diff --git a/.gitignore b/.gitignore
index 529c3af4a51f874e41f916b1c0a84d2efb2a3071..e7a2d8c0eedfe432d9bb58fa02a384b221c86949 100755
--- a/.gitignore
+++ b/.gitignore
@@ -114,4 +114,6 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-md-style
\ No newline at end of file
+md-style
+
+.idea
\ No newline at end of file
diff --git a/cpgzh/actor.py b/cpgzh/actor.py
index c91108894e2a56f2190e9f29014aabf0b7782bf3..6fc72252188e84a22bc73df79992177583bf0d00 100755
--- a/cpgzh/actor.py
+++ b/cpgzh/actor.py
@@ -12,10 +12,10 @@ from .mouse import mouse
 
 
 class Actor(Actor):
-    "角色"
+    """角色"""
 
     def __init__(self, image, pos=POS_TOPLEFT, anchor=ANCHOR_CENTER, **kwargs):
-        "新的角色类"
+        """新的角色类"""
         may_dir = os.path.join(loaders.root, "images", image)
         if os.path.isdir(image):
             self._images = self.__load_dir_images(image)
@@ -39,25 +39,25 @@ class Actor(Actor):
         super().__init__(self._images[0], pos, anchor, **kwargs)
 
     def __load_gif(self, image):
-        "gif动画支持"
+        """gif动画支持"""
         if not os.path.isfile(image):
             image = os.path.join(loaders.root, "images", image)
         images = gif2png(image)
         return images
 
     def __load_dir_images(self, dirname):
-        "加载某个文件夹中的图片"
+        """加载某个文件夹中的图片"""
         if not os.path.isdir(dirname):
             dirname = os.path.join(loaders.root, "images", dirname)
         images = loadimgs(dirname)
         return images
 
     def distance_to(self, actor: Actor):
-        "计算到另一个角色的距离"
+        """计算到另一个角色的距离"""
         return math.dist(actor.pos, self.pos)
 
     def direction_to(self, actor):
-        "计算面向另一个角色的方向"
+        """计算面向另一个角色的方向"""
         dx = actor.x - self.x
         dy = self.y - actor.y
 
@@ -68,7 +68,7 @@ class Actor(Actor):
         return 360 + angle
 
     def move_towards(self, actor, dist):
-        "朝另一个角色移动dist步"
+        """朝另一个角色移动dist步"""
         angle = math.radians(self.direction_to(actor))
         dx = dist * math.cos(angle)
         dy = dist * math.sin(angle)
@@ -76,12 +76,12 @@ class Actor(Actor):
         self.y -= dy
 
     def point_towards(self, actor):
-        "面向另一个角色"
+        """面向另一个角色"""
         print(self.direction_to(actor))
         self.angle = self.direction_to(actor)
 
     def move_in_direction(self, dist):
-        "朝着当前方向移动dist步，不是角色角度"
+        """朝着当前方向移动dist步，不是角色角度"""
         angle = math.radians(self.direction)
         dx = dist * math.cos(angle)
         dy = dist * math.sin(angle)
@@ -89,7 +89,7 @@ class Actor(Actor):
         self.y -= dy
 
     def move_forward(self, dist):
-        "演着角色角度移动dist步"
+        """演着角色角度移动dist步"""
         angle = math.radians(self.angle)
         dx = dist * math.cos(angle)
         dy = dist * math.sin(angle)
@@ -97,7 +97,7 @@ class Actor(Actor):
         self.y -= dy
 
     def move_left(self, dist):
-        "朝当前角度的左边移动dist步"
+        """朝当前角度的左边移动dist步"""
         angle = math.radians(self.angle + 90)
         dx = dist * math.cos(angle)
         dy = dist * math.sin(angle)
@@ -105,7 +105,7 @@ class Actor(Actor):
         self.y -= dy
 
     def move_right(self, dist):
-        "朝当前角度的右边移动dist步"
+        """朝当前角度的右边移动dist步"""
         angle = math.radians(self.angle - 90)
         dx = dist * math.cos(angle)
         dy = dist * math.sin(angle)
@@ -113,7 +113,7 @@ class Actor(Actor):
         self.y -= dy
 
     def move_back(self, dist):
-        "倒退dist步"
+        """倒退dist步"""
         angle = math.radians(self.angle)
         dx = -dist * math.cos(angle)
         dy = -dist * math.sin(angle)
@@ -122,18 +122,18 @@ class Actor(Actor):
 
     @property
     def images(self):
-        "设置造型列表"
+        """设置造型列表"""
         return self._images
 
     @images.setter
     def images(self, images):
-        "设置造型列表"
+        """设置造型列表"""
         self._images = images
         if len(self._images) != 0:
             self.image = self._images[0]
 
     def next_image(self):
-        "下一个造型"
+        """下一个造型"""
         if self.image in self._images:
             current = self._images.index(self.image)
             if current == len(self._images) - 1:
@@ -144,7 +144,7 @@ class Actor(Actor):
             self.image = self._images[0]
 
     def toggle_animate(self):
-        "切换角色是否自动切换造型"
+        """切换角色是否自动切换造型"""
         if self.animate_fps == 0:
             self.animate_fps = 10
         else:
@@ -163,30 +163,80 @@ class Actor(Actor):
                 self._animate_counter = now
                 self.next_image()
 
+    def run_tasks(self):
+        """
+        根据计划任务执行要做的事\n
+        需要放在update函数中执行
+        """
+        now = int(time.time() * self.max_fps)  # 获取当前绝对帧数
+        # 如果任务过期就执行并删除
+        for task_count in list(self.tasks):
+            if task_count <= now:
+                for task_id, func in self.tasks.pop(task_count).items():
+                    func()
+                    # print(f'任务{task_id}执行完毕')
+            else:
+                break
+
+    def create_delay_tasks(self, task, seconds=1, times=1, after=None):
+        """
+        创建任务队列并添加到角色的任务列表中。\n
+        延迟seconds秒执行task任务，times代表这个任务执行多少次。\n
+        只写第一个参数就是等待1秒执行1次task。\n
+        最后一个after参数指的是任务执行完了之后做的事，比如重复执行5次下一个造型后隐藏这样子写：\n
+        a=create_delay_tasks(a.next_image,0.1,5,a.hide)\n
+        """
+        now = time.time()
+        for i in range(times):
+            taskTime = now + (i + 1) * seconds  # 计算执行任务的时间
+            task_count = int(taskTime * self.max_fps)  # 计算计数器走到哪一帧
+            self._task_id += 1
+            # 将任务加到任务队列
+            if task_count in self.tasks:
+                self.tasks[task_count][self._task_id] = task
+            else:
+                self.tasks[task_count] = {self._task_id: task}
+        if after:
+            taskTime = now + (times + 1) * seconds
+            task_count = int(taskTime * self.max_fps)  # 计算计数器走到哪一帧
+            self._task_id += 1
+            # 将任务加到任务队列
+            if task_count in self.tasks:
+                self.tasks[task_count][self._task_id] = after
+            else:
+                self.tasks[task_count] = {self._task_id: after}
+
+    def remove_taskById(self, id):
+        "根据id删掉任务"
+        for i in self.tasks:
+            if id in self.tasks[i]:
+                del self.tasks[i][id]
+                # print(f'任务{id}被取消')
+                break
 
     @property
     def angle(self):
-        "设置角度"
+        """设置角度"""
         return self._angle
 
     @angle.setter
     def angle(self, angle):
-        "设置角度"
+        """设置角度"""
         self._angle = angle
         self._transform_surf()
 
     @property
     def scale(self):
-        "设置缩放"
+        """设置缩放"""
         return self._scale
 
     @scale.setter
     def scale(self, scale):
-        '''
+        """
         设置缩放\n
         设置一个小数将会同时修改x方向和y方向\n
         设置一个(0.4,0.6)这样的元组，将会x方向缩放到0.4倍，y方向缩放到0.6倍
-        '''
+        """
         if type(scale) == float or type(scale) == int:
             self._scale_x = self._scale_y = scale
             self._scale = scale
@@ -199,41 +249,41 @@ class Actor(Actor):
 
     @property
     def flip_x(self):
-        "设置x方向翻转"
+        """设置x方向翻转"""
         return self._flip_x
 
     @flip_x.setter
     def flip_x(self, flip_x):
-        "设置x方向翻转"
+        """设置x方向翻转"""
         self._flip_x = flip_x
         self._transform_surf()
 
     @property
     def flip_y(self):
-        "设置x方向翻转"
+        """设置x方向翻转"""
         return self._flip_y
 
     @flip_y.setter
     def flip_y(self, flip_y):
-        "设置y方向翻转"
+        """设置y方向翻转"""
         self._flip_y = flip_y
         self._transform_surf()
 
     @property
     def image(self):
-        "设置造型"
+        """设置造型"""
         return self._image_name
 
     @image.setter
     def image(self, image):
-        "设置当前造型"
+        """设置当前造型"""
         self._image_name = image
         self._orig_surf = self._surf = loaders.images.load(image)
         self._update_pos()
         self._transform_surf()
 
     def _transform_surf(self):
-        "变换角色的缩放、翻转等"
+        """变换角色的缩放、翻转等"""
         self._surf = self._orig_surf
         p = self.pos
 
@@ -244,11 +294,10 @@ class Actor(Actor):
                              int(size[1] * self._scale_y))
             )
         if self._flip_x or self._flip_y:
-            self._surf = pygame.transform.flip(
-                self._surf, self._flip_x, self._flip_y)
+            self._surf = pygame.transform.flip(self._surf, self._flip_x, self._flip_y)
 
         self._surf = pygame.transform.rotate(self._surf, self._angle)
-        # 应该改成用pygame.transform.rotozoom合并旋转和缩放操作
+        # 应该改成用pygame.transform.rotozoom合并旋转和缩放操作，但是rotozoom只支持横竖统一的缩放率
 
         self.width, self.height = self._surf.get_size()
         w, h = self._orig_surf.get_size()
@@ -260,10 +309,10 @@ class Actor(Actor):
         self._mask = None
 
     def collidepoint_pixel(self, x, y=0):
-        "检测碰撞到某个像素，像素级精确检测"
+        """检测碰撞到某个像素，像素级精确检测"""
         if isinstance(x, tuple):
             x, y = x
-        if self._mask == None:
+        if self._mask is None:
             self._mask = pygame.mask.from_surface(self._surf)
 
         xoffset = int(x - self.left)
@@ -278,9 +327,9 @@ class Actor(Actor):
         return self._mask.get_at((xoffset, yoffset))
 
     def collide_pixel(self, actor):
-        "检测碰撞其他某个角色，返回重叠的坐标，如果没重叠就直接返回None，像素级精确检测"
+        """检测碰撞其他某个角色，返回重叠的坐标，如果没重叠就直接返回None，像素级精确检测"""
         for a in [self, actor]:
-            if a._mask == None:
+            if a._mask is None:
                 a._mask = pygame.mask.from_surface(a._surf)
 
         xoffset = int(actor.left - self.left)
@@ -289,18 +338,17 @@ class Actor(Actor):
         return self._mask.overlap(actor._mask, (xoffset, yoffset))
 
     def collidelist_pixel(self, actors):
-        "检测碰撞角色列表，返回碰撞到的角色的索引，没碰到返回None，像素级精确检测"
+        """检测碰撞角色列表，返回碰撞到的角色的索引，没碰到返回None，像素级精确检测"""
         for i, actor in enumerate(actors):
             if self.collide_pixel(actor):
                 return i
-        return None
 
     def collidelistall_pixel(self, actors):
-        "检测碰撞角色列表，返回值是碰撞到的角色，返回一个列表，如果列表为空说明没碰到，像素级精确检测"
+        """检测碰撞角色列表，返回值是碰撞到的角色，返回一个列表，如果列表为空说明没碰到，像素级精确检测"""
         return list(filter(self.collide_pixel, actors))
 
     def obb_collidepoints(self, actors):
-        "检测多个角色碰撞，旋转了rect，使得rect贴合角色"
+        """检测多个角色碰撞，旋转了rect，使得rect贴合角色"""
         angle = math.radians(self._angle)
         costheta = math.cos(angle)
         sintheta = math.sin(angle)
@@ -320,7 +368,7 @@ class Actor(Actor):
         return -1
 
     def obb_collidepoint(self, x, y=0):
-        "检测碰撞一个点，旋转了rect，使得rect贴合角色"
+        """检测碰撞一个点，旋转了rect，使得rect贴合角色"""
         if isinstance(x, tuple):
             x, y = x
         angle = math.radians(self._angle)
@@ -338,7 +386,7 @@ class Actor(Actor):
         return -half_width < rx < half_width and -half_height < ry < half_height
 
     def circle_collidepoints(self, radius, actors):
-        "检测碰撞一堆点，将角色变成圆形区域，适合于圆形角色的碰撞检测"
+        """检测碰撞一堆点，将角色变成圆形区域，适合于圆形角色的碰撞检测"""
         rSquare = radius ** 2
 
         for i, actor in enumerate(actors):
@@ -350,7 +398,7 @@ class Actor(Actor):
         return -1
 
     def circle_collidepoint(self, radius, x, y=0):
-        "检测碰撞一个点，将角色变成圆形区域，适合于圆形角色的碰撞检测"
+        """检测碰撞一个点，将角色变成圆形区域，适合于圆形角色的碰撞检测"""
         if isinstance(x, tuple):
             x, y = x
         rSquare = radius ** 2
@@ -359,37 +407,39 @@ class Actor(Actor):
         return dSquare < rSquare
 
     def draw(self):
-        "绘图"
+        """绘图"""
         if self.is_draw:
             game.screen.blit(self._surf, self.topleft)
             self.animate()
 
     def get_rect(self):
-        "获取角色的rect"
+        """获取角色的rect"""
         return self._rect
 
     def show(self):
-        "显示角色"
+        """显示角色"""
         self.is_draw = 1
 
     def hide(self):
-        "隐藏"
+        """隐藏"""
         self.is_draw = 0
 
     def face_to(self, pos=None):
-        '''
+        """
         面向一个对象\n
         pos参数不传递则面向鼠标\n
         pos传入一个坐标则面向这个坐标\n
         pos传入一个Actor则面向这个演员\n
-        '''
+        """
         if isinstance(pos, (list, tuple)):
-            x, y = pos[:2]
+            x, y = pos[:2]  # 传入Rect也行
         elif isinstance(pos, Actor):
             x, y = pos.pos
-        else:
+        elif pos is None:
             x, y = mouse.get_pos()
+        else:
+            raise NotImplementedError(pos)
         dx = x - self.x
-        dy = self.y-y
+        dy = self.y - y
         d = math.degrees(math.atan2(dy, dx))
         self.angle = d
diff --git a/cpgzh/animation.py b/cpgzh/animation.py
index c9812174d7a5bb4f0cc6b2164ea0eabd1e5d3763..6a595f36ece109f46afe3ddbbc7bc57fdb2d5efd 100755
--- a/cpgzh/animation.py
+++ b/cpgzh/animation.py
@@ -3,12 +3,12 @@ from pgzero.animation import animate as ani
 
 
 def animate(object, tween='linear', duration=1, on_finished=None, **targets):
-    '''
-    控制角色运动的功能，比如从一个地方运动到另外一个地方。\n  
+    """
+    控制角色运动的功能，比如从一个地方运动到另外一个地方。\n
     object：你要运动的角色(必选)。\n
     pos：终点坐标(必选)。
     tween：运动的方式，linear就是线性的意思，还有：accelerate、decelerate、accel_decel、end_elastic、start_elastic、both_elastic、bounce_end、bounce_start、bounce_start_end等参数可选，请大家自行尝试。\n
     duration：延迟的时间，单位为s。\n
     on_finished：结束后做的事。\n
-    '''
-    ani(object, tween, duration, on_finished, **targets)
+    """
+    return ani(object, tween, duration, on_finished, **targets)
diff --git a/cpgzh/data.py b/cpgzh/data.py
index 478856db342f23b8b816138f235d271c1c1e6775..2f06c8c8bc7f5d53e210a5e5ddf58a5e28dd42b0 100755
--- a/cpgzh/data.py
+++ b/cpgzh/data.py
@@ -4,10 +4,10 @@ import os
 
 
 class Data:
-    '数据存储类'
+    """数据存储类"""
 
-    def __init__(self, data_path) -> None:
-        '数据类'
+    def __init__(self, data_path):
+        """数据类"""
         self.data_path = data_path
 
         self.status = 0  # 游戏状态
@@ -17,20 +17,20 @@ class Data:
         self.start()
 
     def start(self):
-        '启动'
+        """启动"""
+        self.__start = time.time()
+        return self.__start
+
+    def get_time(self):
+        """获取游戏的持续时间"""
         return time.time() - self.__start
 
     @property
     def time(self):
-        '返回时间'
-        return self.get_time()    
-
-    def get_time(self):
-        '获取游戏的持续时间'
-        return time.time()-self.__start
+        return self.get_time()
 
     def save_data(self):
-        '保存数据'
+        """保存数据"""
         try:
             with open(self.data_path, 'wb') as f:
                 pickle.dump(self, f)
@@ -40,19 +40,20 @@ class Data:
             print(f'{self.data_path}保存失败！')
             return 0
 
-    def load_data(cls, path):
-        '加载数据'
+    @classmethod
+    def load_data(cls, path) -> "Data":
+        """加载数据"""
         try:
             with open(path, 'rb') as f:
                 data = pickle.load(f)
-                assert isinstance(data, cls)
+                assert isinstance(data, cls), type(data)
                 return data
         except FileNotFoundError:
             print(f'{path}不存在')
             return cls(path)
 
     def del_data(self):
-        '删除数据'
+        """删除数据"""
         try:
             os.remove(self.data_path)
             print(f'{self.data_path}删除成功')
diff --git a/cpgzh/example.py b/cpgzh/example.py
index 5c3cdc9a4a802a71dfba14d208bd96151787d0fb..d8eccc8463878f90493f288d1a7b6a672693f843 100755
--- a/cpgzh/example.py
+++ b/cpgzh/example.py
@@ -25,15 +25,6 @@ monv.flip_y = 1
 master = Master()
 pen = Pen()
 
-a = 10
-b = 12
-c = a
-a = b
-b = c
-
-a, b = b, a
-
-
 def flushImages():
     "刷新造型列表"
     now = datetime.datetime.now()
diff --git a/cpgzh/getimg.py b/cpgzh/getimg.py
index b1d8eb67ec75610df97f1b0503bb5fbbbc037fb2..e04dc3cb4a5010d9488756f6e24e4cc9939026e2 100755
--- a/cpgzh/getimg.py
+++ b/cpgzh/getimg.py
@@ -5,33 +5,31 @@ from PIL import Image, ImageSequence
 
 
 def gif2png(image):
-    '将gif动画拆解成每一帧png的函数'
-    image_dir=os.path.dirname(image)
-    head,name=os.path.split(image)
-    name=name[:-4]
-    image_dir=os.path.join(image_dir,name)
+    """将gif动画拆解成每一帧png的函数"""
+    image_dir = os.path.dirname(image)
+    head, name = os.path.split(image)
+    name = name[:-4]
+    image_dir = os.path.join(image_dir, name)
     if not os.path.isdir(image_dir):
         os.makedirs(image_dir)
-    img=Image.open(image)
+    img = Image.open(image)
     # 创建读取每一帧的迭代器
-    iter = ImageSequence.Iterator(img)
-    index=1
+    iter_ = ImageSequence.Iterator(img)
     images=[]
-    for i in iter:
-        now_img=os.path.join(image_dir,f"{name}({index}).png")
+    for index, i in enumerate(iter_):
+        now_img = os.path.join(image_dir, f"{name}({index + 1}).png")
         i.save(now_img)
         images.append(now_img)
-        index+=1
     return images
 
 
 
 
 def loadimgs(path):
-    '加载并排序图片'
+    """加载并排序图片"""
     if os.path.isdir(path):
-        new_lists=[]
-        files=os.listdir(path)
+        new_lists = []
+        files = os.listdir(path)
         for file in files:
             if os.path.isfile(os.path.join(path,file)):
                 if file.split(".")[-1] in ["png", "jpg", "jpeg", "gif", "bmp"]:
diff --git a/cpgzh/keys.py b/cpgzh/keys.py
index ba31def904715add597828f234e5133f263f696b..d57ed68662635e909654aedaba2244663301a110 100644
--- a/cpgzh/keys.py
+++ b/cpgzh/keys.py
@@ -1,7 +1,7 @@
 from enum import IntEnum
 
 class keys(IntEnum):
-    '用于获取键盘按键的类'
+    """用于获取键盘按键的类"""
     AC_BACK = 1073742094
     UNKNOWN = 0
     BACKSPACE = 8
@@ -180,7 +180,7 @@ class keymods(IntEnum):
 from warnings import warn
 from pgzero.keyboard import Keyboard
 class Keyboard(Keyboard):
-    '重写获取按键函数'
+    """重写获取按键函数"""
     def __getitem__(self, k):
         if isinstance(k, str):
             warn(
diff --git a/cpgzh/master.py b/cpgzh/master.py
index 3df1bfea1e0a73629af58124ec1bfb1fc62a9ecb..715bafde798e0f6b8f4477c324127898bc15d105 100755
--- a/cpgzh/master.py
+++ b/cpgzh/master.py
@@ -15,83 +15,96 @@ MAX_FPS = 120
 
 
 def round_xy(pos):
-    "四舍五入坐标"
+    """四舍五入坐标"""
     if isinstance(pos, tuple):
         x, y = pos
-        return (round(x), round(y))
+        return round(x), round(y)
     else:
         return round(pos)
 
 
 class Task:
-    '任务类'
+    """任务类"""
 
-    def __init__(self, id, time_count, func, args) -> None:
-        '任务类'
-        self.id = id
+    def __init__(self, id_, time_count, func, *args, init_hp=1, tags=None, **kwargs):
+        """任务类"""
+        self.id = id_
         self.time_count = time_count
         self.__func = func
         self.__args = args
-        self.hp = 1
+        self.hp = init_hp
+        self.tags = tags or {}
+        self.__kwargs = kwargs
 
-    def run(self):
-        '运行任务'
-        if int(time.time()*MAX_FPS) >= self.time_count:
-            self.__func(*self.__args)
-            self.hp = 0
+    def run(self, async_=False):
+        """运行任务"""
+        if int(time.time() * MAX_FPS) >= self.time_count:
+            if async_:  # 执行一些长时间任务时（比如保存转码GIF，读取游戏地图之类），不会阻塞主线程
+                import threading
+                threading.Thread(target=self.__func, args=self.__args, kwargs=self.__kwargs).start()
+            else:
+                self.__func(*self.__args, **self.__kwargs)
+            self.hp -= 1
 
 
 class Master:
-    "管家类，负责一些管理类的功能"
+    """管家类，负责一些管理类的功能"""
 
     def __init__(self, data_path="data.dat") -> None:
-        "管家类，负责一些管理类的功能"
+        """管家类，负责一些管理类的功能"""
         self._fullscreen = False
-        self.data: Data = Data.load_data(Data, data_path)
+        self.data: Data = Data.load_data(data_path)
         self.data.temp = ""
         self.app = App(visible=False)
         self.mod = sys.modules["__main__"]
         self._task_id = 0
-        self.tasks = []
+        self.tasks: list[Task] = []
 
     @property
     def data_path(self):
-        "获取data_path"
+        """获取data_path"""
         return self.data.data_path
 
     @data_path.setter
     def data_path(self, path):
-        "设置data_path"
+        """设置data_path"""
         print(f"数据地址{path}")
         self.data.data_path = path
 
     def load_data(self, new_path=None):
         """加载数据"""
-        self.data: Data = Data.load_data(Data, new_path or self.data_path)
+        self.data: Data = Data.load_data(new_path or self.data_path)
 
     def save_data(self):
-        "保存数据"
+        """保存数据"""
         self.data.save_data()
 
     def del_data(self):
-        "删除数据"
+        """删除数据"""
         self.data.del_data()
 
-    def set_fullscreen(self) -> None:
-        "设置全屏"
+    def set_fullscreen(self):
+        """设置全屏"""
         self.mod.screen.surface = pygame.display.set_mode(
             (self.mod.WIDTH, self.mod.HEIGHT), pygame.FULLSCREEN
         )
         self._fullscreen = True
 
-    def set_windowed(self) -> None:
-        "设置窗口化"
+    def set_windowed(self):
+        """设置窗口化"""
         os.environ['SDL_VIDEO_CENTERED'] = "1"  # pygame设置窗口在中心，实测无效
         self.mod.screen.surface = pygame.display.set_mode(
             (self.mod.WIDTH, self.mod.HEIGHT)
         )
         self._fullscreen = False
 
+    def toggle_fullscreen(self):
+        """切换全屏和窗口化"""
+        if self._fullscreen:
+            self.set_windowed()
+        else:
+            self.set_fullscreen()
+
     @property
     def fullscreen(self):
         return self._fullscreen
@@ -111,14 +124,14 @@ class Master:
         """
         if dtype == 1:
             text = guizero.askstring("输入整数", msg)
-            text = int(text)
+            ans = int(text)
         elif dtype == 2:
-            text = guizero.askstringt("输入小数", msg)
-            text = float(text)
+            text = guizero.askstring("输入小数", msg)
+            ans = float(text)
         else:
-            text = guizero.askstring("输入", msg)
-        self.data.temp = text
-        return text
+            ans = guizero.askstring("输入", msg)
+        self.data.temp = ans
+        return ans
 
     def select_file(self, msg="请选择文件", filetypes=[["All files", "*.*"]]) -> str:
         """
@@ -145,27 +158,30 @@ class Master:
         return path
 
     def select_dir(self, msg="请选择文件夹") -> str:
-        "选择一个文件夹"
+        """选择一个文件夹"""
         dir_ = guizero.select_folder(msg)
         self.data.temp = dir_
         return dir_
 
     def yes_no(self, msg="是否？"):
-        "是否做某件事的选择框"
+        """是否做某件事的选择框"""
         yes_or_no = guizero.yesno("请选择", msg)
         self.data.temp = yes_or_no
         return yes_or_no
 
-    def msg(self, msg="这是提示信息"):
-        "提示信息"
+    @staticmethod
+    def msg(msg="这是提示信息"):
+        """提示信息"""
         guizero.info("提示", msg)
 
-    def warning(self, msg="这是警告信息"):
-        "警告信息"
+    @staticmethod
+    def warning(msg="这是警告信息"):
+        """警告信息"""
         guizero.warn("警告", msg)
 
-    def error(self, msg="这是错误信息"):
-        "错误信息"
+    @staticmethod
+    def error(msg="这是错误信息"):
+        """错误信息"""
         guizero.error("错误", msg)
 
     def run_tasks(self):
@@ -179,10 +195,11 @@ class Master:
             if task.hp:
                 left_tasks.append(task)
         self.tasks = left_tasks
+
         del left_tasks
         gc.collect()  # 释放内存
 
-    def create_delay_tasks(self, task, seconds=1, times=1, args=()):
+    def create_delay_tasks(self, task, seconds=1, times=1, *args, **kwargs):
         """
         创建任务队列并添加到角色的任务列表中。\n
         延迟seconds秒执行task任务，times代表这个任务执行多少次。\n
@@ -195,14 +212,38 @@ class Master:
             time_count = int(task_time * MAX_FPS)  # 计算计数器走到哪一帧
             self._task_id += 1
             # 将任务加到任务队列
-            now_task = Task(self._task_id, time_count, task, args)
+            now_task = Task(self._task_id, time_count, task, *args, **kwargs)
             self.tasks.append(now_task)
 
-    def remove_taskById(self, id):
-        "根据id删掉任务"
+    def remove_tasks_by_tag(self, tag):
+        """删除所有含有该标签的任务，类似抓违章"""
+        self.tasks = [task for task in self.tasks if tag not in task.tags]
+        gc.collect()
+
+    def remain_tasks_by_tag(self, tag):
+        """只保留所有含有该标签的任务，类似免死金牌"""
+        self.tasks = [task for task in self.tasks if tag in task.tags]
+        gc.collect()
+
+    def remove_tasks_by_tags(self, *tags):
+        """删除精确匹配该标签组合的任务，类似通缉令"""
+        tags = {tags} if len(tags) == 1 else set(tags)
+        self.tasks = [task for task in self.tasks if task.tags != tags]
+        gc.collect()
+
+    def remain_tasks_by_tags(self, *tags):
+        """只保留精确匹配该标签组合的任务，暂时没想到用途"""
+        tags = {tags} if len(tags) == 1 else set(tags)
+        self.tasks = [task for task in self.tasks if task.tags == tags]
+        gc.collect()
+
+    def remove_taskById(self, id_):
+        """根据id删掉任务"""
+        import warnings
+        warnings.warn("这个方法将来会变成按标签删除任务", DeprecationWarning)
         del_task = 0
         for task in self.tasks:
-            if task.id == id:
+            if task.id == id_:
                 del_task = task
                 break
         del del_task
diff --git a/cpgzh/mouse.py b/cpgzh/mouse.py
index c733369e4076daf046bd2cdcd56403388bb832ed..a1c64302bd3219da4219319dbb880156d7a5073e 100755
--- a/cpgzh/mouse.py
+++ b/cpgzh/mouse.py
@@ -2,30 +2,30 @@ import pygame
 from pgzero.constants import mouse as mouse_keys
 
 
-class Mouse(object):
-    '鼠标类'
+class Mouse:
+    """鼠标类"""
 
     def __init__(self) -> None:
-        '鼠标类'
+        """鼠标类"""
         self.keys = mouse_keys
 
-    def get_pos(self):
-        '获取鼠标坐标'
+    @staticmethod
+    def get_pos():
+        """获取鼠标坐标"""
         return pygame.mouse.get_pos()
 
+    @staticmethod
     def set_pos(x, y=None):
-        if y == None:
-            pos = x
-        else:
-            pos = (x, y)
-        pygame.mouse.set_pos(pos)
-
-    def hide(self) -> None:
-        "隐藏鼠标"
+        pygame.mouse.set_pos(x, y)
+
+    @staticmethod
+    def hide() -> None:
+        """隐藏鼠标"""
         pygame.mouse.set_visible(False)
 
-    def show(self) -> None:
-        "显示鼠标"
+    @staticmethod
+    def show() -> None:
+        """显示鼠标"""
         pygame.mouse.set_visible(True)
 
 
diff --git a/cpgzh/runner.py b/cpgzh/runner.py
index e67460845a9e17c1f76eb3704fb2f42c6c3226e4..147120d3e9931eaff09388616eb5fc57280171e4 100755
--- a/cpgzh/runner.py
+++ b/cpgzh/runner.py
@@ -58,6 +58,6 @@ def go():
 
 
 def get_screen():
-    "返回当前游戏所在的屏幕"
+    """返回当前游戏所在的屏幕"""
     mod = sys.modules["__main__"]
     return mod.screen