def random_destination(self):
w, h = SCREEN_SIZE
self.ant.destination = Vector2(randint(0, w), randint(0, h))
def __init__(self):
self.body = [Vector2(5, 10), Vector2(4, 10), Vector2(3, 10)]
self.direction = Vector2(1, 0)
self.new_block = False
def tick(self):
#ograniczenie pola
if self.p_pos.x >= 943:
self.p_pos.x = 942
if self.p_pos.x <= 387:
self.p_pos.x = 388
if self.p_pos.y >= 536:
self.p_pos.y = 535
if self.p_pos.y <= 194:
self.p_pos.y = 195
if self.p_v == Vector2(0, 10):
self.p_v = Vector2(0, 9.9)
else:
self.p_v += self.p_a
self.p_pos += self.p_v
self.p_a *= 0.1
self.p_v *= 0.5
if self.p2_pos.x >= 943:
self.p2_pos.x = 942
if self.p2_pos.x <= 387:
self.p2_pos.x = 388
if self.p2_pos.y >= 536:
self.p2_pos.y = 535
if self.p2_pos.y <= 194:
self.p2_pos.y = 195
if self.p2_v == Vector2(0, 10):
self.p2_v = Vector2(0, 9.9)
else:
self.p2_v += self.p2_a
self.p2_pos += self.p2_v
self.p2_a *= 0.1
self.p2_v *= 0.5
# ruch gracza 1
if pygame.key.get_pressed()[pygame.K_w]:
self.p_a += Vector2(0, -0.5)
self.play = pygame.image.load('bolid_red_up.png')
if pygame.key.get_pressed()[pygame.K_d]:
self.p_a += Vector2(0.5, 0)
self.play = pygame.image.load('bolid_red_right.png')
if pygame.key.get_pressed()[pygame.K_s]:
self.p_a += Vector2(0, 0.5)
self.play = pygame.image.load('bolid_red_down.png')
if pygame.key.get_pressed()[pygame.K_a]:
self.p_a += Vector2(-0.5, 0)
self.play = pygame.image.load('bolid_red_left.png')
if pygame.key.get_pressed()[pygame.K_d] and pygame.key.get_pressed()[
pygame.K_s]:
self.play = pygame.image.load('bolid_red_down_right.png')
if pygame.key.get_pressed()[pygame.K_s] and pygame.key.get_pressed()[
pygame.K_a]:
self.play = pygame.image.load('bolid_red_down_left.png')
if pygame.key.get_pressed()[pygame.K_w] and pygame.key.get_pressed()[
pygame.K_d]:
self.play = pygame.image.load('bolid_red_up_right.png')
if pygame.key.get_pressed()[pygame.K_w] and pygame.key.get_pressed()[
pygame.K_a]:
self.play = pygame.image.load('bolid_red_up_left.png')
# ruch gracza 2
if pygame.key.get_pressed()[pygame.K_UP]:
self.p2_a += Vector2(0, -0.5)
self.play2 = pygame.image.load('bolid_blue_up.png')
if pygame.key.get_pressed()[pygame.K_RIGHT]:
self.p2_a += Vector2(0.5, 0)
self.play2 = pygame.image.load('bolid_blue_right.png')
if pygame.key.get_pressed()[pygame.K_DOWN]:
self.p2_a += Vector2(0, 0.5)
self.play2 = pygame.image.load('bolid_blue_down.png')
if pygame.key.get_pressed()[pygame.K_LEFT]:
self.p2_a += Vector2(-0.5, 0)
self.play2 = pygame.image.load('bolid_blue_left.png')
if pygame.key.get_pressed()[
pygame.K_RIGHT] and pygame.key.get_pressed()[pygame.K_DOWN]:
self.play2 = pygame.image.load('bolid_blue_down_right.png')
if pygame.key.get_pressed()[
pygame.K_LEFT] and pygame.key.get_pressed()[pygame.K_DOWN]:
self.play2 = pygame.image.load('bolid_blue_down_left.png')
if pygame.key.get_pressed()[pygame.K_UP] and pygame.key.get_pressed()[
pygame.K_RIGHT]:
self.play2 = pygame.image.load('bolid_blue_up_right.png')
if pygame.key.get_pressed()[pygame.K_UP] and pygame.key.get_pressed()[
pygame.K_LEFT]:
self.play2 = pygame.image.load('bolid_blue_up_left.png')
if self.grass_1.collidepoint(
(self.p_pos.x, self.p_pos.y)) or self.grass_2.collidepoint(
(self.p_pos.x, self.p_pos.y)) or self.grass_3.collidepoint(
(self.p_pos.x, self.p_pos.y)) or self.grass_4.collidepoint(
(self.p_pos.x,
self.p_pos.y)) or self.grass_5.collidepoint(
(self.p_pos.x,
self.p_pos.y)) or self.grass_6.collidepoint(
(self.p_pos.x,
self.p_pos.y)) or self.grass_7.collidepoint(
(self.p_pos.x, self.p_pos.y
)) or self.grass_8.collidepoint(
(self.p_pos.x, self.p_pos.y
)) or self.grass_9.collidepoint(
(self.p_pos.x, self.p_pos.y)
) or self.grass_10.collidepoint(
(self.p_pos.x, self.p_pos.y)):
self.p_a *= 0.1
if self.grass_1.collidepoint(
(self.p2_pos.x, self.p2_pos.y)) or self.grass_2.collidepoint(
(self.p2_pos.x, self.p2_pos.y)) or self.grass_3.collidepoint(
(self.p2_pos.x,
self.p2_pos.y)) or self.grass_4.collidepoint(
(self.p2_pos.x,
self.p2_pos.y)) or self.grass_5.collidepoint(
(self.p2_pos.x,
self.p2_pos.y)) or self.grass_6.collidepoint(
(self.p2_pos.x, self.p2_pos.y
)) or self.grass_7.collidepoint(
(self.p2_pos.x, self.p2_pos.y
)) or self.grass_8.collidepoint(
(self.p2_pos.x, self.p2_pos.y)
) or self.grass_9.collidepoint(
(self.p2_pos.x, self.p2_pos.y
)) or self.grass_10.collidepoint(
(self.p2_pos.x,
self.p2_pos.y)):
self.p2_a *= 0.1
#checkpoints
if self.check_1.collidepoint(
(self.p_pos.x, self.p_pos.y)) and self.check < 1:
self.check += 1
print(self.check)
pygame.mixer.music.load('UI_Quirky1.mp3')
pygame.mixer.music.play()
if self.check_1.collidepoint(
(self.p2_pos.x, self.p2_pos.y)) and self.check2 < 1:
self.check2 += 1
print(self.check2)
pygame.mixer.music.load('UI_Quirky1.mp3')
pygame.mixer.music.play()
if self.check_2.collidepoint(
(self.p_pos.x, self.p_pos.y)) and self.check == 1:
self.check += 1
print(self.check)
pygame.mixer.music.load('UI_Quirky1.mp3')
pygame.mixer.music.play()
if self.check_2.collidepoint(
(self.p2_pos.x, self.p2_pos.y)) and self.check2 == 1:
self.check2 += 1
print(self.check2)
pygame.mixer.music.load('UI_Quirky1.mp3')
pygame.mixer.music.play()
#linia mety
if self.check >= 2 and self.stop.collidepoint(
(self.p_pos.x, self.p_pos.y)):
pygame.mixer.music.load('UI_Quirky1.mp3')
pygame.mixer.music.play()
self.check = 0
self.lap += 1
if self.check2 >= 2 and self.stop.collidepoint(
(self.p2_pos.x, self.p2_pos.y)):
pygame.mixer.music.load('UI_Quirky1.mp3')
pygame.mixer.music.play()
self.check2 = 0
self.lap2 += 1
if self.lap >= 0:
pygame.mixer.music.load('win.mp3')
pygame.mixer.music.play()
Win_red()
if self.lap2 >= 4:
pygame.mixer.music.load('win.mp3')
pygame.mixer.music.play()
Win_blue()
def chunk(self):
chunk = Asteroid(self.bounds, mass=self.mass - 1)
chunk.pos = self.pos
chunk.velocity = self.velocity.rotate(random.uniform(180, 360)) * 2
chunk.exact_pos = Vector2(chunk.pos)
return chunk
apple = pygame.image.load('Graphics/tatha3.png').convert_alpha()
main_game = MAIN()
SCREEN_UPDATE = pygame.USEREVENT
pygame.time.set_timer(SCREEN_UPDATE, 150)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == SCREEN_UPDATE:
main_game.update()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
if main_game.snake.direction.y != 1:
main_game.snake.direction = Vector2(0, -1)
if event.key == pygame.K_DOWN:
if main_game.snake.direction.y != -1:
main_game.snake.direction = Vector2(0, 1)
if event.key == pygame.K_LEFT:
if main_game.snake.direction.x != 1:
main_game.snake.direction = Vector2(-1, 0)
if event.key == pygame.K_RIGHT:
if main_game.snake.direction.x != -1:
main_game.snake.direction = Vector2(1, 0)
screen.fill((175, 215, 70))
main_game.draw_elements()
pygame.display.update()
clock.tick(60) # how many times can the while loop run per second
def aim(self):
angle = Vector2(-1, 0).angle_to(self.target_enemy.position - self.position)
image = self.get_rotated_image(angle)
self.image = image # pygame.transform.scale(image, CELL_SIZE)
if active:
change = j.get_button(0)
if change:
sleep(0.2)
if j.get_button(0):
if switch == True:
switch = False
print('Arm')
else:
switch = True
print('Motor')
if switch:
motorcode()
vec = Vector2(x1, y1)
radius, angle = vec.as_polar()
adjusted_angle = (angle + 90) % 360
pygame.display.set_caption('Gear {:2d} '.format(gear))
# Rotate the image and get a new rect.
player_rotated = pygame.transform.rotozoom(
player_img, -adjusted_angle, 1)
player_rect = player_rotated.get_rect(
center=player_rect.center)
screen.fill((30, 30, 30))
screen.blit(player_rotated, player_rect)
pygame.display.flip()
clock.tick(60)
else:
arm()
def update_rabo_graphics(self):
rabo_relacao = self.corpo[-2] - self.corpo[-1]
if rabo_relacao == Vector2(1, 0): self.rabo = self.rabo_esquerda
elif rabo_relacao == Vector2(-1, 0): self.rabo = self.rabo_direita
elif rabo_relacao == Vector2(0, 1): self.rabo = self.rabo_cima
elif rabo_relacao == Vector2(0, -1): self.rabo = self.rabo_baixo
def reset(self):
""" additionally to entity reset: randomizes position and direction as well """
super().reset()
self.velocity = Vector2()
self.direction = Vector2(random.uniform(-1, 1), random.uniform(-1, 1)).normalize()
TELA_UPDATE = pygame.USEREVENT
pygame.time.set_timer(TELA_UPDATE, 150)
main_game = MAIN()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
if event.type == TELA_UPDATE:
main_game.update()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
if main_game.cobra.direcao.y != 1:
main_game.cobra.direcao = Vector2(0, -1)
if event.key == pygame.K_RIGHT:
if main_game.cobra.direcao.x != -1:
main_game.cobra.direcao = Vector2(1, 0)
if event.key == pygame.K_DOWN:
if main_game.cobra.direcao.y != -1:
main_game.cobra.direcao = Vector2(0, 1)
if event.key == pygame.K_LEFT:
if main_game.cobra.direcao.x != 1:
main_game.cobra.direcao = Vector2(-1, 0)
tela.fill((175, 215, 70))
main_game.draw_elementos()
pygame.display.update()
relogio.tick(60)
def reset(self):
self.corpo = [Vector2(5, 10), Vector2(4, 10), Vector2(3, 10)]
self.direcao = Vector2(0, 0)
def update(self, dt):
"""Show tutorial messages when it necessary."""
self.curTime += dt
screenSize = Game.ui_manager.window_resolution
hintRect = Rect(10, 10, screenSize[1] - 10, 100)
if not self.moveHint and self.curTime > 1:
self.hintText = pygame_gui.elements.UITextBox(
"<font size=\"5\">" + Localization.TUTORIAL_MOVEMENT +
"</font>", hintRect, Game.ui_manager)
# seems TEXT_EFFECT_FADE_IN/TEXT_EFFECT_FADE_OUT don't work :(
self.hintText.set_active_effect(
pygame_gui.TEXT_EFFECT_TYPING_APPEAR)
self.playerTank = None
for obj in Game.all_objects:
if isinstance(obj, PlayerTank):
self.playerTank = obj
assert self.playerTank is not None
self.startPos = Vector2(self.playerTank.pos)
self.moveHint = True
if (not self.shootHint and self.curTime > 3
and self.startPos.distance_to(
self.playerTank.pos) > Game.current_scene.cellSize):
self.hintText.kill()
self.hintText = pygame_gui.elements.UITextBox(
"<font size=\"5\">" + Localization.TUTORIAL_SHOOTING +
"</font>", hintRect, Game.ui_manager)
self.hintText.set_active_effect(
pygame_gui.TEXT_EFFECT_TYPING_APPEAR)
self.numShoots = 0
self.shootHint = True
numEnemies = 0
for obj in Game.all_objects:
if isinstance(obj, EnemyTank):
numEnemies += 1
if not self.killHint and self.shootHint and self.numShoots > 3:
self.hintText.kill()
self.hintText = pygame_gui.elements.UITextBox(
"<font size=\"5\">" + Localization.TUTORIAL_KILL +
f" (0/{numEnemies})" + "</font>", hintRect, Game.ui_manager)
self.hintText.set_active_effect(
pygame_gui.TEXT_EFFECT_TYPING_APPEAR)
self.killHint = True
for obj in Game.all_objects:
if isinstance(obj, Spawner):
obj.spawnsLeft = 0
if self.killHint and numEnemies != self.prevEnemies:
self.killed += self.prevEnemies - numEnemies
self.hintText.kill()
self.hintText = pygame_gui.elements.UITextBox(
"<font size=\"5\">" + Localization.TUTORIAL_KILL +
f" ({self.killed}/{self.killed+numEnemies})" + "</font>",
hintRect, Game.ui_manager)
if self.killHint and numEnemies == 0:
Game.stats_required = True
MainMenu.MainMenu() # todo: show some message
self.prevEnemies = numEnemies
def entry_actions(self):
self.ant.speed = 60.
random_offset = Vector2(randint(-20, 20), randint(-20, 20))
self.ant.destination = Vector2(*NEST_POSITION) + random_offset
def check_conditions(self):
if Vector2(*NEST_POSITION - self.ant.location).length() < NEST_SIZE:
if (randint(1, 10) == 1):
self.ant.drop(self.ant.world.background)
return "exploring"
return None
def debug_create_objects(object_list):
kinetic = GameBall(
1, # mass
object_list, # object_list
SCREEN_SIZE, # bounds
Vector2(
random.randint(20, SCREEN_SIZE[0] - 20),
random.randint(20, SCREEN_SIZE[1] - 20),
), # position
Vector2(4, 2), # velocity
[255, 10, 0], # color
20, # radius
)
object_list.append(kinetic)
block = AltBreak(
Vector2(50, 20), 50, 20, [0, 0, 255]
) # position width height color
object_list.extend((block,))
block = AltBreak(
Vector2(151, 20), 50, 20, [0, 0, 255]
) # position width height color
object_list.extend((block,))
block = Breakable(Vector2(252, 20), 50, 20, [0, 0, 255]) # position width height color
object_list.extend((block,))
block = Breakable(Vector2(353, 20), 50, 20, [0, 0, 255]) # position width height color
object_list.extend((block,))
block = AltBreak(
Vector2(50, 80), 50, 20, [0, 0, 255]
) # position width height color
object_list.extend((block,))
block = Breakable(Vector2(151, 80), 50, 20, [0, 0, 255]) # position width height color
object_list.extend((block,))
block = Breakable(Vector2(252, 80), 50, 20, [0, 0, 255]) # position width height color
object_list.extend((block,))
block = AltBreak(
Vector2(353, 80), 50, 20, [0, 0, 255]
) # position width height color
object_list.extend((block,))
block = Paddle(Vector2(1, 799), 100, 50, [0, 0, 0])
object_list.extend((block,))
# IMPORT CYTHON VERSION
from EC_GAME import momentum_angle_free, momentum_trigonometry
# IMPORT C VERSION
from ECC import momentum_angle_free_c, momentum_trigonometry_c
import pygame
from pygame.math import Vector2
if __name__ == '__main__':
import timeit
v1 = Vector2(0.707, 0.707)
x1 = Vector2(0.0, 0.0)
v2 = Vector2(-0.707, -0.707)
x2 = Vector2(1.4142, 1.4142)
m1 = 1.0
m2 = 1.0
x1x = x1.x
x1y = x1.y
x2x = x2.x
x2y = x2.y
v1x = v1.x
v1y = v1.y
v2x = v2.x
v2y = v2.y
invert = False
vec1, vec2 = momentum_angle_free(v1x, v1y, v2x, v2y, m1, m2, x1x, x1y, x2x,
x2y, invert)
def __init__(self, target_enemy, parent_tower, *groups):
super().__init__(*groups)
self.target_enemy = target_enemy
self.parent_tower = parent_tower
self.position = Vector2(self.parent_tower.position)
self.image = self.get_rotated_image(0)
from pygame.math import Vector2
from pygame.transform import rotozoom
from utils import load_sprite, wrap_position
UP = Vector2(0, -1)
class GameObject:
def __init__(self, position, sprite, velocity):
self.position = Vector2(position)
self.sprite = sprite
self.radius = sprite.get_width() / 2
self.velocity = Vector2(velocity)
def draw(self, surface):
blit_position = self.position - Vector2(self.radius)
surface.blit(self.sprite, blit_position)
def move(self, surface):
self.position = wrap_position(self.position + self.velocity, surface)
def collides_with(self, other_obj):
distance = self.position.distance_to(other_obj.position)
return distance < self.radius + other_obj.radius
class Spaceship(GameObject):
MANEUVERABILITY = 3
ACCELERATION = 0.25
def __init__(self):
self.order = 屏幕信息_L
self.design = pygame.transform.scale(
pygame.image.load('images/mapdesign.png'), (300, 300))
self.rect = self.design.get_rect()
self.target = Vector2(0, 0)
def draw(self, surface):
blit_position = self.position - Vector2(self.radius)
surface.blit(self.sprite, blit_position)
def move_without_collision(self, deltatime):
"""
Makes movement steps move without intersecting nearby objects
"""
map_data = GameMap.map_data
TILE_SIZE = map_data.tilewidth
owner_rect = self.owner.rect
delta_movement = self.owner.velocity * deltatime
final_movement_veloc = Vector2(delta_movement.x, delta_movement.y)
tolerance = 0.
direction = 0
start_tile = -999
target_tile = -999
# X
if self.owner.velocity.x > tolerance: # Right
start_tile = int(owner_rect.right / TILE_SIZE)
target_tile = int((owner_rect.right + delta_movement.x) / TILE_SIZE)
direction = 1 # Right
elif self.owner.velocity.x < -tolerance: # Left
start_tile = int(owner_rect.left / TILE_SIZE)
target_tile = int((owner_rect.left + delta_movement.x) / TILE_SIZE)
direction = -1 # Left
start_height = int(owner_rect.top / TILE_SIZE)
end_height = int(owner_rect.bottom / TILE_SIZE)
if direction != 0:
x_range = range(start_tile, target_tile + 1, direction) if direction == 1 else range(target_tile , start_tile- 1 , direction)
for j in range(start_height, end_height): # Height
for i in x_range: # Width
# Get tile, skip if not existent/has no property
try:
properties = GameMap.get_tile_properties(i, j)
if not properties: continue
except:
continue
if properties and properties.get(MapInfo.SOLID.value):
self.owner.velocity.x = 0
bbox = pygame.Rect((i * TILE_SIZE, j * TILE_SIZE), (TILE_SIZE, TILE_SIZE))
if direction == 1: # Right
smallest_dist = min(bbox.left - owner_rect.right, delta_movement.x)
final_movement_veloc.x = min(smallest_dist, final_movement_veloc.x)
else: # Left
smallest_dist = max(bbox.right - owner_rect.left, delta_movement.x)
final_movement_veloc.x = max(smallest_dist, final_movement_veloc.x)
break
else:
final_movement_veloc.x = delta_movement.x
self.owner.rect.move_ip(final_movement_veloc.x, 0)
# Y
owner_rect = self.owner.rect
direction = 0
start_tile = -999
target_tile = -999
if self.owner.velocity.y > tolerance: # Down
start_tile = int(owner_rect.bottom / TILE_SIZE)
target_tile = int((owner_rect.bottom + delta_movement.y) / TILE_SIZE)
direction = 1 # Down
elif self.owner.velocity.y < -tolerance: # Up
start_tile = int(owner_rect.top / TILE_SIZE)
target_tile = int((owner_rect.top + delta_movement.y) / TILE_SIZE)
direction = -1 # Up
start_width = int((owner_rect.left + 5) / TILE_SIZE)
end_width = int((owner_rect.right - 5) / TILE_SIZE)
if direction != 0:
y_range = range(start_tile - 1, target_tile + 1, direction) if direction == 1 else range(target_tile + 1, start_height - 1, direction)
for i in range(start_width, end_width + 1):
for j in y_range:
# Get tile, skip if not existent/has no property
try:
properties = GameMap.get_tile_properties(i, j)
if not properties: continue
except:
continue
if properties and properties.get(MapInfo.SOLID.value) or properties.get(MapInfo.SEMISOLID.value):
bbox = pygame.Rect((i * TILE_SIZE, j * TILE_SIZE), (TILE_SIZE, TILE_SIZE))
self.owner.velocity.y = 0
if direction == 1: # Down
smallest_dist = min(bbox.top - owner_rect.bottom, delta_movement.y)
final_movement_veloc.y = min(smallest_dist, final_movement_veloc.y)
else: # Up
smallest_dist = max(bbox.bottom - owner_rect.top, delta_movement.y)
final_movement_veloc.y = max(smallest_dist, final_movement_veloc.y)
break
else:
final_movement_veloc.y = delta_movement.y
self.owner.rect.move_ip(0, final_movement_veloc.y)
def __init__(self, position):
# Make a copy of the original UP vector
self.direction = Vector2(UP)
super().__init__(position, load_sprite("spaceship"), Vector2(0))
def _process(self):
def case(state):
return state == self.state
def subCase(state):
return state == self.subState
self.getPredictedPuckPosition(self.puck.position, 1)
if case(DEFEND):
# 3 Main decisions
self.debugString = "Deffending"
if self.isPuckBehingStriker(): # IF puck is behing striker
self.defendGoalLastLine()
elif self.canAttack(): # If striker can attack
self.subState = WAITING
if self.shouldStop():
self.state = STOP_PUCK
else:
self.state = ATTACK
elif self.shouldIntercept(
): # If it is good idea to try to intercept current trajectory of the puck
self.defendTrajectory()
else:
self.defendGoalDefault()
elif case(ATTACK):
if self.puck.velocity.x > self.maxSpeed * 0.8 or self.getPredictedPuckPosition(
self.puck.position).x > STRIKER_AREA_WIDTH:
self.subState = WAITING
self.state = DEFEND
self.getPredictedPuckPosition(self.puck.position)
if subCase(WAITING):
self.debugString = "Attacking"
self.lineToGoal = Line(self.predictedPosition,
Vector2(FIELD_WIDTH * 1.2, 0))
if self.puck.vector.x > -.2:
self.subState = ATTACK_STAND_BEHIND
elif abs(
self.goalLineIntersection
) < GOAL_SPAN / 2 and self.puck.state == ACURATE or self.puck.speedMagnitude > 200:
self.subState = ATTACK_SHOOT
self.debugString = "Attacking: Without init"
else:
if self.puck.speedMagnitude < 100:
self.lastPuckStop = self.gameTime
self.subState = ATTACK_INIT
elif subCase(ATTACK_STAND_BEHIND):
self.debugString = "Attacking: Standing behind puck"
if self.puck.state == ACURATE:
desiredY = self.getPredictedPuckPosition(
self.puck.position, 1).y
maxPos = FIELD_HEIGHT / 2 - PUCK_RADIUS
if abs(desiredY) > maxPos:
desiredY = sign(desiredY) * (maxPos -
(abs(desiredY) - maxPos))
else:
desiredY = self.puck.position.y
self.setDesiredPosition(
Vector2(self.puck.position.x - 4 * STRIKER_RADIUS,
desiredY))
if self.puck.speedMagnitude < 100 or self.puck.state == ACURATE and abs(self.puck.velocity.y) < self.maxSpeed*.8\
and sign(self.puck.velocity.y)*(self.striker.position.y - self.puck.position.y) > 20:
self.subState = ATTACK_SHOOT
elif subCase(
ATTACK_INIT
): # this should be done only if puck is almost still (will need a prepare time afted decision)
# wait a bit for decision
if self.gameTime > self.lastPuckStop + 0.15:
randomNum = random()
chosen = False
#----------------------------- Decision how should striker aim at goal -----------------------------
if not self.puck.state == ACURATE and self.puck.speedMagnitude < 30: # try wall bounce only if puck is almost still
topBounce = Line(
self.predictedPosition,
Vector2(FIELD_WIDTH * 0.9, FIELD_HEIGHT))
vectorFromGoal = topBounce.start - topBounce.end
vectorFromGoal.scale_to_length(STRIKER_RADIUS * 6)
if self.puck.position.y > YLIMIT - STRIKER_RADIUS * 2 or (
not self.striker.position.y <
-FIELD_HEIGHT * 0.3 and randomNum < 0.4):
self.debugString = "Attacking: Top bounce"
self.lineToGoal = topBounce
finalVector = vectorFromGoal
chosen = True
bottomBounce = Line(
self.predictedPosition,
Vector2(FIELD_WIDTH * 0.9, FIELD_HEIGHT))
vectorFromGoal = bottomBounce.start - bottomBounce.end
vectorFromGoal.scale_to_length(STRIKER_RADIUS * 6)
if self.puck.position.y < -YLIMIT + STRIKER_RADIUS * 2 or (
not self.striker.position.y >
FIELD_HEIGHT * 0.3 - STRIKER_RADIUS * 4
and randomNum > 0.6):
self.debugString = "Attacking: Bottom bounce"
self.lineToGoal = bottomBounce
finalVector = vectorFromGoal
chosen = True
if not chosen:
self.debugString = "Attacking: Straight shot"
center = Line(self.predictedPosition,
Vector2(FIELD_WIDTH * 1.15, 0))
vectorFromGoal = center.start - center.end
vectorFromGoal.scale_to_length(STRIKER_RADIUS * 6)
finalVector = vectorFromGoal
self.lineToGoal = center
# print("center")
self.setDesiredPosition(self.predictedPosition +
finalVector)
self.subState = ATTACK_INIT_STEP2
elif subCase(ATTACK_INIT_STEP2):
self.debugString = "Attacking: Preparing position"
if self.striker.position.distance_squared_to(
self.striker.desiredPosition
) < CLOSE_DISTANCE**2 or self.isPuckDangerous(
) or self.isInGoodPosition(
self.lineToGoal) or self.puck.speedMagnitude > 100:
self.subState = ATTACK_SHOOT
elif subCase(ATTACK_SHOOT):
stepToPuck = (self.puck.position - self.striker.position)
# Accurate shot
if len(self.puck.trajectory
) > 0 and self.puck.trajectory[0].getPointLineDist(
self.striker.position) < STRIKER_RADIUS / 3 or (
stepToPuck.magnitude() < 3 * STRIKER_RADIUS
and self.puck.vector.x < -.7
) or self.puck.speedMagnitude < 200:
# A bit of aiming
# self.debugString += " - Acurate shot (aimming)"
vectorToGoal = self.lineToGoal.end - self.lineToGoal.start
step = (self.puck.position - self.striker.position)
step.scale_to_length(PUCK_RADIUS * 3)
angleDiff = self.getAngleDifference(vectorToGoal, step)
step = step.rotate(angleDiff)
stepFromStriker = (self.puck.position -
self.striker.position) + step
if abs(
self.puck.position.y
) > YLIMIT - STRIKER_RADIUS: # and self.puck.position.x > XLIMIT + STRIKER_RADIUS:
self.setDesiredPosition(self.striker.position +
stepFromStriker)
else:
self.clampDesired(self.striker.position,
stepFromStriker)
# Inaccurate shot
else:
# self.debugString = " - Inaccurate shot (aimming)"
perpendicularPoint = self.puck.trajectory[
0].getPerpendicularPoint(self.striker.position)
self.getPredictedPuckPosition(perpendicularPoint, 0.8)
if perpendicularPoint.x < self.predictedPosition.x and self.puck.vector.x < 0:
step = (self.predictedPosition - self.striker.position)
elif self.puck.vector.x > 0:
self.getPredictedPuckPosition(self.puck.position, 0.8)
step = (self.predictedPosition - self.striker.position)
else:
self.getPredictedPuckPosition(self.puck.position)
step = (self.predictedPosition - self.striker.position)
step.scale_to_length(PUCK_RADIUS * 3)
self.clampDesired(self.predictedPosition, step)
if self.isPuckBehingStriker() or (
self.badAttackingAngle(self.striker.desiredPosition)
and abs(self.puck.position.y) < YLIMIT - STRIKER_RADIUS
and self.puck.position.x > XLIMIT + STRIKER_RADIUS
and self.puck.vector.x < -.6) or abs(
self.puck.velocity.y) > self.maxSpeed * .8:
if self.shouldIntercept():
self.defendTrajectory()
else:
self.defendGoalDefault()
self.subState = WAITING
self.state = DEFEND
else:
self.subState = WAITING
self.debugLines.append(self.lineToGoal)
elif case(STOP_PUCK):
self.slowDownPuck()
if self.striker.desiredPosition.x > self.puck.position.x:
self.defendGoalDefault()
self.subState = WAITING
self.state = DEFEND
if self.puck.speedMagnitude < 100 or self.isPuckDangerous() or (
self.puck.state == ACURATE and self.puck.vector.x > 0):
self.subState = WAITING
self.state = ATTACK
else:
pass
# 'Always' fucntions
pos = self.getPredictedPuckPosition(self.striker.desiredPosition, 1)
if self.isPuckBehingStriker(
pos) and self.puck.speedMagnitude > 100 and abs(
self.puck.vector.y) < .6 and self.state == DEFEND:
self.defendGoalLastLine()
self.subState = WAITING
self.state = DEFEND
def draw(self, surface):
angle = self.direction.angle_to(UP)
rotated_surface = rotozoom(self.sprite, angle, 1.0)
rotated_surface_size = Vector2(rotated_surface.get_size())
blit_position = self.position - rotated_surface_size * 0.5
surface.blit(rotated_surface, blit_position)
def randomize(self):
self.x = random.randint(0, cell_number - 1)
self.y = random.randint(0, cell_number - 1)
self.pos = Vector2(self.x, self.y)
def __init__(self, position, sprite, velocity):
self.position = Vector2(position)
self.sprite = sprite
self.radius = sprite.get_width() / 2
self.velocity = Vector2(velocity)
def __init__(self, state, position, tile):
super().__init__(state, position, tile)
self.weaponTarget = Vector2(0, 0)
self.lastBulletEpoch = -100
stext = sfont.render("Play Again y/n", 1, WHITE)
window.blit(stext, (100, 100))
pygame.display.update()
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_y:
pygame.mixer.music.stop()
pygame.mixer_music.load('Background.mid')
pygame.mixer.music.play(-1,0.0)
return
elif event.key == K_n or event.key == K_ESCAPE:
pygame.quit()
sys.exit()
MOVESPEED = 20
ball_movement = Vector2(10,10)
#Paddle images
enemy = pygame.Rect( 0, 175, 20, 60)
enemy2 = pygame.Rect( 175, 0, 60, 20)
enemy3 = pygame.Rect( 175, 480, 60, 20)
enemy_image = pygame.image.load('Green.png')
enemy_fixed_image = pygame.transform.scale(enemy_image, (20,60))
enemy_fixed_image2 = pygame.transform.scale(enemy_image, (60, 20))
player = pygame.Rect( 680, 175, 20, 60)
player2 = pygame.Rect( 700-175, 0, 60, 20)
player3 = pygame.Rect( 700-175, 480, 60, 20)
player_image = pygame.image.load('Green.png')
player_fixed_image = pygame.transform.scale(player_image, (20,60))
player_fixed_image2 = pygame.transform.scale(player_image,(60,20))
import config
from soccer_pitch import SoccerPitch
import random
WIDTH = 400
HEIGHT = 400
pitch = SoccerPitch(WIDTH, HEIGHT)
# player = Actor('playerredshirt0',pos=(300,200))
# player = FieldPlayer('playerredshirt0',home_region = 0, heading=Vector2(-1,0), pos=(300,50))
home = pitch.pos_from_region(11)
player = FieldPlayer('redshirt0',
pitch,
team=None,
home=home,
heading=Vector2(-1, 0))
player.team = None
player.pos = Vector2(random.randint(10, WIDTH), random.randint(10, HEIGHT))
def draw():
screen.fill('white')
pitch.draw(screen)
player.draw()
# player.velocity = Vector2(10,25)
# def update(dt):
# player.update(dt)
pgzrun.go()
def update(self):
super().update()
#Figured this would make more sense here
t = self.game_object.get_behaviour("Transform")
self.rect.center = Vector2(t.position)
