Fifa by Gemini
unknown
python
16 days ago
25 kB
8
Indexable
import pygame
import sys
import math
import random
import numpy # Dla generowania dźwięku
# --- Skalowanie ---
SCALE_FACTOR = 1.5
# Inicjalizacja Pygame
pygame.init()
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)
# Ustawienia ekranu
SCREEN_WIDTH = int(800 * SCALE_FACTOR)
SCREEN_HEIGHT = int(600 * SCALE_FACTOR)
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Prosta Piłka Nożna v1.5 - Stylowi Bramkarze!")
# Kolory
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 128, 0)
DARK_GREEN = (0, 100, 0)
RED = (200, 0, 0) # Kolor Drużyny 2 (AI)
BLUE = (0, 0, 200) # Kolor Drużyny 1 (Gracz)
YELLOW = (255, 255, 0)
SKIN_TONE = (230, 190, 135)
GOALIE_JERSEY_COLOR_1 = (50, 150, 50) # Zielony strój bramkarza drużyny 1
GOALIE_JERSEY_COLOR_2 = (130, 60, 130) # Fioletowy strój bramkarza drużyny 2
# Ustawienia gry
FPS = 60
clock = pygame.time.Clock()
FONT_SIZE_LARGE = int(74 * SCALE_FACTOR)
FONT_SIZE_SMALL = int(36 * SCALE_FACTOR)
FONT_SIZE_TIMER = int(48 * SCALE_FACTOR)
FONT = pygame.font.Font(None, FONT_SIZE_LARGE)
SMALL_FONT = pygame.font.Font(None, FONT_SIZE_SMALL)
TIMER_FONT = pygame.font.Font(None, FONT_SIZE_TIMER)
mixer_init_result = pygame.mixer.get_init()
_SAMPLE_SIZE_BITS = abs(mixer_init_result[1]) if mixer_init_result and mixer_init_result[1] != 0 else 16
def generate_beep_sound_corrected(frequency=440, duration_ms=100): # Bez zmian
sample_rate = pygame.mixer.get_init()[0]
num_samples = int(sample_rate * duration_ms / 1000.0)
buf = numpy.zeros((num_samples, 2), dtype=numpy.int16)
max_sample = 2**(_SAMPLE_SIZE_BITS - 1) - 1
for i in range(num_samples):
t = float(i) / sample_rate
buf[i][0] = int(max_sample * math.sin(2 * math.pi * frequency * t))
buf[i][1] = int(max_sample * math.sin(2 * math.pi * frequency * t))
return pygame.sndarray.make_sound(buf)
try: # Bez zmian
KICK_SOUND = generate_beep_sound_corrected(660, 70)
GOAL_SOUND = generate_beep_sound_corrected(880, 300)
WALL_HIT_SOUND = generate_beep_sound_corrected(220, 50)
WHISTLE_SOUND = generate_beep_sound_corrected(1200, 500)
except Exception as e:
print(f"Nie udało się wygenerować dźwięków: {e}")
KICK_SOUND, GOAL_SOUND, WALL_HIT_SOUND, WHISTLE_SOUND = None, None, None, None
# Stany gry i czas (bez zmian)
GAME_STATE_KICK_OFF = "KICK_OFF"
GAME_STATE_PLAYING = "PLAYING"
GAME_STATE_FULL_TIME = "FULL_TIME"
GAME_STATE_SHOW_MESSAGE = "SHOW_MESSAGE"
current_game_state = GAME_STATE_KICK_OFF
message_text = "Przygotuj się!"
message_duration_frames = FPS * 2
next_state_after_message = GAME_STATE_PLAYING
HALF_DURATION_SECONDS = 60
half_timer = HALF_DURATION_SECONDS
current_half = 1
player1_attacks_right_goal = True
# Ustawienia boiska (bez zmian)
PITCH_MARGIN = int(50 * SCALE_FACTOR)
LINE_THICKNESS = int(5 * SCALE_FACTOR)
PITCH_RECT = pygame.Rect(PITCH_MARGIN, PITCH_MARGIN, SCREEN_WIDTH - 2 * PITCH_MARGIN, SCREEN_HEIGHT - 2 * PITCH_MARGIN)
CENTER_CIRCLE_RADIUS = int(50 * SCALE_FACTOR)
GOAL_POST_THICKNESS = int(10 * SCALE_FACTOR)
GOAL_OPENING_DEPTH = int(15*SCALE_FACTOR)
GOAL_HEIGHT = int(150 * SCALE_FACTOR)
PHYS_LEFT_GOAL_RECT = pygame.Rect(PITCH_RECT.left - GOAL_OPENING_DEPTH, PITCH_RECT.centery - GOAL_HEIGHT // 2, GOAL_OPENING_DEPTH, GOAL_HEIGHT)
PHYS_RIGHT_GOAL_RECT = pygame.Rect(PITCH_RECT.right, PITCH_RECT.centery - GOAL_HEIGHT // 2, GOAL_OPENING_DEPTH, GOAL_HEIGHT)
VIS_LEFT_GOAL_POSTS = pygame.Rect(PITCH_RECT.left - GOAL_POST_THICKNESS + LINE_THICKNESS, PITCH_RECT.centery - GOAL_HEIGHT // 2, GOAL_POST_THICKNESS, GOAL_HEIGHT)
VIS_RIGHT_GOAL_POSTS = pygame.Rect(PITCH_RECT.right - LINE_THICKNESS, PITCH_RECT.centery - GOAL_HEIGHT // 2, GOAL_POST_THICKNESS, GOAL_HEIGHT)
class Player(pygame.sprite.Sprite): # Bez zmian
def __init__(self, x, y, color, control_keys=None, is_ai=False):
super().__init__()
self.original_color = color
self.player_width = int(20 * SCALE_FACTOR)
self.player_height = int(30 * SCALE_FACTOR)
self.image = pygame.Surface([self.player_width, self.player_height], pygame.SRCALPHA)
self.image.fill((0,0,0,0))
torso_height = self.player_height * 0.7
torso_width = self.player_width * 0.8
torso_y_offset = self.player_height - torso_height
torso_rect_params = pygame.Rect((self.player_width - torso_width) / 2, torso_y_offset, torso_width, torso_height)
pygame.draw.rect(self.image, self.original_color, torso_rect_params, border_radius=int(3 * SCALE_FACTOR))
head_radius = self.player_width * 0.33
head_center_x = self.player_width / 2
head_center_y = torso_y_offset - head_radius + int(2*SCALE_FACTOR)
pygame.draw.circle(self.image, SKIN_TONE, (head_center_x, head_center_y), head_radius)
pygame.draw.circle(self.image, tuple(c*0.8 for c in self.original_color), (head_center_x, head_center_y), head_radius, int(1*SCALE_FACTOR))
self.rect = self.image.get_rect()
self.initial_pos = (x,y)
self.rect.center = self.initial_pos
self.speed = int(5 * SCALE_FACTOR)
self.control_keys = control_keys
self.is_ai = is_ai
def reset_position(self, new_initial_pos=None):
if new_initial_pos: self.initial_pos = new_initial_pos
self.rect.center = self.initial_pos
def update(self, ball): # Bez zmian w tej sekcji (poprawki AI były wcześniej)
if self.control_keys:
keys = pygame.key.get_pressed()
if keys[self.control_keys['up']]: self.rect.y -= self.speed
if keys[self.control_keys['down']]: self.rect.y += self.speed
if keys[self.control_keys['left']]: self.rect.x -= self.speed
if keys[self.control_keys['right']]: self.rect.x += self.speed
elif self.is_ai:
target_x = ball.rect.centerx
target_y = ball.rect.centery
ai_speed_factor = 0.65
current_ai_speed = self.speed * ai_speed_factor
boundary_safety_margin = self.player_height * 0.5
ball_near_boundary_margin = ball.radius + int(5 * SCALE_FACTOR)
is_ai_roughly_aligned_with_ball_x = abs(self.rect.centerx - ball.rect.centerx) < self.player_width * 2.5
is_stuck_top = (ball.rect.top < PITCH_RECT.top + ball_near_boundary_margin and \
self.rect.top < PITCH_RECT.top + boundary_safety_margin and \
is_ai_roughly_aligned_with_ball_x and \
self.rect.centery < ball.rect.centery + ball.radius)
is_stuck_bottom = (ball.rect.bottom > PITCH_RECT.bottom - ball_near_boundary_margin and \
self.rect.bottom > PITCH_RECT.bottom - boundary_safety_margin and \
is_ai_roughly_aligned_with_ball_x and \
self.rect.centery > ball.rect.centery - ball.radius)
if is_stuck_top or is_stuck_bottom:
current_ai_speed *= 0.9
if is_stuck_top: target_y = ball.rect.centery + self.player_height
else: target_y = ball.rect.centery - self.player_height
ai_attacks_left_goal = not player1_attacks_right_goal if self.original_color == RED else player1_attacks_right_goal
if ai_attacks_left_goal:
target_x = ball.rect.centerx + self.player_width * 1.5
if ball.rect.centerx > PITCH_RECT.centerx: target_x = PITCH_RECT.centerx
else:
target_x = ball.rect.centerx - self.player_width * 1.5
if ball.rect.centerx < PITCH_RECT.centerx: target_x = PITCH_RECT.centerx
if self.rect.centerx < target_x: self.rect.x += current_ai_speed
elif self.rect.centerx > target_x: self.rect.x -= current_ai_speed
if self.rect.centery < target_y: self.rect.y += current_ai_speed
elif self.rect.centery > target_y: self.rect.y -= current_ai_speed
self.rect.clamp_ip(PITCH_RECT)
class Goalkeeper(pygame.sprite.Sprite): # ZMODYFIKOWANY WYGLĄD
def __init__(self, jersey_color, team_color_for_head_outline, own_goal_rect, movement_area_rect):
super().__init__()
self.jersey_color = jersey_color # Główny kolor koszulki bramkarza
self.team_base_color = team_color_for_head_outline # Kolor drużyny (np. na obwódkę głowy)
self.width = int(22 * SCALE_FACTOR)
self.height = int(32 * SCALE_FACTOR)
self.image = pygame.Surface([self.width, self.height], pygame.SRCALPHA)
self.image.fill((0,0,0,0))
# Tułów (koszulka w paski)
torso_height_abs = self.height * 0.7
torso_width_abs = self.width * 0.9 # Tułów bramkarza nieco szerszy
torso_y_offset_abs = self.height - torso_height_abs
torso_left_abs = (self.width - torso_width_abs) / 2
stripe_color1 = self.jersey_color
# Drugi kolor paska - kontrastujący
if sum(stripe_color1) / 3 > 160: # Jeśli główny kolor jest stosunkowo jasny
stripe_color2 = tuple(max(0, c - 60) for c in stripe_color1) # Ciemniejszy odcień lub czarny
if sum(stripe_color2) / 3 > 100 : stripe_color2 = (40,40,40) # Jeśli nadal za jasny, daj ciemnoszary
else: # Jeśli główny kolor jest ciemny
stripe_color2 = tuple(min(255, c + 80) for c in stripe_color1) # Jaśniejszy odcień lub biały
if sum(stripe_color2) / 3 < 150 : stripe_color2 = (220,220,220) # Jeśli nadal za ciemny, daj jasnoszary
num_vertical_stripes = 5
single_stripe_width = torso_width_abs / num_vertical_stripes
for i in range(num_vertical_stripes):
s_x = torso_left_abs + i * single_stripe_width
current_s_color = stripe_color1 if i % 2 == 0 else stripe_color2
s_w = single_stripe_width
if i == num_vertical_stripes - 1: # Ostatni pasek - dociągnij do krawędzi
s_w = torso_left_abs + torso_width_abs - s_x
stripe_rect = pygame.Rect(s_x, torso_y_offset_abs, s_w, torso_height_abs)
pygame.draw.rect(self.image, current_s_color, stripe_rect)
# Głowa (podobna do zawodnika z pola)
head_radius_abs = self.width * 0.30
head_center_x_abs = self.width / 2
head_center_y_abs = torso_y_offset_abs - head_radius_abs + int(2*SCALE_FACTOR)
pygame.draw.circle(self.image, SKIN_TONE, (head_center_x_abs, head_center_y_abs), head_radius_abs)
pygame.draw.circle(self.image, tuple(c*0.8 for c in self.team_base_color),
(head_center_x_abs, head_center_y_abs), head_radius_abs, int(1*SCALE_FACTOR))
self.rect = self.image.get_rect()
self.movement_area = movement_area_rect
self.rect.center = self.movement_area.center
self.speed = int(4.5 * SCALE_FACTOR)
self.own_goal_rect = own_goal_rect
def update(self, ball): # Bez zmian
target_y = ball.rect.centery
if self.rect.centery < target_y: self.rect.y += self.speed
elif self.rect.centery > target_y: self.rect.y -= self.speed
self.rect.clamp_ip(self.movement_area)
def reset_position(self): # Bez zmian
self.rect.center = self.movement_area.center
class Ball(pygame.sprite.Sprite): # Bez zmian
def __init__(self, x, y):
super().__init__()
self.radius = int(7 * SCALE_FACTOR)
self.image = pygame.Surface([self.radius*2, self.radius*2], pygame.SRCALPHA)
self.image.fill((0,0,0,0))
pygame.draw.circle(self.image, YELLOW, (self.radius, self.radius), self.radius)
pygame.draw.circle(self.image, BLACK, (self.radius, self.radius), self.radius, int(1*SCALE_FACTOR))
self.rect = self.image.get_rect()
self.rect.center = (x, y)
self.velocity_x = 0
self.velocity_y = 0
self.max_speed = int(8 * SCALE_FACTOR)
self.friction = 0.985
def update(self): # Bez zmian
self.rect.x += self.velocity_x
self.rect.y += self.velocity_y
self.velocity_x *= self.friction
self.velocity_y *= self.friction
if abs(self.velocity_x) < 0.1: self.velocity_x = 0
if abs(self.velocity_y) < 0.1: self.velocity_y = 0
if self.rect.top < PITCH_RECT.top + LINE_THICKNESS:
self.rect.top = PITCH_RECT.top + LINE_THICKNESS; self.velocity_y *= -1
if WALL_HIT_SOUND: WALL_HIT_SOUND.play()
elif self.rect.bottom > PITCH_RECT.bottom - LINE_THICKNESS:
self.rect.bottom = PITCH_RECT.bottom - LINE_THICKNESS; self.velocity_y *= -1
if WALL_HIT_SOUND: WALL_HIT_SOUND.play()
is_aligned_with_left_goal_y = PHYS_LEFT_GOAL_RECT.top <= self.rect.centery <= PHYS_LEFT_GOAL_RECT.bottom
is_aligned_with_right_goal_y = PHYS_RIGHT_GOAL_RECT.top <= self.rect.centery <= PHYS_RIGHT_GOAL_RECT.bottom
if self.rect.left < PITCH_RECT.left + LINE_THICKNESS:
if not (is_aligned_with_left_goal_y and self.rect.right > PHYS_LEFT_GOAL_RECT.right - self.radius * 2):
self.rect.left = PITCH_RECT.left + LINE_THICKNESS; self.velocity_x *= -1
if WALL_HIT_SOUND: WALL_HIT_SOUND.play()
elif self.rect.right > PITCH_RECT.right - LINE_THICKNESS:
if not (is_aligned_with_right_goal_y and self.rect.left < PHYS_RIGHT_GOAL_RECT.left + self.radius * 2):
self.rect.right = PITCH_RECT.right - LINE_THICKNESS; self.velocity_x *= -1
if WALL_HIT_SOUND: WALL_HIT_SOUND.play()
def kick(self, kicker_rect, kicker_type="field_player"): # Bez zmian
if KICK_SOUND: KICK_SOUND.play()
kick_strength_factor = 1.25
if kicker_type == "goalie":
kick_strength_factor = 1.0
is_left_goalie = kicker_rect.centerx < SCREEN_WIDTH / 2
kick_direction_x = 1 if is_left_goalie else -1
offset_y = (self.rect.centery - kicker_rect.centery)
if abs(offset_y) < kicker_rect.height / 4 :
offset_y = random.uniform(-self.radius * 2, self.radius * 2)
angle = math.atan2(offset_y, kick_direction_x * (PITCH_RECT.width / 4) )
else:
angle = math.atan2(self.rect.centery - kicker_rect.centery, self.rect.centerx - kicker_rect.centerx)
kick_strength = self.max_speed * kick_strength_factor
self.velocity_x = kick_strength * math.cos(angle)
self.velocity_y = kick_strength * math.sin(angle)
speed = math.hypot(self.velocity_x, self.velocity_y)
if speed > kick_strength:
self.velocity_x = (self.velocity_x / speed) * kick_strength
self.velocity_y = (self.velocity_y / speed) * kick_strength
overlap_iterations = 0
max_overlap_iterations = 15
push_angle = math.atan2(self.rect.centery - kicker_rect.centery, self.rect.centerx - kicker_rect.centerx)
while self.rect.colliderect(kicker_rect) and overlap_iterations < max_overlap_iterations:
self.rect.x += math.cos(push_angle)
self.rect.y += math.sin(push_angle)
overlap_iterations += 1
if self.rect.colliderect(kicker_rect) :
kicker_radius_approx = max(kicker_rect.width, kicker_rect.height) / 2
required_sep = kicker_radius_approx + self.radius + int(3*SCALE_FACTOR)
self.rect.centerx = kicker_rect.centerx + math.cos(push_angle) * required_sep
self.rect.centery = kicker_rect.centery + math.sin(push_angle) * required_sep
def reset(self): # Bez zmian
self.rect.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
self.velocity_x = 0; self.velocity_y = 0
# Tworzenie obiektów (bez zmian w logice, tylko przekazanie dodatkowego koloru do Goalkeeper)
all_sprites = pygame.sprite.Group()
players_group = pygame.sprite.Group()
goalies_group = pygame.sprite.Group()
P1_START_POS_LEFT = (PITCH_RECT.centerx - int(200 * SCALE_FACTOR), PITCH_RECT.centery)
P1_START_POS_RIGHT = (PITCH_RECT.centerx + int(200 * SCALE_FACTOR), PITCH_RECT.centery)
AI_START_POS_LEFT = (PITCH_RECT.centerx - int(200 * SCALE_FACTOR), PITCH_RECT.centery)
AI_START_POS_RIGHT = (PITCH_RECT.centerx + int(200 * SCALE_FACTOR), PITCH_RECT.centery)
player1_keys = {'up': pygame.K_w, 'down': pygame.K_s, 'left': pygame.K_a, 'right': pygame.K_d}
player1 = Player(P1_START_POS_LEFT[0], P1_START_POS_LEFT[1], BLUE, player1_keys)
player2 = Player(AI_START_POS_RIGHT[0], AI_START_POS_RIGHT[1], RED, is_ai=True)
ball = Ball(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
all_sprites.add(player1, player2, ball)
players_group.add(player1, player2)
GOALIE_AREA_WIDTH = int(30 * SCALE_FACTOR)
GOALIE_AREA_OFFSET_X = int(10 * SCALE_FACTOR)
left_goalie_movement_area = pygame.Rect(PHYS_LEFT_GOAL_RECT.right - GOALIE_AREA_OFFSET_X, PHYS_LEFT_GOAL_RECT.top, GOALIE_AREA_WIDTH, PHYS_LEFT_GOAL_RECT.height)
right_goalie_movement_area = pygame.Rect(PHYS_RIGHT_GOAL_RECT.left - GOALIE_AREA_WIDTH + GOALIE_AREA_OFFSET_X, PHYS_RIGHT_GOAL_RECT.top, GOALIE_AREA_WIDTH, PHYS_RIGHT_GOAL_RECT.height)
# Przy tworzeniu bramkarzy przekazujemy teraz kolor drużyny dla obwódki głowy
goalie1 = Goalkeeper(GOALIE_JERSEY_COLOR_1, BLUE, PHYS_LEFT_GOAL_RECT, left_goalie_movement_area)
goalie2 = Goalkeeper(GOALIE_JERSEY_COLOR_2, RED, PHYS_RIGHT_GOAL_RECT, right_goalie_movement_area)
all_sprites.add(goalie1, goalie2)
goalies_group.add(goalie1, goalie2)
score_player1 = 0
score_player2 = 0
def setup_half(): # Zmodyfikowano, aby przekazać team_base_color (choć jest stały dla instancji)
ball.reset()
if player1_attacks_right_goal:
player1.reset_position(P1_START_POS_LEFT)
goalie1.movement_area = left_goalie_movement_area; goalie1.own_goal_rect = PHYS_LEFT_GOAL_RECT; goalie1.team_base_color = BLUE; goalie1.reset_position()
player2.reset_position(AI_START_POS_RIGHT)
goalie2.movement_area = right_goalie_movement_area; goalie2.own_goal_rect = PHYS_RIGHT_GOAL_RECT; goalie2.team_base_color = RED; goalie2.reset_position()
else:
player1.reset_position(P1_START_POS_RIGHT)
goalie1.movement_area = right_goalie_movement_area; goalie1.own_goal_rect = PHYS_RIGHT_GOAL_RECT; goalie1.team_base_color = BLUE; goalie1.reset_position()
player2.reset_position(AI_START_POS_LEFT)
goalie2.movement_area = left_goalie_movement_area; goalie2.own_goal_rect = PHYS_LEFT_GOAL_RECT; goalie2.team_base_color = RED; goalie2.reset_position()
setup_half()
# Funkcje rysujące i pętla główna (bez zmian)
def draw_pitch():
screen.fill(DARK_GREEN)
pygame.draw.rect(screen, GREEN, PITCH_RECT)
pygame.draw.rect(screen, WHITE, PITCH_RECT, LINE_THICKNESS)
pygame.draw.line(screen, WHITE, (PITCH_RECT.centerx, PITCH_RECT.top), (PITCH_RECT.centerx, PITCH_RECT.bottom), LINE_THICKNESS)
pygame.draw.circle(screen, WHITE, PITCH_RECT.center, CENTER_CIRCLE_RADIUS, LINE_THICKNESS)
pygame.draw.rect(screen, WHITE, VIS_LEFT_GOAL_POSTS)
pygame.draw.rect(screen, WHITE, VIS_RIGHT_GOAL_POSTS)
def draw_scores():
score1_text = SMALL_FONT.render(str(score_player1), True, WHITE)
score2_text = SMALL_FONT.render(str(score_player2), True, WHITE)
screen.blit(score1_text, (PITCH_MARGIN + int(20*SCALE_FACTOR), int(10*SCALE_FACTOR)))
screen.blit(score2_text, (SCREEN_WIDTH - PITCH_MARGIN - int(40*SCALE_FACTOR) - score2_text.get_width()/2 , int(10*SCALE_FACTOR)))
def draw_timer():
timer_text_str = ""
if current_game_state == GAME_STATE_PLAYING:
minutes = int(half_timer) // 60
seconds = int(half_timer) % 60
timer_text_str = f"{minutes:02}:{seconds:02}"
elif message_text == "Przerwa! Zmiana stron.": timer_text_str = "PRZERWA"
elif current_game_state == GAME_STATE_FULL_TIME or message_text.startswith("Koniec Meczu!"): timer_text_str = "KONIEC"
elif current_game_state == GAME_STATE_KICK_OFF or current_game_state == GAME_STATE_SHOW_MESSAGE:
if message_text == "Przygotuj się!": timer_text_str = "START"
elif "GOL!" in message_text: timer_text_str = "GOL!"
else: timer_text_str = "1. POŁOWA" if current_half == 1 else "2. POŁOWA"
timer_surface = TIMER_FONT.render(timer_text_str, True, YELLOW)
timer_rect = timer_surface.get_rect(center=(SCREEN_WIDTH / 2, PITCH_MARGIN / 2 + int(5*SCALE_FACTOR) ))
screen.blit(timer_surface, timer_rect)
def show_message_and_set_next_state(msg_text, duration_sec, next_state):
global current_game_state, message_text, message_duration_frames, next_state_after_message
current_game_state = GAME_STATE_SHOW_MESSAGE
message_text = msg_text
message_duration_frames = FPS * duration_sec
next_state_after_message = next_state
running = True
show_message_and_set_next_state("Przygotuj się!", 2, GAME_STATE_KICK_OFF)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT: running = False
if current_game_state == GAME_STATE_SHOW_MESSAGE:
message_duration_frames -= 1
if message_duration_frames <= 0:
current_game_state = next_state_after_message
if current_game_state == GAME_STATE_KICK_OFF or \
(current_game_state == GAME_STATE_PLAYING and ("GOL!" in message_text or "Rozpoczęcie" in message_text or "Przygotuj się!" in message_text)):
setup_half()
if WHISTLE_SOUND and ("Rozpoczęcie" in message_text or "Przygotuj się!" in message_text): WHISTLE_SOUND.play()
elif current_game_state == GAME_STATE_KICK_OFF:
show_message_and_set_next_state(f"Rozpoczęcie {current_half}. połowy!", 2, GAME_STATE_PLAYING)
elif current_game_state == GAME_STATE_PLAYING:
half_timer -= 1 / FPS
if half_timer <= 0:
if WHISTLE_SOUND: WHISTLE_SOUND.play()
if current_half == 1:
current_half = 2
player1_attacks_right_goal = not player1_attacks_right_goal
half_timer = HALF_DURATION_SECONDS
show_message_and_set_next_state("Przerwa! Zmiana stron.", 3, GAME_STATE_KICK_OFF)
else:
current_game_state = GAME_STATE_FULL_TIME
final_msg = f"Koniec Meczu! Wynik: {score_player1} - {score_player2}"
show_message_and_set_next_state(final_msg, 10, GAME_STATE_FULL_TIME)
else:
for player_sprite in players_group: player_sprite.update(ball)
for goalie_sprite in goalies_group: goalie_sprite.update(ball)
ball.update()
for player_sprite in players_group:
if pygame.sprite.collide_rect(player_sprite, ball):
ball.kick(player_sprite.rect, kicker_type="field_player")
for goalie_sprite in goalies_group:
if pygame.sprite.collide_rect(goalie_sprite, ball):
ball.kick(goalie_sprite.rect, kicker_type="goalie")
goal_this_frame = False; msg_on_goal = ""
if player1_attacks_right_goal:
if PHYS_RIGHT_GOAL_RECT.colliderect(ball.rect): score_player1 += 1; goal_this_frame = True; msg_on_goal = "GRACZ 1 GOL!"
elif PHYS_LEFT_GOAL_RECT.colliderect(ball.rect): score_player2 += 1; goal_this_frame = True; msg_on_goal = "AI GOL!"
else:
if PHYS_LEFT_GOAL_RECT.colliderect(ball.rect): score_player1 += 1; goal_this_frame = True; msg_on_goal = "GRACZ 1 GOL!"
elif PHYS_RIGHT_GOAL_RECT.colliderect(ball.rect): score_player2 += 1; goal_this_frame = True; msg_on_goal = "AI GOL!"
if goal_this_frame:
if GOAL_SOUND: GOAL_SOUND.play()
show_message_and_set_next_state(msg_on_goal, 2, GAME_STATE_PLAYING)
elif current_game_state == GAME_STATE_FULL_TIME: pass
draw_pitch()
all_sprites.draw(screen)
draw_scores()
draw_timer()
if current_game_state == GAME_STATE_SHOW_MESSAGE:
text_surface = FONT.render(message_text, True, YELLOW)
text_rect = text_surface.get_rect(center=(SCREEN_WIDTH/2, SCREEN_HEIGHT/2))
bg_rect = text_rect.inflate(int(20*SCALE_FACTOR), int(20*SCALE_FACTOR))
bg_shadow_rect = bg_rect.move(int(3*SCALE_FACTOR), int(3*SCALE_FACTOR))
pygame.draw.rect(screen, (0,0,0,150) if bg_shadow_rect.width > 0 and bg_shadow_rect.height > 0 else BLACK, bg_shadow_rect)
pygame.draw.rect(screen, BLACK, bg_rect)
pygame.draw.rect(screen, YELLOW, bg_rect, int(3*SCALE_FACTOR))
screen.blit(text_surface, text_rect)
pygame.display.flip()
clock.tick(FPS)
pygame.quit()
sys.exit()Editor is loading...
Leave a Comment