import pygame
import sys
import math
import random
from pygame.locals import *
# 初始化pygame
pygame.init()
# 屏幕设置
SCREEN_WIDTH = 1200
SCREEN_HEIGHT = 700
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("3v3fc 足球世界")
# 颜色定义
GREEN = (30, 180, 30)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (220, 20, 20)
BLUE = (30, 80, 200)
YELLOW = (255, 255, 0)
ORANGE = (255, 165, 0)
LIGHT_GREEN = (100, 230, 100)
LIGHT_BLUE = (100, 180, 255)
# 足球场尺寸
FIELD_RECT = pygame.Rect(50, 50, SCREEN_WIDTH - 100, SCREEN_HEIGHT - 100)
CENTER_X = SCREEN_WIDTH // 2
CENTER_Y = SCREEN_HEIGHT // 2
# 加载字体
font_large = pygame.font.SysFont('simhei', 48)
font_medium = pygame.font.SysFont('simhei', 32)
font_small = pygame.font.SysFont('simhei', 24)
class Player:
def __init__(self, x, y, team, number, is_user=False, position="forward"):
self.original_x = x
self.original_y = y
self.x = x
self.y = y
self.team = team
self.number = number
self.position = position
self.radius = 13
self.normal_speed = 4.0
self.speed = self.normal_speed
self.is_user = is_user
self.color = RED if team == "red" else BLUE
self.has_ball = False
self.sprint_cooldown = 0
self.sprint_duration = 0
self.is_sprinting = False
self.steal_cooldown = 0
self.pass_cooldown = 0
self.selected = is_user
self.role_radius = 120
self.home_x = x
self.home_y = y
self.target_x = x
self.target_y = y
self.last_target_update = 0
self.smooth_factor = 0.3
self.direction = (1, 0) if team == "red" else (-1, 0)
self.stamina = 100
self.aggression = random.uniform(0.6, 0.9)
self.defense = random.uniform(0.6, 0.9)
self.pass_accuracy = random.uniform(0.7, 0.95)
self.last_action_time = 0
self.move_lock = 0
def reset_position(self):
self.x = self.original_x
self.y = self.original_y
self.has_ball = False
self.is_sprinting = False
self.steal_cooldown = 0
self.pass_cooldown = 0
self.stamina = 100
self.direction = (1, 0) if self.team == "red" else (-1, 0)
self.move_lock = 0
def draw(self):
color = self.color
if self.is_sprinting:
color = YELLOW
elif self.has_ball:
color = WHITE
pygame.draw.circle(screen, color, (int(self.x), int(self.y)), self.radius)
pygame.draw.circle(screen, BLACK if not self.has_ball else RED if self.team=="red" else BLUE,
(int(self.x), int(self.y)), self.radius, 2)
# 绘制球员号码
number_text = font_small.render(str(self.number), True, WHITE if not self.has_ball else BLACK)
text_rect = number_text.get_rect(center=(self.x, self.y))
screen.blit(number_text, text_rect)
# 如果球员被选中，绘制选择圈
if self.selected:
pygame.draw.circle(screen, YELLOW, (int(self.x), int(self.y)), self.radius + 5, 2)
# 如果球员持球，绘制球在正前方
if self.has_ball:
# 根据移动方向计算球的位置
dx, dy = self.direction
if dx == 0 and dy == 0:
dx, dy = (1, 0) if self.team == "red" else (-1, 0)
# 归一化
length = math.sqrt(dx*dx + dy*dy)
if length > 0:
dx = dx / length
dy = dy / length
ball_x = self.x + dx * (self.radius + 10)
ball_y = self.y + dy * (self.radius + 10)
pygame.draw.circle(screen, WHITE, (int(ball_x), int(ball_y)), 10)
def sprint(self):
if self.has_ball and self.sprint_cooldown == 0 and self.stamina > 30:
self.speed = self.normal_speed * 1.8
self.sprint_duration = 30
self.sprint_cooldown = 90
self.is_sprinting = True
self.stamina -= 15
return True
return False
def steal(self):
if not self.has_ball and self.steal_cooldown == 0:
self.steal_cooldown = 30
return True
return False
def pass_ball(self, teammates, ball):
if self.has_ball and self.pass_cooldown == 0:
best_teammate = None
best_score = -9999
for player in teammates:
if player.team == self.team and player != self and not player.has_ball:
dist = math.sqrt((self.x - player.x)**2 + (self.y - player.y)**2)
if self.team == "red":
position_score = (player.x - CENTER_X) * 1.5
else:
position_score = (CENTER_X - player.x) * 1.5
angle_score = 0
if dist > 0:
dx = player.x - self.x
dy = player.y - self.y
obstructed = False
for opp in teammates:
if opp.team != self.team:
dist_to_line = abs((dy)*opp.x - (dx)*opp.y + self.x*player.y - player.x*self.y) / dist
if dist_to_line < 25 and math.sqrt((opp.x - self.x)**2 + (opp.y - self.y)**2) < dist:
obstructed = True
break
if not obstructed:
angle_score = 60
player_score = player.pass_accuracy * 30
score = position_score + angle_score + player_score + random.uniform(0, 20) - dist / 4
if score > best_score:
best_score = score
best_teammate = player
if best_teammate and random.random() < self.pass_accuracy:
predict_x = best_teammate.x + (best_teammate.x - self.x) * 0.3
predict_y = best_teammate.y + (best_teammate.y - self.y) * 0.3
ball.target_x = predict_x
ball.target_y = predict_y
ball.speed = 8
ball.is_moving = True
self.has_ball = False
self.pass_cooldown = 30
return best_teammate
return None
def update_status(self):
if not self.is_sprinting and self.stamina < 100:
self.stamina += 0.1
if self.sprint_duration > 0:
self.sprint_duration -= 1
if self.sprint_duration == 0:
self.speed = self.normal_speed
self.is_sprinting = False
if self.sprint_cooldown > 0:
self.sprint_cooldown -= 1
if self.steal_cooldown > 0:
self.steal_cooldown -= 1
if self.pass_cooldown > 0:
self.pass_cooldown -= 1
if self.last_target_update > 0:
self.last_target_update -= 1
if self.move_lock > 0:
self.move_lock -= 1
self.last_action_time += 1
def calculate_position(self, ball, teammates, opponents):
if self.last_target_update == 0:
if self.team == "red":
attack_direction = 1
defend_direction = -1
else:
attack_direction = -1
defend_direction = 1
ball_side = ball.x > CENTER_X if self.team == "red" else ball.x < CENTER_X
our_ball = any(p.has_ball and p.team == self.team for p in teammates)
if self.position == "forward":
if our_ball or ball_side:
self.target_x = self.home_x + attack_direction * 200
self.target_y = CENTER_Y + random.uniform(-30, 30)
else:
self.target_x = CENTER_X - attack_direction * 100
self.target_y = CENTER_Y
elif self.position == "midfielder":
if our_ball:
self.target_x = self.home_x + attack_direction * 100
self.target_y = ball.y
elif ball_side:
self.target_x = self.home_x + attack_direction * 50
self.target_y = CENTER_Y
else:
self.target_x = CENTER_X - attack_direction * 50
self.target_y = CENTER_Y
else:
if ball_side or not our_ball:
self.target_x = self.home_x
self.target_y = self.home_y
else:
self.target_x = self.home_x + attack_direction * 50
self.target_y = CENTER_Y
self.last_target_update = 30
self.target_x = max(FIELD_RECT.left + self.radius,
min(self.target_x, FIELD_RECT.right - self.radius))
self.target_y = max(FIELD_RECT.top + self.radius,
min(self.target_y, FIELD_RECT.bottom - self.radius))
def move_ai(self, ball, teammates, opponents, game):
# 如果是玩家控制且选中的球员，跳过AI移动
if self.selected and self.team == "red":
return 0, 0
self.calculate_position(ball, teammates, opponents)
# 如果持球，决定传球或带球
if self.has_ball:
if self.last_action_time > 30:
best_teammate = None
best_score = -9999
for player in teammates:
if player.team == self.team and player != self and not player.has_ball:
dist = math.sqrt((self.x - player.x)**2 + (self.y - player.y)**2)
if self.team == "red":
position_score = (player.x - CENTER_X) * 2.0
else:
position_score = (CENTER_X - player.x) * 2.0
if position_score > best_score and dist < 300:
best_score = position_score
best_teammate = player
if best_teammate and best_score > 50 and random.random() < 0.03:
return "pass"
if (self.team == "red" and self.x > FIELD_RECT.right - 250) or \
(self.team == "blue" and self.x < FIELD_RECT.left + 250):
if random.random() < 0.02:
return "shoot"
if random.random() < 0.01 and self.sprint_cooldown == 0 and self.stamina > 40:
self.sprint()
# 检查是否应该切换到该球员
if self.team == "red" and not self.selected:
if self.is_closest_to_ball(ball, teammates + opponents):
game.switch_to_player(self)
closest_to_ball = self.is_closest_to_ball(ball, teammates + opponents)
if closest_to_ball and not self.has_ball and self.move_lock == 0:
dx = ball.x - self.x
dy = ball.y - self.y
dist = math.sqrt(dx*dx + dy*dy)
if dist > 0:
self.direction = (dx/dist, dy/dist)
if dist < 80 and self.steal_cooldown == 0 and random.random() < 0.05:
self.steal()
else:
dx = self.target_x - self.x
dy = self.target_y - self.y
dist = math.sqrt(dx*dx + dy*dy)
if dist > 0:
self.direction = (dx/dist, dy/dist)
if dist > 0:
dx = dx * self.smooth_factor
dy = dy * self.smooth_factor
move_dist = math.sqrt(dx*dx + dy*dy)
if move_dist > self.speed:
dx = dx / move_dist * self.speed
dy = dy / move_dist * self.speed
return dx, dy
def is_closest_to_ball(self, ball, players):
min_dist = float('inf')
closest_player = None
for player in players:
if isinstance(player, Goalie):
continue
dist = math.sqrt((player.x - ball.x)**2 + (player.y - ball.y)**2)
if dist < min_dist:
min_dist = dist
closest_player = player
return closest_player == self if closest_player else False
def move(self, keys, ball, teammates, opponents, game):
dx, dy = 0, 0
# 玩家控制逻辑
if self.selected and self.team == "red":
if keys[K_LEFT]:
dx = -self.speed
if keys[K_RIGHT]:
dx = self.speed
if keys[K_UP]:
dy = -self.speed
if keys[K_DOWN]:
dy = self.speed
if dx != 0 or dy != 0:
self.direction = (dx, dy)
length = math.sqrt(dx*dx+dy*dy)
if length > 0:
self.direction = (dx/length, dy/length)
if keys[K_LSHIFT]:
self.sprint()
if keys[K_LCTRL]:
self.steal()
else:
ai_action = self.move_ai(ball, teammates, opponents, game)
if ai_action == "shoot" and self.has_ball:
return "shoot"
elif ai_action == "pass" and self.has_ball:
return "pass"
elif isinstance(ai_action, tuple):
dx, dy = ai_action
new_x = self.x + dx
new_y = self.y + dy
new_x = max(FIELD_RECT.left + self.radius,
min(new_x, FIELD_RECT.right - self.radius))
new_y = max(FIELD_RECT.top + self.radius,
min(new_y, FIELD_RECT.bottom - self.radius))
self.x = new_x
self.y = new_y
self.update_status()
for opponent in opponents:
if opponent != self:
dist = math.sqrt((self.x - opponent.x)**2 + (self.y - opponent.y)**2)
if dist < (self.radius + opponent.radius + 5):
self.handle_collision(opponent, ball)
def handle_collision(self, opponent, ball):
if opponent.has_ball:
steal_chance = 0.6 + (self.defense - opponent.aggression) * 0.2
if self.steal_cooldown == 0 and random.random() < steal_chance:
opponent.has_ball = False
self.has_ball = True
self.move_lock = 10
dx = self.x - opponent.x
dy = self.y - opponent.y
if dx == 0 and dy == 0:
dx = 1
length = math.sqrt(dx*dx+dy*dy)
self.direction = (dx/length, dy/length)
elif self.has_ball and opponent.steal_cooldown == 0:
steal_chance = 0.5 + (opponent.defense - self.aggression) * 0.2
if random.random() < steal_chance:
self.has_ball = False
opponent.has_ball = True
self.move_lock = 10
dx = opponent.x - self.x
dy = opponent.y - self.y
if dx == 0 and dy == 0:
dx = -1 if self.team=="red" else 1
length = math.sqrt(dx*dx+dy*dy)
opponent.direction = (dx/length, dy/length)
class Ball:
def __init__(self, x, y):
self.original_x = x
self.original_y = y
self.x = x
self.y = y
self.radius = 10
self.speed = 0
self.is_moving = False
self.target_x = x
self.target_y = y
self.trail = []
def reset_position(self):
self.x = self.original_x
self.y = self.original_y
self.is_moving = False
self.trail = []
def draw(self):
# 只在球移动时绘制轨迹
if self.is_moving:
for i, (trail_x, trail_y) in enumerate(self.trail):
pygame.draw.circle(screen, (200, 200, 200), (int(trail_x), int(trail_y)), 3)
# 只在球未被球员持有时绘制球
if not any(p.has_ball for p in game.players + game.goalies):
pygame.draw.circle(screen, WHITE, (int(self.x), int(self.y)), self.radius)
pygame.draw.circle(screen, BLACK, (int(self.x), int(self.y)), self.radius, 1)
def move(self):
if self.is_moving:
if len(self.trail) > 10:
self.trail.pop(0)
self.trail.append((self.x, self.y))
dx = self.target_x - self.x
dy = self.target_y - self.y
dist = math.sqrt(dx*dx + dy*dy)
if dist < self.speed:
self.x = self.target_x
self.y = self.target_y
self.is_moving = False
else:
dx = dx / dist * self.speed
dy = dy / dist * self.speed
self.x += dx
self.y += dy
def check_collision(self, players):
for player in players:
dx, dy = player.direction
if dx == 0 and dy == 0:
dx, dy = (1, 0) if player.team == "red" else (-1, 0)
length = math.sqrt(dx*dx + dy*dy)
if length > 0:
dx = dx / length
dy = dy / length
ball_x = player.x + dx * (player.radius + 10)
ball_y = player.y + dy * (player.radius + 10)
dist = math.sqrt((self.x - ball_x)**2 + (self.y - ball_y)**2)
if dist < (self.radius + 10) and self.is_moving:
if random.random() < 0.8:
self.is_moving = False
player.has_ball = True
return player
return None
class Goalie:
def __init__(self, x, y, team):
self.x = x
self.y = y
self.team = team
self.radius = 20
self.speed = 4
self.home_x = x
self.home_y = y
self.has_ball = False
self.pass_cooldown = 0
self.direction = (0, 0)
self.skill = random.uniform(0.7, 0.95)
self.number = 1 # 为守门员添加号码属性
def reset_position(self):
self.x = self.home_x
self.y = self.home_y
self.has_ball = False
self.pass_cooldown = 0
def draw(self):
color = RED if self.team == "red" else BLUE
if self.has_ball:
color = WHITE
pygame.draw.circle(screen, color, (int(self.x), int(self.y)), self.radius)
pygame.draw.circle(screen, WHITE if not self.has_ball else BLACK,
(int(self.x), int(self.y)), self.radius, 2)
# 绘制守门员号码
number_text = font_small.render(str(self.number), True, WHITE if not self.has_ball else BLACK)
text_rect = number_text.get_rect(center=(self.x, self.y))
screen.blit(number_text, text_rect)
if self.has_ball:
pygame.draw.circle(screen, WHITE, (int(self.x), int(self.y + 20)), 10)
def move(self, ball, teammates):
if self.pass_cooldown > 0:
self.pass_cooldown -= 1
if self.has_ball:
if self.pass_cooldown == 0:
closest_teammate = None
min_dist = float('inf')
for player in teammates:
if player.team == self.team and not isinstance(player, Goalie): # 只找普通球员
dist = math.sqrt((self.x - player.x)**2 + (self.y - player.y)**2)
if dist < min_dist:
min_dist = dist
closest_teammate = player
if closest_teammate:
ball.target_x = closest_teammate.x
ball.target_y = closest_teammate.y
ball.speed = 10
ball.is_moving = True
self.has_ball = False
self.pass_cooldown = 60
return
# 守门员移动逻辑 - 只在球进入危险区域时移动
if (self.team == "red" and ball.x > FIELD_RECT.left + 200) or \
(self.team == "blue" and ball.x < FIELD_RECT.right - 200):
if ball.is_moving:
if self.team == "red":
goal_x = FIELD_RECT.right
else:
goal_x = FIELD_RECT.left
dx = ball.x - self.x
dy = ball.y - self.y
if dx != 0:
slope = dy / dx
intercept_y = ball.y - slope * ball.x
predict_y = slope * goal_x + intercept_y
predict_y = max(self.home_y - 80, min(predict_y, self.home_y + 80))
skill_factor = 0.3 + self.skill * 0.7
self.y = predict_y * skill_factor + self.y * (1 - skill_factor)
else:
# 球静止时，向球移动
dy = ball.y - self.y
if abs(dy) > 5:
self.y += dy / abs(dy) * self.speed
else:
# 返回初始位置
if abs(self.y - self.home_y) > 5:
self.y += (self.home_y - self.y) / abs(self.home_y - self.y) * self.speed
class FootballGame:
def __init__(self):
self.reset_game()
def reset_positions(self):
for player in self.players:
player.reset_position()
for goalie in self.goalies:
goalie.reset_position()
self.ball.reset_position()
if self.score_red > self.score_blue:
player = random.choice([p for p in self.players if p.team == "red"])
player.has_ball = True
self.switch_to_player(player)
elif self.score_blue > self.score_red:
player = random.choice([p for p in self.players if p.team == "blue"])
player.has_ball = True
else:
if random.random() < 0.5:
player = random.choice([p for p in self.players if p.team == "red"])
player.has_ball = True
self.switch_to_player(player)
else:
player = random.choice([p for p in self.players if p.team == "blue"])
player.has_ball = True
def switch_to_player(self, player):
for i, p in enumerate(self.players):
if p == player:
self.selected_player = i
p.selected = True
p.is_user = (p.team == "red")
else:
p.selected = False
def switch_to_closest_to_ball(self, team="red"):
"""切换到离球最近的队友（忽略守门员）"""
min_dist = float('inf')
closest_player = None
for player in self.players:
if player.team == team and not isinstance(player, Goalie): # 忽略守门员
dist = math.sqrt((player.x - self.ball.x)**2 + (player.y - self.ball.y)**2)
if dist < min_dist:
min_dist = dist
closest_player = player
if closest_player:
self.switch_to_player(closest_player)
def reset_game(self):
# 创建球员
self.players = [
Player(CENTER_X - 150, CENTER_Y - 100, "red", 10, True, "forward"),
Player(CENTER_X - 250, CENTER_Y, "red", 8, False, "midfielder"),
Player(CENTER_X - 350, CENTER_Y, "red", 5, False, "defender"),
Player(CENTER_X + 150, CENTER_Y - 100, "blue", 9, False, "forward"),
Player(CENTER_X + 250, CENTER_Y, "blue", 7, False, "midfielder"),
Player(CENTER_X + 350, CENTER_Y, "blue", 3, False, "defender"),
]
# 创建守门员
self.goalies = [
Goalie(FIELD_RECT.left + 30, CENTER_Y, "red"),
Goalie(FIELD_RECT.right - 30, CENTER_Y, "blue")
]
# 创建球
self.ball = Ball(CENTER_X, CENTER_Y)
self.players[0].has_ball = True
# 创建球门
self.goals = [
pygame.Rect(FIELD_RECT.left, CENTER_Y - 100, 10, 200),
pygame.Rect(FIELD_RECT.right - 10, CENTER_Y - 100, 10, 200) # 修正球门位置
]
# 游戏状态
self.score_red = 0
self.score_blue = 0
self.game_time = 0
self.message = ""
self.message_timer = 0
self.waiting_reset = 0
self.selected_player = 0
self.player_switch_cooldown = 0
self.possession = {"red": 0, "blue": 0}
self.last_ball_holder_team = "red"
def switch_player(self):
if self.player_switch_cooldown > 0:
return
red_players = [i for i, p in enumerate(self.players) if p.team == "red" and not isinstance(p, Goalie)]
if not red_players:
return
current_index = red_players.index(self.selected_player)
next_index = (current_index + 1) % len(red_players)
self.selected_player = red_players[next_index]
for i, player in enumerate(self.players):
player.selected = (i == self.selected_player)
self.message = f"切换至{self.players[self.selected_player].number}号"
self.message_timer = 30
self.player_switch_cooldown = 20
def handle_events(self):
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN:
if event.key == K_s and self.waiting_reset == 0:
player = self.players[self.selected_player]
if player.has_ball:
if player.team == "red":
target_x = FIELD_RECT.right
else:
target_x = FIELD_RECT.left
accuracy = player.aggression * 0.8 + 0.2
offset = random.uniform(-100, 100) * (1 - accuracy)
self.ball.is_moving = True
self.ball.target_x = target_x
self.ball.target_y = CENTER_Y + offset
self.ball.speed = 15
player.has_ball = False
self.message = "射门！"
self.message_timer = 60
if event.key == K_SPACE and self.waiting_reset == 0:
player = self.players[self.selected_player]
if player.has_ball:
teammates = [p for p in self.players if p.team == player.team and p != player]
receiver = player.pass_ball(teammates, self.ball)
if receiver:
self.message = f"传球给{receiver.number}号！"
self.message_timer = 30
if receiver.team == "red":
self.switch_to_player(receiver)
if event.key == K_TAB:
self.switch_player()
if event.key == K_r:
self.reset_game()
def update(self):
# 更新控球统计
for player in self.players:
if player.has_ball:
self.possession[player.team] += 1
if self.player_switch_cooldown > 0:
self.player_switch_cooldown -= 1
if self.waiting_reset > 0:
self.waiting_reset -= 1
if self.waiting_reset == 0:
self.reset_positions()
return
self.game_time += 1
keys = pygame.key.get_pressed()
# 更新球员
for player in self.players:
action = player.move(keys, self.ball,
[p for p in self.players if p.team == player.team and p != player],
[p for p in self.players if p.team != player.team], self)
# 处理AI动作
if not (player.selected and player.team == "red"):
if action == "shoot" and player.has_ball:
if player.team == "red":
target_x = FIELD_RECT.right
else:
target_x = FIELD_RECT.left
accuracy = player.aggression * 0.7 + 0.3
offset = random.uniform(-80, 80) * (1 - accuracy)
self.ball.is_moving = True
self.ball.target_x = target_x
self.ball.target_y = CENTER_Y + offset
self.ball.speed = 15
player.has_ball = False
self.message = "电脑射门！"
self.message_timer = 60
elif action == "pass" and player.has_ball:
teammates = [p for p in self.players if p.team == player.team and p != player]
receiver = player.pass_ball(teammates, self.ball)
if receiver:
self.message = f"电脑传球！"
self.message_timer = 30
# 更新守门员
for goalie in self.goalies:
goalie.move(self.ball, self.players)
# 更新足球
self.ball.move()
# 检查足球与球员的碰撞
ball_holder = self.ball.check_collision(self.players + self.goalies)
if ball_holder:
# 修复：守门员没有number属性会导致错误
if isinstance(ball_holder, Goalie):
self.message = "守门员接球！"
else:
self.message = f"{ball_holder.number}号接球！"
self.message_timer = 30
# 记录最后持球队伍
self.last_ball_holder_team = ball_holder.team
# 如果是普通球员且是玩家队伍，切换到该球员
if not isinstance(ball_holder, Goalie):
if ball_holder.team == "red" and not ball_holder.selected:
self.switch_to_player(ball_holder)
elif ball_holder.team == "blue":
# 如果球被对方球员接到，自动切换到离球最近的队友
self.switch_to_closest_to_ball("red")
# 检查与守门员的碰撞
for goalie in self.goalies:
if self.ball.is_moving:
dist = math.sqrt((self.ball.x - goalie.x)**2 + (self.ball.y - goalie.y)**2)
if dist < (self.ball.radius + goalie.radius):
if random.random() < goalie.skill:
# 扑救成功
self.ball.is_moving = False
goalie.has_ball = True
self.message = "守门员扑救成功！"
self.message_timer = 60
# 记录最后持球队伍
self.last_ball_holder_team = goalie.team
if goalie.team == "blue":
self.switch_to_closest_to_ball("red")
else:
# 扑救失误
self.message = "守门员扑救失误！"
self.message_timer = 60
# 检查是否进球 - 只在球移动时检查
if self.ball.is_moving:
for i, goal in enumerate(self.goals):
if goal.collidepoint(self.ball.x, self.ball.y):
self.ball.is_moving = False
if i == 0: # 蓝队得分
self.score_blue += 1
self.message = "蓝队得分！"
else: # 红队得分
self.score_red += 1
self.message = "红队得分！"
self.message_timer = 60
self.waiting_reset = 90
break
# 如果球没人控制且静止
if not self.ball.is_moving and not any(p.has_ball for p in self.players + self.goalies):
closest_player = None
min_dist = float('inf')
for player in self.players + self.goalies:
dist = math.sqrt((player.x - self.ball.x)**2 + (player.y - self.ball.y)**2)
if dist < min_dist:
min_dist = dist
closest_player = player
if closest_player:
closest_player.has_ball = True
# 修复：添加对守门员的判断
if isinstance(closest_player, Goalie):
self.message = "守门员拿到球！"
else:
self.message = f"{closest_player.number}号拿到球！"
self.message_timer = 30
if not isinstance(closest_player, Goalie): # 普通球员
if closest_player.team == "red" and not closest_player.selected:
self.switch_to_player(closest_player)
elif closest_player.team == "blue":
# 如果球被对方控制，自动切换到离球最近的队友
self.switch_to_closest_to_ball("red")
if self.message_timer > 0:
self.message_timer -= 1
def draw(self):
screen.fill(LIGHT_GREEN)
# 绘制球场
pygame.draw.rect(screen, GREEN, FIELD_RECT)
pygame.draw.rect(screen, WHITE, FIELD_RECT, 3)
pygame.draw.line(screen, WHITE, (CENTER_X, FIELD_RECT.top), (CENTER_X, FIELD_RECT.bottom), 2)
pygame.draw.circle(screen, WHITE, (CENTER_X, CENTER_Y), 80, 2)
pygame.draw.circle(screen, WHITE, (CENTER_X, CENTER_Y), 5)
# 绘制禁区
pygame.draw.rect(screen, WHITE, (FIELD_RECT.left, CENTER_Y - 120, 120, 240), 2)
pygame.draw.rect(screen, WHITE, (FIELD_RECT.right - 120, CENTER_Y - 120, 120, 240), 2)
# 绘制球门
pygame.draw.rect(screen, WHITE, (FIELD_RECT.left, CENTER_Y - 100, 10, 200), 2)
pygame.draw.rect(screen, WHITE, (FIELD_RECT.right - 10, CENTER_Y - 100, 10, 200), 2)
# 绘制球门区
pygame.draw.rect(screen, WHITE, (FIELD_RECT.left, CENTER_Y - 50, 40, 100), 2)
pygame.draw.rect(screen, WHITE, (FIELD_RECT.right - 40, CENTER_Y - 50, 40, 100), 2)
# 绘制球员
for player in self.players:
player.draw()
# 绘制守门员
for goalie in self.goalies:
goalie.draw()
# 绘制足球
self.ball.draw()
# 绘制比分
score_text = font_large.render(f"{self.score_red} - {self.score_blue}", True, WHITE)
screen.blit(score_text, (CENTER_X - score_text.get_width() // 2, 10))
# 绘制时间
minutes = self.game_time // 3600
seconds = (self.game_time // 60) % 60
time_text = font_medium.render(f"{minutes:02d}:{seconds:02d}", True, WHITE)
screen.blit(time_text, (CENTER_X - time_text.get_width() // 2, 70))
# 绘制队伍名称
red_text = font_medium.render("玩家", True, RED)
blue_text = font_medium.render("电脑", True, BLUE)
screen.blit(red_text, (FIELD_RECT.left + 20, 10))
screen.blit(blue_text, (FIELD_RECT.right - blue_text.get_width() - 20, 10))
# 绘制控球率
total_possession = self.possession["red"] + self.possession["blue"]
if total_possession > 0:
red_percent = int(self.possession["red"] / total_possession * 100)
blue_percent = 100 - red_percent
possession_text = font_small.render(f"控球率: {red_percent}% - {blue_percent}%", True, WHITE)
screen.blit(possession_text, (CENTER_X - possession_text.get_width() // 2, 110))
# 绘制消息
if self.message_timer > 0:
msg_surface = font_medium.render(self.message, True, YELLOW)
screen.blit(msg_surface, (CENTER_X - msg_surface.get_width() // 2, CENTER_Y - 100))
# 绘制控制说明
controls = [
"方向键: 移动球员",
"空格键: 传球",
"S键: 射门",
"Shift键: 暴趟(加速)",
"Ctrl键: 抢断",
"Tab键: 切换球员",
"R键: 重置游戏"
]
for i, text in enumerate(controls):
ctrl_text = font_small.render(text, True, LIGHT_BLUE)
screen.blit(ctrl_text, (SCREEN_WIDTH - ctrl_text.get_width() - 20, 20 + i * 30))
# 创建游戏实例
game = FootballGame()
clock = pygame.time.Clock()
# 游戏主循环
while True:
game.handle_events()
game.update()
game.draw()
pygame.display.flip()
clock.tick(60)