From 1170f1521c7f0a617e06b8fa8835bb882cde8378 Mon Sep 17 00:00:00 2001 From: themixray <35273590+themixray@users.noreply.github.com> Date: Tue, 2 Nov 2021 13:25:13 +0300 Subject: [PATCH] Add files via upload --- pygwin/__init__.py | 13 +++ pygwin/_pg.py | 16 +++ pygwin/_win.py | 91 ++++++++++++++++ pygwin/events.py | 4 + pygwin/font.py | 45 ++++++++ pygwin/gamepad.py | 260 +++++++++++++++++++++++++++++++++++++++++++++ pygwin/image.py | 42 ++++++++ pygwin/keyboard.py | 10 ++ pygwin/mixer.py | 92 ++++++++++++++++ pygwin/mouse.py | 21 ++++ pygwin/rect.py | 34 ++++++ pygwin/surface.py | 136 ++++++++++++++++++++++++ 12 files changed, 764 insertions(+) create mode 100644 pygwin/__init__.py create mode 100644 pygwin/_pg.py create mode 100644 pygwin/_win.py create mode 100644 pygwin/events.py create mode 100644 pygwin/font.py create mode 100644 pygwin/gamepad.py create mode 100644 pygwin/image.py create mode 100644 pygwin/keyboard.py create mode 100644 pygwin/mixer.py create mode 100644 pygwin/mouse.py create mode 100644 pygwin/rect.py create mode 100644 pygwin/surface.py diff --git a/pygwin/__init__.py b/pygwin/__init__.py new file mode 100644 index 0000000..3155edf --- /dev/null +++ b/pygwin/__init__.py @@ -0,0 +1,13 @@ +from pygwin.surface import surface +import pygwin.keyboard as keyboard +import pygwin.gamepad as _gp +import pygwin.mouse as mouse +from pygwin.rect import rect +import pygwin.image as image +import pygwin.mixer as mixer +from pygwin.events import * +from pygame.locals import * +from pygwin.font import * +from pygwin._win import * +from pygwin._pg import pg +gamepad = _gp.gamepad(pg) diff --git a/pygwin/_pg.py b/pygwin/_pg.py new file mode 100644 index 0000000..b8aa9e7 --- /dev/null +++ b/pygwin/_pg.py @@ -0,0 +1,16 @@ +from contextlib import contextmanager as _cm +import os as _os +import sys as _sys + +@_cm +def _suppress_stdout(): + with open(_os.devnull, "w") as devnull: + old_stdout = _sys.stdout + _sys.stdout = devnull + try: + yield + finally: + _sys.stdout = old_stdout +with _suppress_stdout(): + import pygame as pg + pg.init() diff --git a/pygwin/_win.py b/pygwin/_win.py new file mode 100644 index 0000000..45dc584 --- /dev/null +++ b/pygwin/_win.py @@ -0,0 +1,91 @@ +from pygwin.surface import surface as _surface +from datetime import datetime as _dt +from pygwin._pg import pg as _pg +import win32job as _w32j +import win32api as _w32a + +class win(_surface): + def __init__(self): + self._orig = _pg.display.get_surface() + super().__init__(self._orig.get_size()) + self._orig = _pg.display.get_surface() + self._clock = _pg.time.Clock() + self._withfps = False + def update(self, fps=-1): + if fps != -1: + self._clock.tick(fps) + self._withfps = True + _pg.display.update() + def title(self, title): + _pg.display.set_caption(title) + def icon(self, path): + _pg.display.set_icon(_pg.image.load(path)) + def resize(self, size): + _pg.display.set_mode(size) + def fullscreen(self): + _pg.display.toogle_fullscreen() + def close(self): + _pg.display.quit() + @property + def rawFps(self): + if self._withfps: + return self._clock.get_fps() + else: + return float(f'2010.{_dt.now().year}') + @property + def fps(self): + return int(self.rawFps) + @property + def hwnd(self): + return _pg.display.get_wm_info()['window'] + +def create(title=None, size=(0,0), icon=None): + screen = _pg.display.set_mode(size) + if title != None: _pg.display.set_caption(title) + if icon != None: _pg.display.set_icon(_pg.image.load(icon)) + return win() + +def ramLimit(bytes): + def create_job(job_name='', breakaway='silent'): + hjob = _w32j.CreateJobObject(None, job_name) + if breakaway: + info = _w32j.QueryInformationJobObject(hjob, + _w32j.JobObjectExtendedLimitInformation) + if breakaway == 'silent': + info['BasicLimitInformation']['LimitFlags'] |= ( + _w32j.JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK) + else: + info['BasicLimitInformation']['LimitFlags'] |= ( + _w32j.JOB_OBJECT_LIMIT_BREAKAWAY_OK) + _w32j.SetInformationJobObject(hjob, + _w32j.JobObjectExtendedLimitInformation, info) + return hjob + def assign_job(hjob): + global g_hjob + hprocess = _w32a.GetCurrentProcess() + try: + _w32j.AssignProcessToJobObject(hjob, hprocess) + g_hjob = hjob + except _w32j.error as e: + if (e.winerror != winerror.ERROR_ACCESS_DENIED or + sys.getwindowsversion() >= (6, 2) or + not _w32j.IsProcessInJob(hprocess, None)): + raise + warnings.warn('The process is already in a job. Nested jobs are not ' + 'supported prior to Windows 8.') + def limit_memory(memory_limit): + if g_hjob is None: + return + info = _w32j.QueryInformationJobObject(g_hjob, + _w32j.JobObjectExtendedLimitInformation) + info['ProcessMemoryLimit'] = memory_limit + info['BasicLimitInformation']['LimitFlags'] |= ( + _w32j.JOB_OBJECT_LIMIT_PROCESS_MEMORY) + _w32j.SetInformationJobObject(g_hjob, + _w32j.JobObjectExtendedLimitInformation, info) + assign_job(create_job()) + limit_memory(bytes) + +def close(): + _pg.quit() + quit() diff --git a/pygwin/events.py b/pygwin/events.py new file mode 100644 index 0000000..2a76292 --- /dev/null +++ b/pygwin/events.py @@ -0,0 +1,4 @@ +from pygwin._pg import pg as _pg + +def getEvents(): + return _pg.event.get() diff --git a/pygwin/font.py b/pygwin/font.py new file mode 100644 index 0000000..9b1cdf2 --- /dev/null +++ b/pygwin/font.py @@ -0,0 +1,45 @@ +from pygwin.surface import surface as _surface +from pygwin._pg import pg as _pg + +class font: + def __init__(self, path): + self._path = path + def _font(self, size): + return _pg.font.Font(self._path,size) + def render(self, text, size, color, newLineSpace=5, + italic=False, bold=False, underline=False): + text = str(text) + font = self._font(size) + font.set_italic(italic) + font.set_bold(bold) + font.set_underline(underline) + if text.replace('\n', '') != text: + text = text.split('\n') + surf = _pg.Surface([ + font.size(max(text, key=len))[0], + (font.size('123')[1]+newLineSpace)*len(text)], + pygame.SRCALPHA) + y = 0 + for i in text: + r = font.render(i, True, color) + surf.blit(r, (r.get_rect(center=(int(surf.get_width()/2),y)).x, y)) + y += font.size(i)[1] + if i != text[-1]: + y += newLineSpace + else: + surf = font.render(text, True, color) + surface = _surface(surf.get_size()) + surface._surface_orig = surf + return surface + def size(self, text, size, newLineSpace=5, + italic=False, bold=False, underline=False): + return self.render(text, size, (255,255,255), + newLineSpace=newLineSpace, + italic=italic, bold=bold, + underline=underline).size + +class sysFont(font): + def __init__(self, name): + self._path = _pg.font.match_font(name) + +defaultFont = font(_pg.font.get_default_font()) diff --git a/pygwin/gamepad.py b/pygwin/gamepad.py new file mode 100644 index 0000000..c023573 --- /dev/null +++ b/pygwin/gamepad.py @@ -0,0 +1,260 @@ +import inputs as _inputs +import threading as _threading +import time as _time + +class gamepad: + def __init__(self, pygame): + self._lasty = '' + self._lastx = '' + self.founded = False + self.buttons = [] + self.leftJoystick = [0, 0] + self.rightJoystick = [0, 0] + self._pygame = pygame + self.start() + def _tick(self): + events = _inputs.get_gamepad() + if not self._pygame.display.get_active():return + self.founded = True + temp = [] + for x in self.buttons: + if x not in temp: + temp.append(x) + self.buttons = temp + if events: + for event in events: + if event.code == 'ABS_X': + self.leftJoystickCallback(x=event.state) + self.leftJoystick[0] = event.state + elif event.code == 'ABS_Y': + self.leftJoystickCallback(y=event.state) + self.leftJoystick[1] = event.state + elif event.code == 'ABS_RY': + self.rightJoystickCallback(y=event.state) + self.rightJoystick[1] = event.state + elif event.code == 'ABS_RX': + self.rightJoystickCallback(x=event.state) + self.rightJoystick[0] = event.state + elif event.code == 'BTN_THUMBL': + if event.state: + self.leftJoystickPressCallback() + self.buttons.append('left-joystick') + else: + self.leftJoystickReleaseCallback() + try: + self.buttons.remove('left-joystick') + except: + pass + elif event.code == 'BTN_THUMBR': + if event.state: + self.rightJoystickPressCallback() + self.buttons.append('right-joystick') + else: + self.rightJoystickReleaseCallback() + try: + self.buttons.remove('right-joystick') + except: + pass + elif event.code == 'BTN_TL': + if event.state: + self.L1PressCallback() + self.buttons.append('l1') + else: + self.L1ReleaseCallback() + try: + self.buttons.remove('l1') + except: + pass + elif event.code == 'BTN_TR': + if event.state: + self.R1PressCallback() + self.buttons.append('r1') + else: + self.R1ReleaseCallback() + try: + self.buttons.remove('r1') + except: + pass + elif event.code == 'ABS_Z': + if event.state == 255: + self.L2PressCallback() + self.buttons.append('l2') + elif event.state == 0: + self.L2ReleaseCallback() + try: + self.buttons.remove('l2') + except: + pass + elif event.code == 'ABS_RZ': + if event.state == 255: + self.R2PressCallback() + self.buttons.append('r2') + elif event.state == 0: + self.R2ReleaseCallback() + try: + self.buttons.remove('r2') + except: + pass + elif event.code == 'BTN_WEST': + if event.state: + self.westPressCallback() + self.buttons.append('west') + else: + self.westReleaseCallback() + try: + self.buttons.remove('west') + except: + pass + elif event.code == 'BTN_NORTH': + if event.state: + self.northPressCallback() + self.buttons.append('north') + else: + self.northReleaseCallback() + try: + self.buttons.remove('north') + except: + pass + elif event.code == 'BTN_EAST': + if event.state: + self.eastPressCallback() + self.buttons.append('east') + else: + self.eastReleaseCallback() + try: + self.buttons.remove('east') + except: + pass + elif event.code == 'BTN_SOUTH': + if event.state: + self.southPressCallback() + self.buttons.append('south') + else: + self.southReleaseCallback() + try: + self.buttons.remove('south') + except: + pass + elif event.code == 'ABS_HAT0Y': + if event.state == 1: + self.downPressCallback() + self.buttons.append('down') + self._lasty = 'down' + elif event.state == -1: + self.upPressCallback() + self.buttons.append('up') + self._lasty = 'up' + else: + if self._lasty == 'up': + self.upReleaseCallback() + try: + self.buttons.remove('up') + except: + pass + elif self._lasty == 'down': + self.downReleaseCallback() + try: + self.buttons.remove('down') + except: + pass + elif event.code == 'ABS_HAT0X': + if event.state == 1: + self.rightPressCallback() + self.buttons.append('right') + self._lastx = 'right' + elif event.state == -1: + self.leftPressCallback() + self.buttons.append('left') + self._lastx = 'left' + else: + if self._lastx == 'right': + self.rightReleaseCallback() + try: + self.buttons.remove('right') + except: + pass + elif self._lastx == 'left': + self.leftReleaseCallback() + try: + self.buttons.remove('left') + except: + pass + elif event.code == 'BTN_START': + if event.state: + self.selectPressCallback() + self.buttons.append('select') + else: + self.selectReleaseCallback() + try: + self.buttons.remove('select') + except: + pass + elif event.code == 'BTN_SELECT': + if event.state: + self.startPressCallback() + self.buttons.append('start') + else: + self.startReleaseCallback() + try: + self.buttons.remove('start') + except: + pass + def start(self): + # def exc(self): + # if self.founded == False: + # raise Exception('Gamepad not found!') + # _threading._timer(10, lambda: exc(self)).start() + self.founded = False + self._started = True + def ttcb(self): + while self._started: + self._tick() + _threading.Thread(target=lambda:ttcb(self), + daemon=True).start() + def _stop(self): + self._started = False + def isPressed(self, btn): + return btn in self.buttons + def reset(self): + self._lasty = '' + self._lastx = '' + self.buttons = [] + self.leftJoystick = [0, 0] + self.rightJoystick = [0, 0] + def getPressed(self): + return self.buttons + # def leftJoystickCallback(self, x=None, y=None): pass + # def rightJoystickCallback(self, x=None, y=None): pass + # def leftJoystickPressCallback(self): pass + # def leftJoystickReleaseCallback(self): pass + # def rightJoystickPressCallback(self): pass + # def rightJoystickReleaseCallback(self): pass + # def L1PressCallback(self): pass + # def L1ReleaseCallback(self): pass + # def R1PressCallback(self): pass + # def R1ReleaseCallback(self): pass + # def R2PressCallback(self): pass + # def R2ReleaseCallback(self): pass + # def L2PressCallback(self): pass + # def L2ReleaseCallback(self): pass + # def westPressCallback(self): pass + # def westReleaseCallback(self): pass + # def northPressCallback(self): pass + # def northReleaseCallback(self): pass + # def eastPressCallback(self): pass + # def eastReleaseCallback(self): pass + # def southPressCallback(self): pass + # def southReleaseCallback(self): pass + # def southReleaseCallback(self): pass + # def selectPressCallback(self): pass + # def selectReleaseCallback(self): pass + # def startPressCallback(self): pass + # def startReleaseCallback(self): pass + # def upPressCallback(self): pass + # def upReleaseCallback(self): pass + # def downPressCallback(self): pass + # def downReleaseCallback(self): pass + # def leftPressCallback(self): pass + # def leftReleaseCallback(self): pass + # def rightPressCallback(self): pass + # def rightReleaseCallback(self): pass diff --git a/pygwin/image.py b/pygwin/image.py new file mode 100644 index 0000000..3691621 --- /dev/null +++ b/pygwin/image.py @@ -0,0 +1,42 @@ +from pygwin._pg import pg as _pg +from pygwin.surface import surface as _surface +from PIL import Image as _image +import pickle as _p + +def load(path): + if path.endswith('.gif'): + im = Image.open(path) + surfs = [] + for i in range(im.n_frames): + im.seek(i) + image = _pg.image.fromstring(im.tobytes(),im.size,im.mode) + surf = _surface(image.get_size()) + surf._surface_orig = image + surfs.append(surf) + return surfs + else: + image = _pg.image.load(path) + surf = _surface(image.get_size()) + surf._surface_orig = image + return surf + +def save(surface, path): + if type(surface) == _surface: + orig = surface._surface_orig + else: + orig = surface._orig + _pg.image.save_extended(orig, path) + +def toString(surface): + if type(surface) == _surface: + orig = surface._surface_orig + else: + orig = surface._orig + return _p.dumps([_pg.image.tostring(orig, "RGBA"), list(surface.size)]) + +def fromString(string): + string = _p.loads(string) + surf = _pg.image.fromstring(string[0], tuple(string[1]), "RGBA") + surface = _surface(tuple(string[1])) + surface._surface_orig = surf + return surface diff --git a/pygwin/keyboard.py b/pygwin/keyboard.py new file mode 100644 index 0000000..9d55d95 --- /dev/null +++ b/pygwin/keyboard.py @@ -0,0 +1,10 @@ +from pygwin._pg import pg as _pg + +def getPressed(): + fkeys = {} + keys = _pg.key.get_pressed() + for i in range(len(keys)): + fkeys.update({_pg.key.name(i):keys[i]}) + return fkeys +def isPressed(key): + return getPressed()[key] diff --git a/pygwin/mixer.py b/pygwin/mixer.py new file mode 100644 index 0000000..a33522b --- /dev/null +++ b/pygwin/mixer.py @@ -0,0 +1,92 @@ +from pygwin._pg import pg as _pg +import os as _os +import tempfile as _tf + +ffmpeg = None + +class sound: + def __init__(self, path): + if not (path.endswith('.wav') or path.endswith('.ogg')): + try: + from pydub import AudioSegment as _as + if ffmpeg != None: + _as.ffmpeg = ffmpeg + _as.converter = ffmpeg + sound = _as.from_file(path, _os.path.splitext(path)[1]) + path = _tf.mkstemp('.wav') + sound.export(path, format="wav") + except: + print('Set ffmpeg to path so that you don'+\ + "'t have to convert the file to "+\ + '".wav". If you have installed, but the error still appears, write down the path to ffmpeg.exe in plugin.ffmpeg.') + self._sound = _pg.mixer.Sound(path) + def play(self): + self._sound.play() + def stop(self): + self._sound.stop() + def volume(): + def fget(self): + return self._sound.get_volume() + def fset(self, value): + if type(value) == int: + self._sound.set_volume(value) + def fdel(self): + pass + return locals() + volume = property(**volume()) + @property + def length(self): + return self._sound.get_length() + +class music: + def __init__(self, path): + if path.endswith('.wav') or path.endswith('.ogg'): + self._path = path + else: + try: + from pydub import AudioSegment as _as + if ffmpeg != None: + _as.ffmpeg = ffmpeg + _as.converter = ffmpeg + sound = _as.from_file(path, _os.path.splitext(path)[1]) + path = _tf.mkstemp('.wav') + sound.export(path, format="wav") + except: + print('Set ffmpeg to path so that you don'+\ + "'t have to convert the file to "+\ + '".wav". If you have installed, but the error still appears, write down the path to ffmpeg.exe in plugin.ffmpeg.') + _pg.mixer.music.load(path) + def play(self, loops=0): + _pg.mixer.music.play(loops) + def stop(self): + _pg.mixer.music.stop() + def restart(self): + _pg.mixer.music.rewind() + def pause(self): + _pg.mixer.music.pause() + def release(self): + _pg.mixer.music.unpause() + def queue(self): + _pg.mixer.music.queue(self._path) + + def volume(): + def fget(self): + return _pg.mixer.music.get_volume() + def fset(self, value): + if type(value) == int: + _pg.mixer.music.set_volume(value) + def fdel(self): + pass + return locals() + volume = property(**volume()) + + def pos(): + def fget(self): + return _pg.mixer.music.get_pos() + def fset(self, value): + if type(value) == int: + _pg.mixer.music.set_pos(value) + def fdel(self): + pass + return locals() + pos = property(**pos()) diff --git a/pygwin/mouse.py b/pygwin/mouse.py new file mode 100644 index 0000000..f956532 --- /dev/null +++ b/pygwin/mouse.py @@ -0,0 +1,21 @@ +from pygwin._pg import pg as _pg + +def isPressed(x): + return _pg.mouse.get_pressed()[x] +def getPressed(): + return _pg.mouse.get_pressed() +def setPosition(x): + _pg.mouse.set_pos(x) +def getPosition(): + return _pg.mouse.get_pos() +def setVisible(x): + _pg.mouse.set_visible(x) +def getVisible(): + return _pg.mouse.get_visible() +def getCursor(): + return _pg.mouse.get_cursor() +def setCursor(size, hotspot=None, xormasks=None, andmasks=None): + if hotspot == None and xormasks == None and andmasks == None: + _pg.mouse.set_system_cursor(size) + else: + _pg.mouse.set_cursor(size, hotspot, xormasks, andmasks) diff --git a/pygwin/rect.py b/pygwin/rect.py new file mode 100644 index 0000000..875f5a9 --- /dev/null +++ b/pygwin/rect.py @@ -0,0 +1,34 @@ +from pygwin._pg import pg + +class rect: + def __init__(self,x,y,w,h): + self.x = x + self.y = y + self.w = w + self.h = h + def width(): + def fget(self): + return self.w + def fset(self, value): + self.w = value + def fdel(self): + pass + return locals() + width = property(**width()) + def height(): + def fget(self): + return self.h + def fset(self, value): + self.h = value + def fdel(self): + pass + return locals() + height = property(**height()) + def contains(self, xorect, y=None): + if type(xorect) == rect and y == None: + return pg.Rect(self.x,self.y, + self.w,self.h).contains(pg.Rect( + xorect.x,xorect.y,xorect.w,xorect.h)) + elif type(xorect) != rect and y != None: + return pg.Rect(self.x,self.y,self.w, + self.h).collidepoint((xorect,y)) diff --git a/pygwin/surface.py b/pygwin/surface.py new file mode 100644 index 0000000..b91083e --- /dev/null +++ b/pygwin/surface.py @@ -0,0 +1,136 @@ +from pygwin._pg import pg as _pg + +class surface: + def __init__(self, size): + self._size = size + self._orig = _pg.Surface(size, _pg.SRCALPHA) + self._pixels = [] + # self._pixels = [] + # pxls = _pg.PixelArray(self._orig) + # for x in range(self.size[0]): + # self._pixels.append([]) + # for y in range(self.size[1]): + # self._pixels[x].append(pxls[x, y]) + @property + def pixels(self): + pixels = [] + pxls = _pg.PixelArray(self._orig) + for x in range(self.size[0]): + pixels.append([]) + for y in range(self.size[1]): + pixels[x].append(pxls[x, y]) + return pixels + @property + def size(self): + return self._size + def copy(self): + surf = surface(self.size) + surf._surface_orig = self._orig + return surf + def getPixel(self, x, y): + # return self._pixels[x][y] + return self._orig.get_at((x,y)) + def setPixel(self, x, y, color): + self._orig.set_at((x,y),color) + return self.copy() + def blit(self, surf, xy): + if type(surf) != surface: + from pygwin.font import defaultFont as _df + surf = _df.render(surf, 25, (0,0,0)) + self._orig.blit(surf._surface_orig, xy) + return self.copy() + def fill(self, color): + self._orig.fill(color) + # self._pixels = [] + # for x in range(self.size[0]): + # self._pixels.append([]) + # for y in range(self.size[1]): + # self._pixels[x].append(color) + return self.copy() + def crop(self, rect): + self._orig = self._orig.subsurface((rect.x,rect.y,rect.w,rect.h)) + self._size = self._orig.get_size() + return self.copy() + def scale(self, rect): + self._orig = _pg.transform.scale(self._orig, (rect.w, rect.h)) + self._size = self._orig.get_size() + return self.copy() + def rotate(self, angle): + self._orig = _pg.transform.rotate(self._orig, angle) + self._size = self._orig.get_size() + return self.copy() + def flip(self, x, y): + self._orig = _pg.transform.flip(self._orig, x, y) + return self.copy() + def blur(self, amt): + if amt < 0: + return self.copy() + scale = (int(self._orig.get_width()*(amt+1)),int(self._orig.get_height()[1]*(amt+1))) + self._orig = _pg.transform.smoothscale(self._orig,scale) + self._orig = _pg.transform.smoothscale(self._orig,self._orig.get_size()) + return self.copy() + class _draw: + def __init__(self,surface): + self._surf = surface + def rect(self,color,rect, + width=0,borderRadius=0, + borderTopLeftRadius=-1, + borderTopRightRadius=-1, + borderBottomLeftRadius=-1, + borderBottomRightRadius=-1): + if type(self._surf) == surface: + orig = self._surf._surface_orig + else: + orig = self._surf._orig + _pg.draw.rect(orig,color,_pg.Rect(rect.x,rect.y,rect.w,rect.h), + width,borderRadius,borderTopLeftRadius, + borderTopRightRadius,borderBottomLeftRadius, + borderBottomRightRadius) + return self._surf.copy() + def polygon(self, color, points, width=0): + if type(self._surf) == surface: + orig = self._surf._surface_orig + else: + orig = self._surf._orig + _pg.draw.polygon(orig,color,points,width) + return self._surf.copy() + def circle(self,color,center, + radius,width=0, + drawTopLeft=None, + drawTopRight=None, + drawBottomLeft=None, + drawBottomRight=None): + if type(self._surf) == surface: + orig = self._surf._surface_orig + else: + orig = self._surf._orig + _pg.draw.circle(orig,color,center,radius, + width,drawTopRight,drawTopLeft, + drawBottomLeft,drawBottomRight) + return self._surf.copy() + def ellipse(self,color,rect,width=0): + if type(self._surf) == surface: + orig = self._surf._surface_orig + else: + orig = self._surf._orig + _pg.draw.ellipse(orig,color,_pg.Rect(rect.x,rect.y,rect.w,rect.h),width) + return self._surf.copy() + def line(self,color,start,end,width=1): + if type(self._surf) == surface: + orig = self._surf._surface_orig + else: + orig = self._surf._orig + _pg.draw.line(orig,color,start,end,width) + return self._surf.copy() + def arc(self,color,rect,startAngle,stopAngle,width=1): + if type(self._surf) == surface: + orig = self._surf._surface_orig + else: + orig = self._surf._orig + _pg.draw.arc(orig,color, + _pg.Rect(rect.x,rect.y,rect.w,rect.h), + startAngle,stopAngle,width) + return self._surf.copy() + @property + def draw(self): + return self._draw(self)