wxPython和pycairo练习记录4

wxPython和pycairo练习记录4

继续写碰撞检测。

4.1 判断碰撞的条件

碰撞，即两个坦克车身产生重合。

因为这里的坦克是四方向的，所以可碰撞的区域概括为编号4和5，不可碰撞区域概括为6和7。已知的是坦克左上角定位点，及坦克的宽高。假设玩家坦克坐标为(x, y)，宽高为(w, h)，其他敌方坦克以编号作下标。

先以正相邻的4号区域来看，4和坦克碰撞，得到条件：
abs(x4 - x) < w4
那么 x 坐标相同且 y 坐标不同的的4567都满足这个条件，所以同时还需要判断 y 坐标：
abs(y4 - y) < h4

再代入编号1234567，发现符合预期。

当然，wxPython 自带的矩形类 wx.Rect 的方法 Intersects 也可以实现同样的效果。

4.2 碰撞后的转向问题

碰撞后谁转向？谁撞了谁？已知两个坦克的前进方向和坐标，可以通过坐标差判断相对位置。

同方向相撞>>，位置在后的转向。
相对方向相撞><，都转向。
不同轴方向相撞>^^或^>，撞向侧面的那个转向。

4.3 代码

还是有问题：1.相对方向碰撞时用SetDirection不转向，但是用ChangeDirection可以，这两个方法都是修改_direction，也不知道错在哪；2.转向时依然有重合的地方。

    def CheckCollisions(self):
        # checked = [] # 存储已检测过的坦克对象
        for tank1 in self.enemies:
            for tank2 in self.enemies:
                # 忽略自身和已检测过的坦克
                if tank1 is tank2:
                # if tank1 is tank2 or tank2 in checked:
                    continue

                rect1 = tank1.GetRect()
                rect2 = tank2.GetRect()
                x1, y1, w1, w2 = rect1
                x2, y2, w2, h2 = rect2
                direction1 = tank1.GetDirection()
                direction2 = tank2.GetDirection()

                if rect1.Intersects(rect2):
                    # 同方向相撞>>，位置在后的转向。
                    # 不同轴方向相撞>^或^>，撞向侧面的那个转向。
                    # print(wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT)
                    # 315 317 314 316
                    if abs(direction1 - direction2) != 2:
                    # if direction1 == direction2 or abs(direction1 - direction2) == 1 or abs(direction1 - direction2) == 3:
                        if direction1 == wx.WXK_UP and y1 >= y2:
                            tank1.SetDirection(wx.WXK_DOWN)
                        elif direction1 == wx.WXK_DOWN and y1 <= y2:
                            tank1.SetDirection(wx.WXK_UP)
                        elif direction1 == wx.WXK_LEFT and x1 >= x2:
                            tank1.SetDirection(wx.WXK_RIGHT)
                        elif direction1 == wx.WXK_RIGHT and x1 <= x2:
                            tank1.SetDirection(wx.WXK_LEFT)
                        else:
                            direction2 = (direction2 <= 315) and (direction2 + 2) or (direction2 - 2)
                            tank2.SetDirection(direction2)
                    # 相对方向相撞><，都转向。
                    else:
                    # elif abs(direction1 - direction2) == 2:
                        # TODO: 哪里错了？
                        # tank1.SetDirection(direction2)
                        # tank2.SetDirection(direction1)
                        tank1.ChangeDirection(direction1)
                        tank2.ChangeDirection(direction2)
            # checked.append(tank1)

4.4 效果

# -*- coding: utf-8 -*-
# example2.py

import random
import wx
import wx.lib.wxcairo
import cairo
import board
from display import MovieClip


class cv(board.cv):
    """
    常量，用类属性避免使用全局变量
    """
    # 面板尺寸
    BOARD_WIDTH = 600
    BOARD_HEIGHT = 400


class Tank(MovieClip):
    def __init__(self, *args, **kwargs):
        super(Tank, self).__init__(*args, **kwargs)
        self._speed = 10 # 移动速度
        self._dx = 0 # x 轴方向
        self._dy = 0 # y 轴方向

    def Up(self):
        self._dy = -1
        self._dx = 0
        # 同一方向时需要需要排除，不然动画一直停留在第1帧
        if self._currentScene != 0:
            self.GotoAndPlay(0, 0)

    def Down(self):
        self._dy = 1
        self._dx = 0

        if self._currentScene != 1:
            self.GotoAndPlay(0, 1)

    def Left(self):
        self._dx = -1
        self._dy = 0

        if self._currentScene != 2:
            self.GotoAndPlay(0, 2)

    def Right(self):
        self._dx = 1
        self._dy = 0

        if self._currentScene != 3:
            self.GotoAndPlay(0, 3)


class Player(Tank):
    def __init__(self, x, y, path="tank_T1_0.png", rect=(0, 0, 48, 48), fps=100):
        super(Player, self).__init__(x, y, path, rect, fps)

    def OnKeyDown(self, e):
        key = e.GetKeyCode()

        if key == wx.WXK_UP:
            self.Up()
        if key == wx.WXK_DOWN:
            self.Down()
        if key == wx.WXK_LEFT:
            self.Left()
        if key == wx.WXK_RIGHT:
            self.Right()

        self._x += self._dx * self._speed
        self._y += self._dy * self._speed

    def OnKeyUp(self, e):
        key = e.GetKeyCode()

        if key == wx.WXK_UP or key == wx.WXK_DOWN:
            self._dy = 0
        if key == wx.WXK_LEFT or key == wx.WXK_RIGHT:
            self._dx = 0
        if self._dx == 0 and self._dy == 0:
            self.Stop()


class Enemy(Tank):
    def __init__(self, x, y, path="tank_T1_0.png", rect=(0, 0, 48, 48), fps=100, mixColor=(0, 1, 1, 0.8)):
        self._mixColor = mixColor # 自定义混合颜色
        super(Enemy, self).__init__(x, y, path, rect, fps)
        # 初始随机方向
        self._direction = random.choice([wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT])
        self._speed = 1
        self._isPlaying = True

    def LoadFrames(self, rect):
        # 将图像载为帧前，先改变图像的色相
        surface = cairo.ImageSurface.create_from_png("tank_T1_0.png")
        sw = surface.get_width()
        sh = surface.get_height()

        # 创建只显示坦克的 surface 作为混合层
        surface2 = cairo.ImageSurface(cairo.FORMAT_ARGB32, sw, sh)
        ctx = cairo.Context(surface2)
        ctx.set_source_rgba(*self._mixColor)
        ctx.mask_surface(surface)

        # 与目标图像混合
        ctx = cairo.Context(surface)
        ctx.set_source_surface(surface2)
        ctx.set_operator(cairo.Operator.HSL_HUE) # 将色相和目标图像色相混合
        ctx.paint()

        self._surface = surface
        super().LoadFrames(rect)

    def GetDirection(self):
        return self._direction

    def SetDirection(self, direction):
        self._direction = direction

    def ChangeDirection(self, direction):
        # 方向转换为除指定方向以外的方向，总觉得这样写不太好 加个
        # TODO
        directions = [wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT]
        directions.remove(direction)
        self._direction = random.choice(directions)

    def AutoWalk(self):
        if self._direction == wx.WXK_UP:
            self.Up()
        elif self._direction == wx.WXK_DOWN:
            self.Down()
        elif self._direction == wx.WXK_LEFT:
            self.Left()
        elif self._direction == wx.WXK_RIGHT:
            self.Right()

        # 遇边界转向，坦克宽高明明是48，可是按48处理显示不对
        # TODO
        if self._x < 0:
            self._x = 0
            self.ChangeDirection(wx.WXK_LEFT)
        elif self._x > cv.BOARD_WIDTH - 68:
            self._x = cv.BOARD_WIDTH - 68
            self.ChangeDirection(wx.WXK_RIGHT)
        else:
            self._x += self._dx * self._speed

        if self._y < 0:
            self._y = 0
            self.ChangeDirection(wx.WXK_UP)
        elif self._y > cv.BOARD_HEIGHT - 96:
            self._y = cv.BOARD_HEIGHT - 96
            self.ChangeDirection(wx.WXK_DOWN)
        else:
            self._y += self._dy * self._speed

    def Update(self, times, speed):
        # 由主程序刷新时更新
        self.AutoWalk()
        super().Update(times, speed)


class Board(board.Board):
    def DrawBackground(self, ctx):
        super().DrawBackground(ctx)

        text = "SmileBasic"
        ctx.set_font_size(40)
        _, _, w, h, _, _ = ctx.text_extents(text)
        x = (cv.BOARD_WIDTH - w) // 2
        y = (cv.BOARD_HEIGHT - h) // 2

        # 文字是以首个字左下角坐标定位，而矩形是以左上角定位，y轴相差文字的高度，不需要考虑线条宽度。
        # 另外PaintDC是不含标题栏的。
        ctx.rectangle(x - 10, y - 10 - h, w + 20, h + 20)
        ctx.set_source_rgb(1, 0, 0)
        ctx.stroke()

        ctx.move_to(x, y)
        ctx.set_source_rgb(1, 1, 1)
        ctx.show_text(text)

    def InitSceneObjects(self):
        super().InitSceneObjects()
        self.enemies = []

        self.player = Player(50, 50) # 实例化一个玩家坦克
        self.sceneObjects.append(self.player)

        # 坦克在四个角的坐标
        coordinates = [(0, 0),
                       (cv.BOARD_WIDTH - 48, 0),
                       (0, cv.BOARD_HEIGHT - 48),
                       (cv.BOARD_WIDTH - 48, cv.BOARD_HEIGHT - 48)]
        # 生成10个敌军坦克
        for i in range(10):
            coord = random.choice(coordinates)
            enemy = Enemy(x=coord[0], y=coord[1], mixColor=(random.random(), random.random(), random.random(), 0.8))
            self.enemies.append(enemy)
            self.sceneObjects.append(enemy)

    def DrawSceneObjects(self, ctx):
        for so in self.sceneObjects:
            ctx.set_source_surface(so.GetSurface(), so.GetX(), so.GetY())
            ctx.paint()

    def OnKeyDown(self, e):
        self.player.OnKeyDown(e)
        self.Refresh()

    def OnKeyUp(self, e):
        self.player.OnKeyUp(e)

    def CheckStrategies(self):
        self.CheckCollisions()

    def CheckCollisions(self):
        # checked = [] # 存储已检测过的坦克对象
        for tank1 in self.enemies:
            for tank2 in self.enemies:
                # 忽略自身和已检测过的坦克
                if tank1 is tank2:
                # if tank1 is tank2 or tank2 in checked:
                    continue

                rect1 = tank1.GetRect()
                rect2 = tank2.GetRect()
                x1, y1, w1, w2 = rect1
                x2, y2, w2, h2 = rect2
                direction1 = tank1.GetDirection()
                direction2 = tank2.GetDirection()

                if rect1.Intersects(rect2):
                    # 同方向相撞>>，位置在后的转向。
                    # 不同轴方向相撞>^或^>，撞向侧面的那个转向。
                    # print(wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT)
                    # 315 317 314 316
                    if abs(direction1 - direction2) != 2:
                    # if direction1 == direction2 or abs(direction1 - direction2) == 1 or abs(direction1 - direction2) == 3:
                        if direction1 == wx.WXK_UP and y1 >= y2:
                            tank1.SetDirection(wx.WXK_DOWN)
                        elif direction1 == wx.WXK_DOWN and y1 <= y2:
                            tank1.SetDirection(wx.WXK_UP)
                        elif direction1 == wx.WXK_LEFT and x1 >= x2:
                            tank1.SetDirection(wx.WXK_RIGHT)
                        elif direction1 == wx.WXK_RIGHT and x1 <= x2:
                            tank1.SetDirection(wx.WXK_LEFT)
                        else:
                            direction2 = (direction2 <= 315) and (direction2 + 2) or (direction2 - 2)
                            tank2.SetDirection(direction2)
                    # 相对方向相撞><，都转向。
                    else:
                    # elif abs(direction1 - direction2) == 2:
                        # TODO: 哪里错了？
                        # tank1.SetDirection(direction2)
                        # tank2.SetDirection(direction1)
                        tank1.ChangeDirection(direction1)
                        tank2.ChangeDirection(direction2)
            # checked.append(tank1)