pythonoop-足球仿真

我是新手。我想模拟一场足球比赛。如何访问玩家/罪犯/防御者类中的游戏实例变量？如果其他结构更好，请帮助

职业玩家：
定义初始化（self，x，y）：
self.x=x
self.y=y
def移动到（自身、x、y）：
self.x=（self.x+x）/2
self.y=（self.y+y）/2
##在游戏中循环。玩家要找到最近的。如何访问Play.Player？
def最近（自我）：
返回最近的
类别违例者（球员）：
定义初始化（self，x，y）：
super（）.\uuuu init\uuuu（x，y）
#移动到球上。
def策略（）：
ball_x=Play.ball_x#如何访问Play.ball_x
ball_y=Play.ball_y#如何访问Play.ball_y
自我。移动到（球x，球y）
职业后卫（球员）：
定义初始化（self，x，y）：
super（）.\uuuu init\uuuu（x，y）
#移动到最近的玩家
def策略（自我）：
最近的
自行移动到（最近的）
班级游戏：
定义初始（自我、进攻球员、防守球员、球x、球y）：
自我攻击=[攻击中的玩家的罪犯（玩家）\u玩家]
自卫=[防守球员（球员）代表防守球员\u球员]
自攻队员=自攻+自卫
self.ball\u x=ball\u x
self.ball\u y=ball\u y
def模拟（自）：
尽管如此：
对于self.players中的玩家：
player.strategy（）
如果名称=“\uuuuu main\uuuuuuuu”：
Play（）模拟

---

我没有“犯规者”和“防守者”的职业，而是每个位置都有一个职业，即“前锋”（球员），“中场”（球员），

守门员（球员）

，这就是为什么我想将他们各自的

策略

存储在他们的类中，而不是

播放

类中。

我将执行以下操作：

在另一个（数据）类中跟踪游戏状态：

您甚至可能希望为此使用python3.7（及其功能）（尽管这根本不是必需的）

然后，玩家在他们的策略中采用这种状态，并期望更新他们的内部状态（如位置）

最近的

播放器通过使用键参数取其他播放器之间的最小值来实现，该键参数取另一个播放器的函数，

p

，该函数是使用编写的

然后，玩游戏

class Play:

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

    def simulate(self):
        while True:
            for player in self.game_state.players:
                player.strategy(self.game_state)

if __name__ == "__main__":
    Play(GameState(
        [Offender(-1, 0), Offender(-1, -1), ...]
        [Defender(1, 0), Offender(1, -1), ...]
    )).simulate()

---

然后可以实现一些实际的播放器

class TiernaDavidson(Defender):

    def strategy(self, *args, **kwargs):
        return better_strategy(*args, **kwargs)

---

您必须要求实施

better_策略

；）

我只是从的注释中阐述了这个想法：我们只是将

Play

实例作为参数传递给

Player

的相关方法。我还编写了

nearest（）

方法的初稿，但您可能希望改进其逻辑。我起草这篇文章是为了演示如何解决OOP设计问题

导入键入
职业球员：
定义初始化（self，x:float，y:float）：
self.x=x
self.y=y
def移动到（自身，x:浮动，y:浮动）->无：
self.x=（self.x+x）/2
self.y=（self.y+y）/2
定义最近的（自我，玩：“玩”）->“玩家”：
#这还必须进行调整，以处理两个玩家的边缘情况
#与当前玩家的距离相等。您没有指定
#这种情况下的期望输出，因此我现在忽略了该场景。
返回最小值([
在游戏中以p换p
如果p.x！=self.x或p.y！=self.y，这是
#排除玩家本身。
#这是一个错误的逻辑，因为它依赖于一个并非如此的假设
#在代码中验证（假设两个不同的玩家永远不会
#具有相同的坐标）。您可能希望引入一个uniqe`id`
#实例变量，以在
#干净的方式。
],
key=lambda p：（self.x-p.x）**2+（self.y-p.y）**2
) 
类别违例者（球员）：
定义初始化（self，x:float，y:float）：
super（）.\uuuu init\uuuu（x，y）
#移动到球上。
def策略（自我，游戏：“游戏”）->无：
self.move_to（play.ball_x，play.ball_y）
职业后卫（球员）：
定义初始化（self，x:float，y:float）：
super（）.\uuuu init\uuuu（x，y）
#移动到最近的玩家
def策略（自我，游戏：“游戏”）->无：
self.move_to（self.nearest）（播放=播放）
班级游戏：
定义初始化__(
自己
进攻队员：输入.列表[“罪犯”]，
防守队员：键入.列表[“防守队员”]，
浮球，
球：浮球，
):
自我进攻=进攻队员
自卫=防守队员
自攻队员=自攻+自卫
self.ball\u x=ball\u x
self.ball\u y=ball\u y
def模拟（自）->无：
虽然为True:#这仍然是一个很糟糕的情况，您可能希望更改它。但是您没有指定所需的逻辑，因此我没有更改它。
对于self.players中的玩家：
玩家策略（self，play=self）

不确定这对您有多大帮助，因为它是用C语言实现的++

您可以检查我的实现是否有类似的问题陈述

---

为了理解编写上述bot的街机游戏框架实现，签出

Player.simulate（）

方法应将

self.ball\x

和

self.ball\y

传递给

Player.strategy（）

方法作为参数…以及

播放

中所有其他

玩家

的坐标，因此可以计算

最近的（）

方法。您对在

玩家

类中添加

策略

的默认实现有何看法？

class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move_to(self, x, y, other_players):
        self.x = (self.x + x) / 2
        self.y = (self.y + y) / 2

    def nearest(self):
        return nearest

class Offender(Player):
    def __init__(self, x, y):
        super().__init__(x, y)

    # Move to ball.
    def strategy(self, game_state):
        ball_x = game_sate.ball_x # how do I access Play.ball_x
        ball_y = game_state.ball_y # how do I access Play.ball_y
        self.move_to(ball_x, ball_y)

class Defender(Player):
    def __init__(self, x, y):
        super().__init__(x, y)

    # Move to nearest player
    def strategy(self, game_state):
        # we assume you are moving to offensive players - which 
        # you will not be apart of 
        nearest = min(
            game_state.offense
            key=lambda p: (
                (self.x - p.x) **2 + (self.y - p.y) ** 2
            ) ** (1/2)  # take the l2 norm to find the "closest" player to you
        )
        self.move_to(nearest.x, nearest.y)      

class Play:

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

    def simulate(self):
        while True:
            for player in self.game_state.players:
                player.strategy(self.game_state)

if __name__ == "__main__":
    Play(GameState(
        [Offender(-1, 0), Offender(-1, -1), ...]
        [Defender(1, 0), Offender(1, -1), ...]
    )).simulate()

class TiernaDavidson(Defender):

    def strategy(self, *args, **kwargs):
        return better_strategy(*args, **kwargs)