270 lines
9.5 KiB
Python
270 lines
9.5 KiB
Python
import os
|
|
from pygame.sprite import Sprite
|
|
import pygame
|
|
import math
|
|
import random
|
|
import time
|
|
|
|
from utils import load_entity_image
|
|
from projectile import Projectile
|
|
|
|
class Tank(Sprite):
|
|
MOVE_UP = "up"
|
|
MOVE_DOWN = "down"
|
|
MOVE_LEFT = "left"
|
|
MOVE_RIGHT = "right"
|
|
|
|
color = "blue"
|
|
|
|
def __init__(self, settings, x: int, y: int):
|
|
super().__init__()
|
|
self.settings = settings
|
|
|
|
image_folder = os.path.join(self.settings.img_folder, "tanks", self.color)
|
|
self.IMAGES = {
|
|
self.MOVE_UP: (load_entity_image(self.settings, os.path.join(image_folder, "tile004.png")), load_entity_image(self.settings, os.path.join(image_folder, "tile006.png"))),
|
|
self.MOVE_DOWN: (load_entity_image(self.settings, os.path.join(image_folder, "tile010.png")), load_entity_image(self.settings, os.path.join(image_folder, "tile008.png"))),
|
|
self.MOVE_LEFT: (load_entity_image(self.settings, os.path.join(image_folder, "tile012.png")), load_entity_image(self.settings, os.path.join(image_folder, "tile014.png"))),
|
|
self.MOVE_RIGHT: (load_entity_image(self.settings, os.path.join(image_folder, "tile000.png")), load_entity_image(self.settings, os.path.join(image_folder, "tile002.png")))
|
|
}
|
|
|
|
self.image = self.IMAGES[self.MOVE_UP][0]
|
|
self.rect = self.image.get_rect()
|
|
|
|
self.now_move = self.MOVE_UP
|
|
self.now_frame = 0
|
|
self.move_stage = 0
|
|
self.animation_tick_change = 3
|
|
self.frame_quantity = 2
|
|
self.animation_max_tick = self.animation_tick_change * self.frame_quantity
|
|
|
|
self.x = x
|
|
self.y = y
|
|
self.rect.x = self.x
|
|
self.rect.y = self.y
|
|
|
|
self.last_shot = time.time()
|
|
|
|
|
|
|
|
def update_move_state(self, triggered: str):
|
|
if triggered == self.now_move:
|
|
self.move_stage += 1
|
|
|
|
self.now_frame = math.floor(self.move_stage / self.animation_tick_change)
|
|
|
|
if self.now_frame > self.frame_quantity - 1:
|
|
self.move_stage = 0
|
|
self.now_frame = 0
|
|
else:
|
|
self.now_move = triggered
|
|
self.move_stage = 0
|
|
|
|
del self.rect
|
|
self.image = self.IMAGES[self.now_move][self.now_frame]
|
|
self.rect = self.image.get_rect()
|
|
self.rect.y = self.y
|
|
self.rect.x = self.x
|
|
|
|
|
|
def update(self):
|
|
keystate = pygame.key.get_pressed()
|
|
|
|
if keystate[pygame.K_w]:
|
|
self.move_up()
|
|
elif keystate[pygame.K_a]:
|
|
self.move_left()
|
|
elif keystate[pygame.K_s]:
|
|
self.move_down()
|
|
elif keystate[pygame.K_d]:
|
|
self.move_right()
|
|
|
|
def get_rect(self):
|
|
return pygame.Rect(self.x, self.y, self.settings.entity_size, self.settings.entity_size)
|
|
|
|
def create_new_projectile(self):
|
|
if self.now_move == Tank.MOVE_UP:
|
|
sx = self.x + self.settings.block_size / 2 - self.settings.projectile_size / 2 + 1
|
|
sy = self.y - self.settings.projectile_size / 2 - 1
|
|
elif self.now_move == Tank.MOVE_DOWN:
|
|
sx = self.x + self.settings.block_size / 2 - self.settings.projectile_size / 2 + 1
|
|
sy = self.y + self.settings.block_size + 1
|
|
elif self.now_move == Tank.MOVE_LEFT:
|
|
sy = self.y + self.settings.block_size / 2 - self.settings.projectile_size / 2 + 1
|
|
sx = self.x - self.settings.projectile_size / 2 - 1
|
|
elif self.now_move == Tank.MOVE_RIGHT:
|
|
sy = self.y + self.settings.block_size / 2 - self.settings.projectile_size / 2 + 1
|
|
sx = self.x + self.settings.block_size + 1
|
|
|
|
self.last_shot = time.time()
|
|
self.game.projectiles.add(Projectile(self.game, sx, sy, self.now_move))
|
|
|
|
|
|
class Player(Tank):
|
|
color = "blue"
|
|
|
|
def __init__(self, game, x, y):
|
|
self.game = game
|
|
super().__init__(self.game.settings, x, y)
|
|
|
|
def move_up(self):
|
|
self.update_move_state(self.MOVE_UP)
|
|
|
|
def move_down(self):
|
|
self.update_move_state(self.MOVE_DOWN)
|
|
|
|
def move_left(self):
|
|
self.update_move_state(self.MOVE_LEFT)
|
|
|
|
def move_right(self):
|
|
self.update_move_state(self.MOVE_RIGHT)
|
|
|
|
def update(self):
|
|
keystate = pygame.key.get_pressed()
|
|
|
|
if keystate[pygame.K_SPACE]:
|
|
if time.time() - self.last_shot > self.settings.recharge_time:
|
|
self.create_new_projectile()
|
|
|
|
self.game.screen.blit(self.image, (self.x, self.y))
|
|
|
|
|
|
|
|
|
|
class Enemy(Tank):
|
|
color = "red"
|
|
last_movement = Tank.MOVE_UP
|
|
prev_variants = set()
|
|
prev_prev_variants = set()
|
|
could_move = True
|
|
|
|
def __init__(self, game, x, y):
|
|
super().__init__(game.settings, x, y)
|
|
self.game = game
|
|
self.settings = game.settings
|
|
self.map = game.map
|
|
|
|
def update(self):
|
|
tsh = self.map.settings.block_size // 2 #tile size half
|
|
block = self.map.find_block_on_coords(self.x + tsh, self.y + tsh)
|
|
i, j = block.i, block.j
|
|
|
|
if abs(self.x - block.x) < 0.6 and abs(self.y - block.y) < 0.6:
|
|
#print(block)
|
|
|
|
variants = self.get_possible_movements(i, j)
|
|
|
|
if variants == self.prev_variants or variants == self.prev_variants:
|
|
next_movement = self.last_movement
|
|
else:
|
|
next_movement = random.choice(list(variants))
|
|
self.last_movement = next_movement
|
|
self.prev_prev_variants = self.prev_variants
|
|
self.prev_variants = variants
|
|
|
|
#print(variants)
|
|
else:
|
|
if self.could_move:
|
|
next_movement = self.last_movement
|
|
else:
|
|
variants = self.get_possible_movements(i, j)
|
|
next_movement = random.choice(list(variants))
|
|
self.last_movement = next_movement
|
|
self.prev_variants = variants
|
|
|
|
#Shot
|
|
if random.randint(1, self.settings.enemy_shot_rev) == 1:
|
|
self.create_new_projectile()
|
|
|
|
|
|
if next_movement == Tank.MOVE_UP:
|
|
self.move_up()
|
|
elif next_movement == Tank.MOVE_LEFT:
|
|
self.move_left()
|
|
elif next_movement == Tank.MOVE_DOWN:
|
|
self.move_down()
|
|
elif next_movement == Tank.MOVE_RIGHT:
|
|
self.move_right()
|
|
|
|
def get_possible_movements(self, i, j):
|
|
variants = set()
|
|
if self.map.blockmap[i - 1][j].passable:
|
|
variants.add(Tank.MOVE_UP)
|
|
|
|
if self.map.blockmap[i + 1][j].passable:
|
|
variants.add(Tank.MOVE_DOWN)
|
|
|
|
if self.map.blockmap[i][j + 1].passable:
|
|
variants.add(Tank.MOVE_RIGHT)
|
|
|
|
if self.map.blockmap[i][j - 1].passable:
|
|
variants.add(Tank.MOVE_LEFT)
|
|
|
|
return variants
|
|
|
|
def change_coords_by_delta(self, dx=None, dy=None):
|
|
#print(dx, dy)
|
|
self.x = self.x - dx
|
|
self.y = self.y - dy
|
|
self.rect.x = self.x
|
|
self.rect.y = self.y
|
|
|
|
def move_up(self):
|
|
cx, cy, tsh = self.get_block_collision_vars()
|
|
cp1 = (cx - tsh + 1, cy - tsh)
|
|
cp2 = (cx + tsh - 1, cy - tsh)
|
|
|
|
if self.check_on_moveability(cp1[0], cp1[1], 0, self.settings.move_speed) and self.check_on_moveability(cp2[0], cp2[1], 0, self.settings.move_speed):
|
|
self.y -= self.settings.move_speed
|
|
self.rect.y = self.y
|
|
self.update_move_state(self.MOVE_UP)
|
|
self.could_move = True
|
|
else:
|
|
self.could_move = False
|
|
|
|
def move_down(self):
|
|
cx, cy, tsh = self.get_block_collision_vars()
|
|
cp1 = (cx - tsh + 1, cy + tsh)
|
|
cp2 = (cx + tsh - 1, cy + tsh)
|
|
|
|
if self.check_on_moveability(cp1[0], cp1[1], 0, -self.settings.move_speed) and self.check_on_moveability(cp2[0], cp2[1], 0, -self.settings.move_speed):
|
|
self.y += self.settings.move_speed
|
|
self.rect.y = self.y
|
|
self.update_move_state(self.MOVE_DOWN)
|
|
self.could_move = True
|
|
else:
|
|
self.could_move = False
|
|
|
|
def move_left(self):
|
|
cx, cy, tsh = self.get_block_collision_vars()
|
|
cp1 = (cx - tsh, cy - tsh + 1)
|
|
cp2 = (cx - tsh, cy + tsh - 1)
|
|
|
|
if self.check_on_moveability(cp1[0], cp1[1], self.settings.move_speed, 0) and self.check_on_moveability(cp2[0], cp2[1], -self.settings.move_speed, 0):
|
|
self.x -= self.settings.move_speed
|
|
self.rect.x = self.x
|
|
self.update_move_state(self.MOVE_LEFT)
|
|
self.could_move = True
|
|
else:
|
|
self.could_move = False
|
|
|
|
def move_right(self):
|
|
cx, cy, tsh = self.get_block_collision_vars()
|
|
cp1 = (cx + tsh, cy - tsh + 1)
|
|
cp2 = (cx + tsh, cy + tsh - 1)
|
|
|
|
if self.check_on_moveability(cp1[0], cp1[1], -self.settings.move_speed, 0) and self.check_on_moveability(cp2[0], cp2[1], -self.settings.move_speed, 0):
|
|
self.x += self.settings.move_speed
|
|
self.rect.x = self.x
|
|
self.update_move_state(self.MOVE_RIGHT)
|
|
self.could_move = True
|
|
else:
|
|
self.could_move = False
|
|
|
|
def get_block_collision_vars(self):
|
|
tsh = self.map.settings.block_size // 2
|
|
return self.x + tsh, self.y + tsh, tsh
|
|
|
|
def check_on_moveability(self, x, y, dx, dy):
|
|
return self.map.check_on_moveability(x, y, dx, dy)
|