【Python/tkinter】横スクロールアクションゲームを作る（より詳細な当たり判定）

class Character:

	def prepareImage(self, path, size, is_right=True):

		#略

		resized_image = image.resize(resize_size)
		mirrored_image = ImageOps.mirror(resized_image)

		#↓これを追加
		resized_channels = resized_image.split()
		if len(resized_channels) == 4:
			resized_alpha = resized_channels[3]
		else:
			resized_alpha = Image.new("L", (resized_image.width, resized_image.height), 255)

		mirrored_channels = mirrored_image.split()
		if len(mirrored_channels) == 4:
			mirrored_alpha = mirrored_channels[3]
		else:
			mirrored_alpha = Image.new("L", (mirrored_image.width, mirrored_image.height), 255)
		#↑これを追加

		#略

class Character:

	def prepareImage(self, path, size, is_right=True):

		#略

		if is_right:
			self.right_image = ImageTk.PhotoImage(resized_image)
			self.left_image = ImageTk.PhotoImage(mirrored_image)

			#↓これを追加
			self.right_alpha = resized_alpha.getdata()
			self.left_alpha = mirrored_alpha.getdata()
			#↑これを追加
		else:
			self.left_image = ImageTk.PhotoImage(resized_image)
			self.right_image = ImageTk.PhotoImage(mirrored_image)

			#↓これを追加
			self.left_alpha = resized_alpha.getdata()
			self.right_alpha = mirrored_alpha.getdata()
			#↑これを追加

class Character:

	#↓これを追加
	def getAlpha(self):
		if self.direction == Character.DIRECTION_RIGHT:
			return self.right_alpha
		elif self.direction == Character.DIRECTION_LEFT:
			return self.left_alpha
	#↑これを追加

class Character:

	def isCollided(self, opponent):
		if self.state == Character.STATE_CLEAR or self.state == Character.STATE_DEFEATED:
			return False
		if opponent.state == Character.STATE_CLEAR or opponent.state == Character.STATE_DEFEATED:
			return False

		sx = max(self.x, opponent.x)
		sy = max(self.y, opponent.y)
		ex = min(self.x + self.width, opponent.x + opponent.width)
		ey = min(self.y + self.height, opponent.y + opponent.height)

		if sx < ex and sy < ey:

			#↓これは削除
			#return True
			#↑これは削除

			#↓これを追加
			character_alpha = self.getAlpha()
			opponent_alpha = opponent.getAlpha()

			for y in range(sy, ey):
				for x in range(sx, ex):

					character_x = x - self.x
					character_y = y - self.y
					opponent_x = x - opponent.x
					opponent_y = y - opponent.y

					character_pos = character_y * self.width + character_x
					opponent_pos = opponent_y * opponent.width + opponent_x

					if character_alpha[character_pos] == 255:
						if opponent_alpha[opponent_pos] == 255:
							return True

			return False
			#↑これを追加

		else:
			False

class Character:

	def isTrampling(self, opponent):
		if self.jump_state == Character.JUMP_NO:
			return False

		sy = max(self.y, opponent.y)

		#↓これを追加
		sx = max(self.x, opponent.x)
		ex = min(self.x + self.width, opponent.x + opponent.width)
		#↑これを追加

		if self.y + self.height / 2 < sy:
			return True

		else:
			#↓これは削除
			#return False
			#↑これは削除

			#↓これを追加
			character_alpha = self.getAlpha()
			opponent_alpha = opponent.getAlpha()

			for y in range(sy, self.y + self.height // 2):
				for x in range(sx, ex):

					character_x = x - self.x
					character_y = y - self.y
					opponent_x = x - opponent.x
					opponent_y = y - opponent.y

					character_pos = character_y * self.width + character_x
					opponent_pos = opponent_y * opponent.width + opponent_x

					if character_alpha[character_pos] == 255:
						if opponent_alpha[opponent_pos] == 255:
							return False
			return True
			#↑これを追加

class Character:

	#↓これを追加
	def isCollidedInDetail(self, opponent, rect):
		character_alpha = self.getAlpha()
		opponent_alpha = opponent.getAlpha()

		sx, sy, ex, ey = rect

		for y in range(sy, ey):
			for x in range(sx, ex):

				character_x = x - self.x
				character_y = y - self.y
				opponent_x = x - opponent.x
				opponent_y = y - opponent.y

				character_pos = character_y * self.width + character_x
				opponent_pos = opponent_y * opponent.width + opponent_x

				if character_alpha[character_pos] == 255:
					if opponent_alpha[opponent_pos] == 255:
						return True

		return False
	#↑これを追加

class Character:

	def isCollided(self, opponent):
		if self.state == Character.STATE_CLEAR or self.state == Character.STATE_DEFEATED:
			return False
		if opponent.state == Character.STATE_CLEAR or opponent.state == Character.STATE_DEFEATED:
			return False

		sx = max(self.x, opponent.x)
		sy = max(self.y, opponent.y)
		ex = min(self.x + self.width, opponent.x + opponent.width)
		ey = min(self.y + self.height, opponent.y + opponent.height)

		if sx < ex and sy < ey:
			#↓これを追加
			return self.isCollidedInDetail(opponent, (sx, sy, ex, ey))
			#↑これを追加

			#↓これは削除
			#character_alpha = self.getAlpha()
			#opponent_alpha = opponent.getAlpha()

			#略
			
			#return False
			#↑これは削除
			
		else:
			return False

	def isTrampling(self, opponent):
		if self.jump_state == Character.JUMP_NO:
			return False

		sy = max(self.y, opponent.y)
		sx = max(self.x, opponent.x)
		ex = min(self.x + self.width, opponent.x + opponent.width)

		if self.y + self.height / 2 < sy:
			return True

		else:
			#↓これを追加
			return not self.isCollidedInDetail(opponent, (sx, sy, ex, self.y + self.height // 2))
			#↑これを追加

			#↓これは削除
			#character_alpha = self.getAlpha()
			#opponent_alpha = opponent.getAlpha()

			#略
			
			#return True
			#↑これは削除

class Character:

	def prepareImage(self, path, size, is_right=True):
		image = Image.open(path)

		width, height = size
		ratio = min(width / image.width, height / image.height)
		resize_size = (round(ratio * image.width), round(ratio * image.height))
		resized_image = image.resize(resize_size)

		#↓これを追加
		crop_rect = resized_image.getbbox()
		resized_image = resized_image.crop(crop_rect)	
		#↑これを追加

		mirrored_image = ImageOps.mirror(resized_image)

		#略

class Character:

	def isCollidedInDetail(self, opponent, rect):
		character_alpha = self.getAlpha()
		opponent_alpha = opponent.getAlpha()

		sx, sy, ex, ey = rect

		for y in range(sy, ey, 2): #←ここを変更
			for x in range(sx, ex, 2): #←ここを変更

import tkinter
from PIL import Image, ImageTk, ImageOps
import random

# アプリの設定
VIEW_WIDTH = 600
VIEW_HEIGHT = 400
GAME_WIDTH = 1500

UPDATE_TIME = 100

NUM_CAT_ENEMY = 3
NUM_DOG_ENEMY = 3

ROUGHNESS_DETECT = 1

BG_IMAGE_PATH = "bg_natural_sougen.jpeg"
PLAYER_IMAGE_PATH = "hashiru_boy.png"
GOAL_IMAGE_PATH = "car_animals_flag.png"
CAT_ENEMY_IMAGE_PATH = "cat_wink_brown.png"
DOG_ENEMY_IMAGE_PATH = "jitensya_inu.png"


class Character:

    DIRECTION_LEFT = 0
    DIRECTION_RIGHT = 1
    DIRECTION_UP = 2

    JUMP_NO = 0
    JUMP_UP = 1
    JUMP_DOWN = 2
    JUMP_TRAMPLE = 3

    STATE_NORMAL = 0
    STATE_CLEAR = 1
    STATE_DEFEATED = 2

    def __init__(self, path, size, is_right=True):
        self.prepareImage(path, size, is_right)

        self.base_y = VIEW_HEIGHT - self.right_image.height()
        self.x = 0
        self.y = self.base_y
        self.speed_x = 30
        self.speed_y = 20
        self.jump_state = Character.JUMP_NO
        self.jump_height = 200
        self.direction = Character.DIRECTION_RIGHT
        self.state = Character.STATE_NORMAL
        self.trample_height = 50
        self.trample_y = 0

    def getImage(self):
        if self.direction == Character.DIRECTION_RIGHT:
            return self.right_image
        elif self.direction == Character.DIRECTION_LEFT:
            return self.left_image

    def getAlpha(self):
        if self.direction == Character.DIRECTION_RIGHT:
            return self.right_alpha
        elif self.direction == Character.DIRECTION_LEFT:
            return self.left_alpha

    def prepareImage(self, path, size, is_right=True):
        image = Image.open(path)

        width, height = size
        ratio = min(width / image.width, height / image.height)
        resize_size = (round(ratio * image.width), round(ratio * image.height))
        resized_image = image.resize(resize_size)
        crop_rect = resized_image.getbbox()
        resized_image = resized_image.crop(crop_rect)
        mirrored_image = ImageOps.mirror(resized_image)

        resized_channels = resized_image.split()
        if len(resized_channels) == 4:
            resized_alpha = resized_channels[3]
        else:
            resized_alpha = Image.new("L", (resized_image.width, resized_image.height), 255)

        mirrored_channels = mirrored_image.split()
        if len(mirrored_channels) == 4:
            mirrored_alpha = mirrored_channels[3]
        else:
            mirrored_alpha = Image.new("L", (mirrored_image.width, mirrored_image.height), 255)

        if is_right:
            self.right_image = ImageTk.PhotoImage(resized_image)
            self.left_image = ImageTk.PhotoImage(mirrored_image)
            self.right_alpha = resized_alpha.getdata()
            self.left_alpha = mirrored_alpha.getdata()
        else:
            self.left_image = ImageTk.PhotoImage(resized_image)
            self.right_image = ImageTk.PhotoImage(mirrored_image)
            self.left_alpha = resized_alpha.getdata()
            self.right_alpha = mirrored_alpha.getdata()

        self.width = self.right_image.width()
        self.height = self.right_image.height()

    def move(self, direction):
        if self.state == Character.STATE_CLEAR or self.state == Character.STATE_DEFEATED:
            return

        if direction == Character.DIRECTION_LEFT:
            self.x = max(0, self.x - self.speed_x)
            self.direction = Character.DIRECTION_LEFT
        elif direction == Character.DIRECTION_RIGHT:
            self.x = min(GAME_WIDTH - self.right_image.width(), self.x + self.speed_x)
            self.direction = Character.DIRECTION_RIGHT
        elif direction == Character.DIRECTION_UP:
            if self.jump_state == Character.JUMP_NO:
                self.jump_state = Character.JUMP_UP

    def update(self):
        if self.state == Character.STATE_CLEAR or self.state == Character.STATE_DEFEATED:
            return

        if self.jump_state == Character.JUMP_UP:
            self.y -= self.speed_y
            if self.y <= self.base_y - self.jump_height:
                self.jump_state = Character.JUMP_DOWN
                self.y = self.base_y - self.jump_height
        elif self.jump_state == Character.JUMP_TRAMPLE:
            self.y -= self.speed_y
            if self.y <= self.trample_y - self.trample_height:
                self.jump_state = Character.JUMP_DOWN
                self.y = self.trample_y - self.trample_height
        elif self.jump_state == Character.JUMP_DOWN:
            self.y += self.speed_y
            if self.y >= self.base_y:
                self.jump_state = Character.JUMP_NO
                self.y = self.base_y

    def isCollidedInDetail(self, opponent, rect):
        character_alpha = self.getAlpha()
        opponent_alpha = opponent.getAlpha()

        sx, sy, ex, ey = rect

        for y in range(sy, ey, ROUGHNESS_DETECT):
            for x in range(sx, ex, ROUGHNESS_DETECT):

                character_x = x - self.x
                character_y = y - self.y
                opponent_x = x - opponent.x
                opponent_y = y - opponent.y

                character_pos = character_y * self.width + character_x
                opponent_pos = opponent_y * opponent.width + opponent_x

                if character_alpha[character_pos] == 255:
                    if opponent_alpha[opponent_pos] == 255:
                        return True

        return False

    def isCollided(self, opponent):
        if self.state == Character.STATE_CLEAR or self.state == Character.STATE_DEFEATED:
            return False
        if opponent.state == Character.STATE_CLEAR or opponent.state == Character.STATE_DEFEATED:
            return False

        sx = max(self.x, opponent.x)
        sy = max(self.y, opponent.y)
        ex = min(self.x + self.width, opponent.x + opponent.width)
        ey = min(self.y + self.height, opponent.y + opponent.height)

        if sx < ex and sy < ey:
            return self.isCollidedInDetail(opponent, (sx, sy, ex, ey))
        else:
            return False

    def defeated(self):
        self.state = Character.STATE_DEFEATED

    def trample(self):
        self.jump_state = Character.JUMP_TRAMPLE
        self.trample_y = self.y

    def isTrampling(self, opponent):
        if self.jump_state == Character.JUMP_NO:
            return False

        sy = max(self.y, opponent.y)
        sx = max(self.x, opponent.x)
        ex = min(self.x + self.width, opponent.x + opponent.width)

        if self.y + self.height / 2 < sy:
            return True
        else:
            return not self.isCollidedInDetail(opponent, (sx, sy, ex, self.y + self.height // 2))


class Player(Character):

    def __init__(self):
        super().__init__(PLAYER_IMAGE_PATH, (100, 100))

    def gameClear(self):
        self.state = Character.STATE_CLEAR


class Enemy(Character):

    def __init__(self, path, size, is_right=True):
        super().__init__(path, size, is_right)

        self.x = random.randrange(300, GAME_WIDTH - 300)
        self.direction = Character.DIRECTION_LEFT

    def update(self):
        self.move(self.direction)

        if random.randrange(10) % 10 == 0:
            self.move(Character.DIRECTION_UP)

        if self.x == 0:
            self.direction = Character.DIRECTION_RIGHT
        elif self.x == GAME_WIDTH - self.width:
            self.direction = Character.DIRECTION_LEFT

        super().update()


class CatEnemy(Enemy):

    def __init__(self):
        super().__init__(CAT_ENEMY_IMAGE_PATH, (80, 80))

        self.jump_height = 70
        self.speed_x = 20


class DogEnemy(Enemy):

    def __init__(self):
        super().__init__(DOG_ENEMY_IMAGE_PATH, (80, 80), False)

        self.jump_height = 50
        self.speed_x = 25


class Goal(Character):

    def __init__(self):
        super().__init__(GOAL_IMAGE_PATH, (200, 200), False)

        self.direction = Character.DIRECTION_LEFT
        self.x = GAME_WIDTH - self.width


class Screen:

    TYPE_GAMECLEAR = 0
    TYPE_GAMEOVER = 1

    def __init__(self, master):
        self.master = master

        self.view_width = VIEW_WIDTH
        self.view_height = VIEW_HEIGHT
        self.game_width = GAME_WIDTH
        self.game_height = self.view_height
        self.draw_images = []

        self.createWidgets()
        self.drawBackground()

    def createWidgets(self):
        self.canvas = tkinter.Canvas(
            self.master,
            width=self.view_width,
            height=self.view_height,
            scrollregion=(
                0, 0, self.game_width, self.game_height
            ),
            highlightthickness=0
        )
        self.canvas.grid(column=0, row=0)

    def drawBackground(self):
        image = Image.open(BG_IMAGE_PATH)

        size = (self.game_width, self.game_height)
        resized_image = image.resize(size)

        self.bg_image = ImageTk.PhotoImage(resized_image)

        self.canvas.create_image(
            0, 0,
            anchor=tkinter.NW,
            image=self.bg_image
        )

    def update(self, image_infos, player_x):
        for draw_image in self.draw_images:
            self.canvas.delete(draw_image)

        self.draw_images.clear()

        for image, x, y in image_infos:

            draw_image = self.canvas.create_image(
                x, y,
                anchor=tkinter.NW,
                image=image
            )
            self.draw_images.append(draw_image)

        scroll_x = (player_x - self.view_width / 2) / self.game_width
        self.canvas.xview_moveto(max(0, scroll_x))

    def message(self, type, player_x):
        if player_x < self.view_width / 2:
            x = self.view_width // 2
        elif player_x >= self.game_width - self.view_width / 2:
            x = self.game_width - self.view_width // 2
        else:
            x = player_x
        y = self.game_height // 2

        if type == Screen.TYPE_GAMECLEAR:
            self.canvas.create_text(
                x, y,
                font=("", 40),
                fill="blue",
                text="GAME CLEAR",
                anchor=tkinter.CENTER
            )
        elif type == Screen.TYPE_GAMEOVER:
            self.canvas.create_text(
                x, y,
                font=("", 40),
                fill="red",
                text="GAME OVER",
                anchor=tkinter.CENTER
            )


class Game:

    def __init__(self, master):
        self.master = master
        self.screen = Screen(self.master)

        self.characters = []
        self.player = Player()
        self.characters.append(self.player)

        goal = Goal()
        self.characters.append(goal)

        for _ in range(NUM_CAT_ENEMY):
            enemy = CatEnemy()
            self.characters.append(enemy)

        for _ in range(NUM_DOG_ENEMY):
            enemy = DogEnemy()
            self.characters.append(enemy)

        self.master.bind("<KeyPress-Left>", self.press)
        self.master.bind("<KeyPress-Right>", self.press)
        self.master.bind("<KeyPress-Up>", self.press)

        self.update()

    def update(self):
        if self.player.state == Character.STATE_NORMAL:
            self.master.after(UPDATE_TIME, self.update)
        else:
            self.master.unbind("<KeyPress-Left>")
            self.master.unbind("<KeyPress-Right>")
            self.master.unbind("<KeyPress-Up>")

        for character in self.characters:
            character.update()
            self.collisionDetect(character)

        image_infos = []
        for character in self.characters:

            if character.state != Character.STATE_DEFEATED:
                image = character.getImage()
                image_info = (image, character.x, character.y)
                image_infos.append(image_info)

        self.screen.update(image_infos, self.player.x + self.player.width / 2)

        if self.player.state == Character.STATE_CLEAR:
            self.screen.message(Screen.TYPE_GAMECLEAR,
                                self.player.x + self.player.width // 2)
        elif self.player.state == Character.STATE_DEFEATED:
            self.screen.message(Screen.TYPE_GAMEOVER,
                                self.player.x + self.player.width // 2)

    def press(self, event):
        if event.keysym == "Left":
            self.player.move(Character.DIRECTION_LEFT)

        elif event.keysym == "Right":
            self.player.move(Character.DIRECTION_RIGHT)

        elif event.keysym == "Up":
            self.player.move(Character.DIRECTION_UP)

        self.collisionDetect(self.player)

    def collide(self, character, opponent):
        if isinstance(character, Player) and isinstance(opponent, Goal):
            character.gameClear()
        elif isinstance(character, Goal) and isinstance(opponent, Player):
            opponent.gameClear()
        elif isinstance(character, Enemy) and isinstance(opponent, Enemy):
            if character.direction != opponent.direction:
                if character.direction == Character.DIRECTION_LEFT:
                    character.move(Character.DIRECTION_RIGHT)
                    opponent.move(Character.DIRECTION_LEFT)
                else:
                    character.move(Character.DIRECTION_LEFT)
                    opponent.move(Character.DIRECTION_RIGHT)
            else:
                if character.direction == Character.DIRECTION_LEFT:
                    if character.x < opponent.x:
                        opponent.move(Character.DIRECTION_RIGHT)
                    else:
                        character.move(Character.DIRECTION_RIGHT)
                else:
                    if character.x > opponent.x:
                        opponent.move(Character.DIRECTION_LEFT)
                    else:
                        character.move(Character.DIRECTION_LEFT)
        elif isinstance(character, Enemy) and isinstance(opponent, Goal):
            if character.direction == Character.DIRECTION_LEFT:
                character.move(Character.DIRECTION_RIGHT)
            else:
                character.move(Character.DIRECTION_LEFT)
        elif isinstance(character, Goal) and isinstance(opponent, Enemy):
            if opponent.direction == Character.DIRECTION_LEFT:
                opponent.move(Character.DIRECTION_RIGHT)
            else:
                opponent.move(Character.DIRECTION_LEFT)
        elif isinstance(character, Player) and isinstance(opponent, Enemy):
            if character.isTrampling(opponent):
                opponent.defeated()
                character.trample()
            else:
                character.defeated()
        elif isinstance(character, Enemy) and isinstance(opponent, Player):
            if opponent.isTrampling(character):
                character.defeated()
                opponent.trample()
            else:
                opponent.defeated()

    def collisionDetect(self, character):
        for opponent in self.characters:
            if opponent is character:
                continue
            
            if character.isCollided(opponent):
                self.collide(character, opponent)


def main():
    app = tkinter.Tk()
    game = Game(app)
    app.mainloop()


if __name__ == "__main__":
    main()