Недо-третьи шаги котика

import pygame as pg
import random
from math import sin

RESOLUTION = (1600, 900)
FPS = 144


WHITE = (255, 255, 255)
BLACK = (0,   0,   0)
BG_COLOR = (95, 75, 102)  # lightskyblue

# PICS
CAT = 'cat.png'
PEPEGA = 'pepega.png'
RAT = 'rat.png'
COIN_SILVER = 'silver.png'
COIN_GOLD = 'gold.png'


class Cat_abstract:
    def __init__(self, x = 0, y = 0, size = 100, speed = 10, img = CAT):
        self.size = size
        self.x = x
        self.y = y
        self.speed = speed
        self.img = pg.image.load(img)
        self.img = pg.transform.scale(self.img, (self.size, self.size))

    def draw(self, surface):
        surface.blit(self.img, (self.x, self.y))

    def border_check(self):
        if self.x > RESOLUTION[0] - (self.size // 2):
            self.x = 0 - (self.size // 2)
        if self.x < 0 - (self.size // 2):
            self.x = RESOLUTION[0] - (self.size // 2)

        if self.y > RESOLUTION[1] - (self.size // 2):
            self.y = 0 - (self.size // 2)
        if self.y < 0 - (self.size // 2):
            self.y = RESOLUTION[1] - (self.size // 2)

    def update(self, *args):
        pass

class Coin_abstract:
    def __init__(self, x = 0, y = 0, size = 100, maxspeed = 3, img = COIN_SILVER):
        self.size = size
        self.x = random.randint(0 + self.size, RESOLUTION[0] - self.size)
        self.y = random.randint(0 - self.size, RESOLUTION[1] + self.size)
        self.img = pg.image.load(img)
        self.img = pg.transform.scale(self.img, (self.size, self.size))

    def draw(self, surface):
        surface.blit(self.img, (self.x, self.y))

    def update(self, *args):
        pass


# class Coin(Coin_abstract):
#     def __init__(self, x = 0, y = 0, size = 300, img = COIN_SILVER):
#         Coin_abstract.__init__(self, size, x, y, img)
#         self.x = random.randint(self.size, RESOLUTION[0])
#         self.y = random.randint(self.size, RESOLUTION[1])

#     def update(self, *args):
#         return



class Cat_random(Cat_abstract):
    def __init__(self, x = 0, y = 0, size = 100, speed = 10, img = PEPEGA):
        Cat_abstract.__init__(self, x, y, size, speed, img)

    def update(self, *args):
        dx = random.randint(-10, 10)
        dy = random.randint(-10, 10)
        self.x += dx
        self.y += dy
        self.border_check()



class Cat_border(Cat_abstract):
    def __init__(self, x = 0, y = 0, size = 100, speed = 5, img = RAT):
        Cat_abstract.__init__(self, x, y, size, speed, img)
        self.rat_facing = 'right'

    def update(self, *args):
        if self.rat_facing == 'right':
            if self.x < RESOLUTION[0] - self.size:
                self.x += self.speed
            else:
                self.rat_facing = 'down'
        if self.rat_facing == 'down':
            if self.y < RESOLUTION[1] - self.size:
                self.y += self.speed
            else:
                self.rat_facing = 'left'
                self.img = pg.transform.flip(self.img, True, False)
        if self.rat_facing == 'left':
            if self.x > 0:
                self.x -= self.speed
            else:
                self.rat_facing = 'up'
        if self.rat_facing == 'up':
            if self.y > 0:
                self.y -= self.speed
            else:
                self.rat_facing = 'right'
                self.img = pg.transform.flip(self.img, True, False)



class Cat_player(Cat_abstract):
    def __init__(self, x = 0, y = 0, size = 100, speed = 5, img = CAT):
        Cat_abstract.__init__(self, x, y, size, speed, img)

    def update(self, up, down, left, right):
        if left == right:
            pass
        elif left:
            self.x -= self.speed
        else:
            self.x += self.speed
        if up == down:
            pass
        elif up:
            self.y -= self.speed
        else:
            self.y += self.speed
        self.border_check()


class Game:
    def __init__(self):
        pg.init()
        self.display = pg.display.set_mode(RESOLUTION)
        pg.display.set_caption('Вторые шаги котика')
        self.clock = pg.time.Clock()
        self.running = True
        self.down = self.up = self.left = self.right = False
        self.cat = Cat_player(size=200)
        self.cat_random = Cat_random(size=200)
        self.cat_border = Cat_border(size=200)
        self.coin = Coin(size=300)

    def run(self):
        while self.running:
            self.events()
            self.update()
            self.render()

    def events(self):
        events = pg.event.get()
        for event in events:
            if event.type == pg.QUIT:
                self.running = False
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_s:
                    self.down = True
                if event.key == pg.K_w:
                    self.up = True
                if event.key == pg.K_a:
                    self.left = True
                if event.key == pg.K_d:
                    self.right = True
            if event.type == pg.KEYUP:
                if event.key == pg.K_s:
                    self.down = False
                if event.key == pg.K_w:
                    self.up = False
                if event.key == pg.K_a:
                    self.left = False
                if event.key == pg.K_d:
                    self.right = False
                if event.key == pg.K_ESCAPE:
                    self.running = False

    def update(self):
        self.clock.tick(FPS)
        self.cat.update(self.up, self.down, self.left, self.right)
        self.cat_random.update(self.up, self.down, self.left, self.right)
        self.cat_border.update(self.up, self.down, self.left, self.right)
        self.coin.update(self.up, self.down)

    def render(self):
        self.display.fill(BG_COLOR)
        self.coin.draw(self.display)
        self.cat.draw(self.display)
        self.cat_random.draw(self.display)
        self.cat_border.draw(self.display)
        pg.display.update()


if __name__ == '__main__':
    game = Game()
    game.run()