forked from s464965/WMICraft
Compare commits
57 Commits
decision_t
...
master
Author | SHA1 | Date | |
---|---|---|---|
f4aa9741e3 | |||
![]() |
3591fedfa2 | ||
050a0359b0 | |||
c6cc763fe1 | |||
08ea0e945e | |||
cb9b8e6b2d | |||
8666a7dbf9 | |||
952e8663b4 | |||
5f7fea24fb | |||
297bd19336 | |||
bab75274dc | |||
681bf08424 | |||
c8f0dc76b6 | |||
e31364b21c | |||
![]() |
1482730bee | ||
![]() |
29aea5bec4 | ||
9afd1f366a | |||
![]() |
6ddfddb2fd | ||
![]() |
3f68f4c8a6 | ||
59a8c49b2d | |||
![]() |
fd4b34eed7 | ||
08329f187b | |||
![]() |
fd081d5c56 | ||
ee7a324e5d | |||
![]() |
10e61e724c | ||
![]() |
f255178162 | ||
d80e83cecf | |||
![]() |
ea105ad140 | ||
32847593e6 | |||
![]() |
f1f2302acd | ||
![]() |
e89f564dd6 | ||
162e2df890 | |||
![]() |
e9ef300dde | ||
![]() |
c7c1feb82c | ||
![]() |
7a9d685701 | ||
![]() |
c06624d79c | ||
8d73a85707 | |||
b6ba817d55 | |||
5c1a1605b8 | |||
97628965f1 | |||
e8c32ade2a | |||
c6697bdc79 | |||
088e90ec5b | |||
4d88b300ae | |||
94b4cbef58 | |||
4e3e68d4c3 | |||
![]() |
431113a04c | ||
![]() |
736dbc9616 | ||
7ce2f0cc38 | |||
dc411fae42 | |||
![]() |
3fce0a5b57 | ||
![]() |
89c307535b | ||
30e2d39d28 | |||
504cfd1af0 | |||
![]() |
9aa9552499 | ||
4ab8065879 | |||
9f3c5fb2d5 |
3
.gitignore
vendored
3
.gitignore
vendored
@ -149,4 +149,5 @@ cython_debug/
|
||||
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
|
||||
# and can be added to the global gitignore or merged into this file. For a more nuclear
|
||||
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
|
||||
.idea/
|
||||
.idea/
|
||||
/algorithms/neural_network/data/
|
||||
|
@ -4,10 +4,11 @@ import heapq
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Tuple, Optional, List
|
||||
|
||||
from algorithms.genetic.const import MAP_ALIASES
|
||||
from common.constants import ROWS, COLUMNS, LEFT, RIGHT, UP, DOWN
|
||||
from common.helpers import directions
|
||||
|
||||
EMPTY_FIELDS = ['s', 'g', ' ']
|
||||
EMPTY_FIELDS = [MAP_ALIASES.get("SAND"), MAP_ALIASES.get("GRASS"), ' ']
|
||||
|
||||
TURN_LEFT = 'TURN_LEFT'
|
||||
TURN_RIGHT = 'TURN_RIGHT'
|
||||
|
@ -51,7 +51,7 @@ def graphsearch(initial_state: State, map, goal_list, fringe: List[Node] = None,
|
||||
explored_states = set()
|
||||
fringe_states = set()
|
||||
|
||||
# root Node
|
||||
# train Node
|
||||
fringe.append(Node(initial_state))
|
||||
fringe_states.add((initial_state.row, initial_state.column, initial_state.direction))
|
||||
|
||||
@ -71,7 +71,7 @@ def graphsearch(initial_state: State, map, goal_list, fringe: List[Node] = None,
|
||||
parent = element.parent
|
||||
|
||||
while parent is not None:
|
||||
# root's action will be None, don't add it
|
||||
# train's action will be None, don't add it
|
||||
if parent.action is not None:
|
||||
actions_sequence.append(parent.action)
|
||||
parent = parent.parent
|
||||
|
142
algorithms/genetic/common.py
Normal file
142
algorithms/genetic/common.py
Normal file
@ -0,0 +1,142 @@
|
||||
from dataclasses import dataclass
|
||||
|
||||
import numpy as np
|
||||
|
||||
from const import *
|
||||
from typing import List, Dict, Tuple
|
||||
|
||||
import numpy.typing as npt
|
||||
|
||||
|
||||
@dataclass
|
||||
class Position:
|
||||
row: int
|
||||
col: int
|
||||
|
||||
|
||||
@dataclass
|
||||
class Area:
|
||||
position: Position
|
||||
width: int
|
||||
height: int
|
||||
|
||||
|
||||
AREAS_TO_CROSS = [
|
||||
# up above left knights spawn
|
||||
Area(position=Position(row=0, col=0),
|
||||
width=KNIGHTS_SPAWN_WIDTH,
|
||||
height=LEFT_KNIGHTS_SPAWN_FIRST_ROW),
|
||||
|
||||
# down below left knights spawn
|
||||
Area(position=Position(row=LEFT_KNIGHTS_SPAWN_FIRST_ROW + KNIGHTS_SPAWN_HEIGHT, col=0),
|
||||
width=KNIGHTS_SPAWN_WIDTH,
|
||||
height=ROWS - LEFT_KNIGHTS_SPAWN_FIRST_ROW - KNIGHTS_SPAWN_HEIGHT),
|
||||
|
||||
# between left knights spawn and castle
|
||||
Area(position=Position(row=0, col=KNIGHTS_SPAWN_WIDTH),
|
||||
width=CASTLE_SPAWN_FIRST_COL - KNIGHTS_SPAWN_WIDTH,
|
||||
height=ROWS),
|
||||
|
||||
# up above castle
|
||||
Area(position=Position(row=0, col=CASTLE_SPAWN_FIRST_COL),
|
||||
width=2,
|
||||
height=CASTLE_SPAWN_FIRST_ROW),
|
||||
|
||||
# down below castle
|
||||
Area(position=Position(row=CASTLE_SPAWN_FIRST_ROW + 2, col=CASTLE_SPAWN_FIRST_COL),
|
||||
width=2,
|
||||
height=ROWS - CASTLE_SPAWN_FIRST_ROW - 2),
|
||||
|
||||
# between castle and right knights spawn
|
||||
Area(position=Position(row=0, col=CASTLE_SPAWN_FIRST_COL + 2),
|
||||
width=RIGHT_KNIGHTS_SPAWN_FIRST_COL - CASTLE_SPAWN_FIRST_COL - 2,
|
||||
height=ROWS),
|
||||
|
||||
# up above right knights spawn
|
||||
Area(position=Position(row=0, col=RIGHT_KNIGHTS_SPAWN_FIRST_COL),
|
||||
width=KNIGHTS_SPAWN_WIDTH,
|
||||
height=RIGHT_KNIGHTS_SPAWN_FIRST_ROW),
|
||||
|
||||
# down below right knights spawn
|
||||
Area(position=Position(row=RIGHT_KNIGHTS_SPAWN_FIRST_ROW + KNIGHTS_SPAWN_HEIGHT, col=RIGHT_KNIGHTS_SPAWN_FIRST_COL),
|
||||
width=KNIGHTS_SPAWN_WIDTH,
|
||||
height=ROWS - RIGHT_KNIGHTS_SPAWN_FIRST_ROW - KNIGHTS_SPAWN_HEIGHT),
|
||||
]
|
||||
|
||||
|
||||
def dfs(grid: npt.NDArray, visited: Dict[Tuple[int, int], bool], position: Position, rows: int, cols: int) -> None:
|
||||
visited[(position.row, position.col)] = True
|
||||
|
||||
row_vector = [0, 0, 1, -1]
|
||||
col_vector = [-1, 1, 0, 0]
|
||||
|
||||
neighbours = []
|
||||
for i in range(4):
|
||||
rr = position.row + row_vector[i]
|
||||
cc = position.col + col_vector[i]
|
||||
if rr < 0 or rr >= ROWS:
|
||||
continue
|
||||
elif cc < 0 or cc >= COLUMNS:
|
||||
continue
|
||||
else:
|
||||
p = Position(rr, cc)
|
||||
if (p.row, p.col) in visited:
|
||||
neighbours.append(p)
|
||||
|
||||
for neighbour in neighbours:
|
||||
if not visited[(neighbour.row, neighbour.col)]:
|
||||
dfs(grid, visited, neighbour, rows, cols)
|
||||
|
||||
|
||||
def get_islands(grid: npt.NDArray, positions: List[Position], rows: int = ROWS, cols: int = COLUMNS) -> List[Position]:
|
||||
"""it returns list of all islands roots"""
|
||||
visited = {}
|
||||
|
||||
for position in positions:
|
||||
visited[(position.row, position.col)] = False
|
||||
|
||||
islands = 0
|
||||
roots = []
|
||||
for position in positions:
|
||||
if not visited[(position.row, position.col)]:
|
||||
dfs(grid, visited, position, rows, cols)
|
||||
roots.append(position)
|
||||
islands += 1
|
||||
|
||||
return roots
|
||||
|
||||
|
||||
def find_neighbours(grid: npt.NDArray, col: int, row: int) -> List[Position]:
|
||||
dr = [-1, 1, 0, 0]
|
||||
dc = [0, 0, -1, 1]
|
||||
|
||||
neighbours = []
|
||||
|
||||
for i in range(4):
|
||||
rr = row + dr[i]
|
||||
cc = col + dc[i]
|
||||
|
||||
if 0 <= rr < ROWS and 0 <= cc < COLUMNS and grid[rr][cc] == MAP_ALIASES.get('GRASS'):
|
||||
neighbours.append(Position(row=rr, col=cc))
|
||||
|
||||
return neighbours
|
||||
|
||||
|
||||
def get_tiles_positions(grid: npt.NDArray):
|
||||
sands = []
|
||||
trees = []
|
||||
waters = []
|
||||
monsters = []
|
||||
|
||||
for row_num in range(len(grid)):
|
||||
for col_num in range(len(grid[row_num])):
|
||||
if grid[row_num][col_num] == MAP_ALIASES.get('WATER'):
|
||||
waters.append(Position(row=row_num, col=col_num))
|
||||
elif grid[row_num][col_num] == MAP_ALIASES.get('TREE'):
|
||||
trees.append(Position(row=row_num, col=col_num))
|
||||
elif grid[row_num][col_num] == MAP_ALIASES.get('SAND'):
|
||||
sands.append(Position(row=row_num, col=col_num))
|
||||
elif grid[row_num][col_num] == MAP_ALIASES.get('MONSTER'):
|
||||
monsters.append(Position(row=row_num, col=col_num))
|
||||
|
||||
return sands, trees, waters, monsters
|
29
algorithms/genetic/const.py
Normal file
29
algorithms/genetic/const.py
Normal file
@ -0,0 +1,29 @@
|
||||
# map config
|
||||
KNIGHTS_PER_TEAM_COUNT = 4
|
||||
SAND_COUNT = 21
|
||||
WATER_COUNT = 21
|
||||
TREE_COUNT = 37
|
||||
MONSTERS_COUNT = 2
|
||||
CASTLES_COUNT = 1
|
||||
ROWS = 19
|
||||
COLUMNS = 24
|
||||
KNIGHTS_SPAWN_WIDTH = 4
|
||||
KNIGHTS_SPAWN_HEIGHT = 7
|
||||
LEFT_KNIGHTS_SPAWN_FIRST_ROW = 6
|
||||
LEFT_KNIGHTS_SPAWN_FIRST_COL = 0
|
||||
RIGHT_KNIGHTS_SPAWN_FIRST_ROW = 6
|
||||
RIGHT_KNIGHTS_SPAWN_FIRST_COL = 20
|
||||
CASTLE_SPAWN_FIRST_ROW = 7
|
||||
CASTLE_SPAWN_FIRST_COL = 11
|
||||
|
||||
# map aliases
|
||||
MAP_ALIASES = {
|
||||
"GRASS": 0,
|
||||
"SAND": 1,
|
||||
"WATER": 2,
|
||||
"TREE": 3,
|
||||
"MONSTER": 4,
|
||||
"CASTLE": 5,
|
||||
"KNIGHT_RED": 6,
|
||||
"KNIGHT_BLUE": 7,
|
||||
}
|
166
algorithms/genetic/genome.py
Normal file
166
algorithms/genetic/genome.py
Normal file
@ -0,0 +1,166 @@
|
||||
import math
|
||||
import random
|
||||
from copy import deepcopy
|
||||
from random import randrange
|
||||
from typing import List
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
from common import Position, get_islands, AREAS_TO_CROSS, find_neighbours, get_tiles_positions
|
||||
from const import *
|
||||
|
||||
|
||||
class Genome:
|
||||
grid: npt.NDArray
|
||||
knights_red: List[Position]
|
||||
knights_blue: List[Position]
|
||||
waters: List[Position]
|
||||
trees: List[Position]
|
||||
sands: List[Position]
|
||||
monsters: List[Position]
|
||||
fitness: int
|
||||
sand_islands: List[Position]
|
||||
tree_islands: List[Position]
|
||||
water_islands: List[Position]
|
||||
|
||||
def __init__(self):
|
||||
self.grid = np.zeros((ROWS, COLUMNS), dtype=int)
|
||||
self.fitness = 0
|
||||
|
||||
self.knights_red = spawn_objects_in_given_area(
|
||||
grid=self.grid,
|
||||
object_alias=MAP_ALIASES.get("KNIGHT_RED"),
|
||||
objects_count=KNIGHTS_PER_TEAM_COUNT,
|
||||
spawn_position_start=Position(row=LEFT_KNIGHTS_SPAWN_FIRST_ROW, col=LEFT_KNIGHTS_SPAWN_FIRST_COL),
|
||||
width=KNIGHTS_SPAWN_WIDTH,
|
||||
height=KNIGHTS_SPAWN_HEIGHT
|
||||
)
|
||||
|
||||
self.knights_blue = spawn_objects_in_given_area(
|
||||
grid=self.grid,
|
||||
object_alias=MAP_ALIASES.get("KNIGHT_BLUE"),
|
||||
objects_count=KNIGHTS_PER_TEAM_COUNT,
|
||||
spawn_position_start=Position(row=RIGHT_KNIGHTS_SPAWN_FIRST_ROW, col=RIGHT_KNIGHTS_SPAWN_FIRST_COL),
|
||||
width=KNIGHTS_SPAWN_WIDTH,
|
||||
height=KNIGHTS_SPAWN_HEIGHT
|
||||
)
|
||||
|
||||
spawn_objects_in_given_area(
|
||||
grid=self.grid,
|
||||
object_alias=MAP_ALIASES.get("CASTLE"),
|
||||
objects_count=4,
|
||||
spawn_position_start=Position(row=CASTLE_SPAWN_FIRST_ROW, col=CASTLE_SPAWN_FIRST_COL),
|
||||
width=2,
|
||||
height=2
|
||||
)
|
||||
|
||||
self.waters = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("WATER"),
|
||||
objects_count=WATER_COUNT)
|
||||
self.trees = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("TREE"),
|
||||
objects_count=TREE_COUNT)
|
||||
self.sands = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("SAND"),
|
||||
objects_count=SAND_COUNT)
|
||||
self.monsters = spawn_objects_in_given_area(grid=self.grid, object_alias=MAP_ALIASES.get("MONSTER"),
|
||||
objects_count=MONSTERS_COUNT)
|
||||
|
||||
self.sand_islands = get_islands(self.grid, self.sands)
|
||||
self.tree_islands = get_islands(self.grid, self.trees)
|
||||
self.water_islands = get_islands(self.grid, self.waters)
|
||||
|
||||
def update_map(self):
|
||||
self.sands, self.trees, self.waters, self.monsters = get_tiles_positions(self.grid)
|
||||
|
||||
self.sand_islands = get_islands(self.grid, self.sands)
|
||||
self.tree_islands = get_islands(self.grid, self.trees)
|
||||
self.water_islands = get_islands(self.grid, self.waters)
|
||||
|
||||
def calc_fitness(self):
|
||||
score = SAND_COUNT + TREE_COUNT + WATER_COUNT
|
||||
score = score - len(self.sand_islands) - len(self.tree_islands) - len(self.water_islands)
|
||||
|
||||
sands, trees, waters, monsters = get_tiles_positions(self.grid)
|
||||
|
||||
if len(monsters) != MONSTERS_COUNT:
|
||||
self.fitness = 0
|
||||
return
|
||||
|
||||
if len(sands) < SAND_COUNT or len(trees) < TREE_COUNT or len(waters) < WATER_COUNT:
|
||||
self.fitness = 5
|
||||
return
|
||||
|
||||
self.fitness = score
|
||||
|
||||
def crossover(self, partner):
|
||||
# replace a randomly selected part of the grid with partner's part
|
||||
child = Genome()
|
||||
child.grid = deepcopy(self.grid)
|
||||
area_to_cross = random.choice(AREAS_TO_CROSS)
|
||||
|
||||
for row in range(area_to_cross.position.row, area_to_cross.position.row + area_to_cross.height):
|
||||
for col in range(area_to_cross.position.col, area_to_cross.position.col + area_to_cross.width):
|
||||
child.grid[row][col] = partner.grid[row][col]
|
||||
|
||||
child.update_map()
|
||||
|
||||
return child
|
||||
|
||||
def mutate(self, mutation_rate: float):
|
||||
# remove 1 item from a random island and add a neighbor to another island
|
||||
if random.random() < mutation_rate:
|
||||
|
||||
# select islands of the same, random type
|
||||
islands_of_same_type = random.choice([self.sand_islands, self.tree_islands, self.water_islands])
|
||||
random_index = random.randint(0, len(islands_of_same_type) - 1)
|
||||
island = islands_of_same_type[random_index]
|
||||
next_island = islands_of_same_type[(random_index + 1) % len(islands_of_same_type)]
|
||||
|
||||
free_tiles_nearby = find_neighbours(self.grid, next_island.col, next_island.row)
|
||||
|
||||
tile_type = self.grid[island.row][island.col]
|
||||
self.grid[island.row][island.col] = MAP_ALIASES.get('GRASS')
|
||||
|
||||
# todo: if there are no free tiles around then randomize another next_island
|
||||
if len(free_tiles_nearby) > 0:
|
||||
random_free_tile = random.choice(free_tiles_nearby)
|
||||
island.row = random_free_tile.row
|
||||
island.col = random_free_tile.col
|
||||
self.grid[island.row][island.col] = tile_type
|
||||
|
||||
self.update_map()
|
||||
|
||||
|
||||
def is_empty(grid: npt.NDArray, position: Position) -> bool:
|
||||
return grid[position.row, position.col] in [MAP_ALIASES.get("GRASS"), MAP_ALIASES.get("SAND")]
|
||||
|
||||
|
||||
def is_invalid_area(spawn_position_start, height, width) -> bool:
|
||||
return spawn_position_start.row + height - 1 < 0 or \
|
||||
spawn_position_start.row + height - 1 >= ROWS or \
|
||||
spawn_position_start.col + width - 1 < 0 or \
|
||||
spawn_position_start.col + width - 1 >= COLUMNS
|
||||
|
||||
|
||||
def spawn_objects_in_given_area(grid: npt.NDArray,
|
||||
object_alias: str,
|
||||
objects_count: int = 1,
|
||||
spawn_position_start: Position = Position(row=0, col=0),
|
||||
width: int = COLUMNS,
|
||||
height: int = ROWS) -> List[Position]:
|
||||
if is_invalid_area(spawn_position_start, height, width):
|
||||
raise ValueError("Invalid spawn area")
|
||||
|
||||
objects_remaining = int(objects_count)
|
||||
positions = []
|
||||
|
||||
while objects_remaining > 0:
|
||||
row = randrange(spawn_position_start.row, spawn_position_start.row + height)
|
||||
col = randrange(spawn_position_start.col, spawn_position_start.col + width)
|
||||
position = Position(row=row, col=col)
|
||||
|
||||
if is_empty(grid=grid, position=position):
|
||||
grid[position.row, position.col] = object_alias
|
||||
positions.append(position)
|
||||
objects_remaining -= 1
|
||||
|
||||
return positions
|
26
algorithms/genetic/map_generator.py
Normal file
26
algorithms/genetic/map_generator.py
Normal file
@ -0,0 +1,26 @@
|
||||
from algorithms.genetic.genome import Genome
|
||||
from algorithms.genetic.map_importer_exporter import export_map
|
||||
from population import Population
|
||||
|
||||
|
||||
def main() -> None:
|
||||
population_size = 500
|
||||
mutation_rate = 0.3
|
||||
|
||||
population = Population(mutation_rate, population_size, 55)
|
||||
|
||||
while not population.evaluate():
|
||||
# create next generation
|
||||
population.generate()
|
||||
|
||||
# calc fitness
|
||||
population.calc_fitness()
|
||||
|
||||
print(population.best_genome.grid)
|
||||
print("Fitness of the best: ", population.best_genome.fitness)
|
||||
|
||||
export_map(population.best_genome.grid)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
42
algorithms/genetic/map_importer_exporter.py
Normal file
42
algorithms/genetic/map_importer_exporter.py
Normal file
@ -0,0 +1,42 @@
|
||||
import json
|
||||
import random
|
||||
import string
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
import numpy
|
||||
import numpy.typing as npt
|
||||
from os import listdir
|
||||
from os.path import isfile, join
|
||||
|
||||
|
||||
# Save map to file
|
||||
def export_map(grid: npt.NDArray):
|
||||
json_data = {"map": grid.tolist()}
|
||||
|
||||
now = datetime.now()
|
||||
file_name = "map_" + now.strftime("%Y_%m_%d_%H_%M_%S") + ".json"
|
||||
path = Path("../../resources/maps/")
|
||||
file_to_open = path / file_name
|
||||
|
||||
with open(file_to_open, "w+") as write_file:
|
||||
json.dump(json_data, write_file)
|
||||
print("Saved map to file " + file_name)
|
||||
|
||||
|
||||
def import_random_map() -> object:
|
||||
path = "resources/maps"
|
||||
files = [f for f in listdir(path) if isfile(join(path, f))]
|
||||
random_map_name = random.choice(files)
|
||||
return import_map(random_map_name)
|
||||
|
||||
|
||||
# Read map from file
|
||||
def import_map(file_name: string) -> object:
|
||||
file_to_open = "resources/maps/" + file_name
|
||||
with open(file_to_open, "r") as read_file:
|
||||
print("Reading map from file " + file_name)
|
||||
decoded_json = json.load(read_file)
|
||||
|
||||
decoded_grid = numpy.asarray(decoded_json["map"])
|
||||
print(decoded_grid)
|
||||
return decoded_grid.tolist()
|
81
algorithms/genetic/population.py
Normal file
81
algorithms/genetic/population.py
Normal file
@ -0,0 +1,81 @@
|
||||
import random
|
||||
from typing import List
|
||||
|
||||
import numpy as np
|
||||
import numpy.typing as npt
|
||||
|
||||
from genome import Genome
|
||||
|
||||
|
||||
class Population:
|
||||
population: List[Genome] = [] # array to hold the current population
|
||||
mating_pool: List[Genome] = [] # array which we will use for our "mating pool"
|
||||
generations: int = 0 # number of generations
|
||||
finished: bool = False # are we finished evolving?
|
||||
mutation_rate: float
|
||||
perfect_score: int
|
||||
best_genome: Genome
|
||||
|
||||
def __init__(self, mutation_rate, population_size, perfect_score=20):
|
||||
self.mutation_rate = mutation_rate
|
||||
self.perfect_score = perfect_score
|
||||
|
||||
for i in range(0, population_size):
|
||||
new_genome = Genome()
|
||||
new_genome.calc_fitness()
|
||||
self.population.append(new_genome)
|
||||
|
||||
# create a new generation
|
||||
def generate(self):
|
||||
max_fitness = 0
|
||||
for genome in self.population:
|
||||
if genome.fitness > max_fitness:
|
||||
max_fitness = genome.fitness
|
||||
|
||||
print("Max fitness of generation " + str(self.generations) + " = " + str(max_fitness))
|
||||
|
||||
# refill the population with children from the mating pool
|
||||
new_population = []
|
||||
for genome in self.population:
|
||||
partner_a = self.accept_reject(max_fitness)
|
||||
partner_b = self.accept_reject(max_fitness)
|
||||
child = partner_a.crossover(partner_b)
|
||||
child.mutate(self.mutation_rate)
|
||||
new_population.append(child)
|
||||
|
||||
self.population = new_population
|
||||
self.generations += 1
|
||||
|
||||
# select random with correct probability from population
|
||||
def accept_reject(self, max_fitness: int):
|
||||
safe_flag = 0
|
||||
|
||||
while safe_flag < 10000:
|
||||
partner = random.choice(self.population)
|
||||
r = random.randint(0, max_fitness)
|
||||
|
||||
if r < partner.fitness:
|
||||
return partner
|
||||
|
||||
safe_flag += 1
|
||||
|
||||
# compute the current "most fit" member of the population
|
||||
def evaluate(self):
|
||||
record = 0
|
||||
best_index = 0
|
||||
|
||||
for index in range(len(self.population)):
|
||||
genome = self.population[index]
|
||||
if genome.fitness > record:
|
||||
record = genome.fitness
|
||||
best_index = index
|
||||
|
||||
self.best_genome = self.population[best_index]
|
||||
if record >= self.perfect_score:
|
||||
self.finished = True
|
||||
|
||||
return self.finished
|
||||
|
||||
def calc_fitness(self):
|
||||
for genome in self.population:
|
||||
genome.calc_fitness()
|
0
algorithms/neural_network/__init__.py
Normal file
0
algorithms/neural_network/__init__.py
Normal file
Binary file not shown.
Binary file not shown.
@ -0,0 +1 @@
|
||||
{}
|
64
algorithms/neural_network/neural_network.py
Normal file
64
algorithms/neural_network/neural_network.py
Normal file
@ -0,0 +1,64 @@
|
||||
import torch
|
||||
import pytorch_lightning as pl
|
||||
import torch.nn as nn
|
||||
from torch.optim import SGD, Adam, lr_scheduler
|
||||
import torch.nn.functional as F
|
||||
from torch.utils.data import DataLoader
|
||||
from watersandtreegrass import WaterSandTreeGrass
|
||||
from common.constants import DEVICE, BATCH_SIZE, NUM_EPOCHS, LEARNING_RATE, SETUP_PHOTOS, ID_TO_CLASS
|
||||
|
||||
|
||||
class NeuralNetwork(pl.LightningModule):
|
||||
def __init__(self, numChannels=3, batch_size=BATCH_SIZE, learning_rate=LEARNING_RATE, num_classes=4):
|
||||
super(NeuralNetwork, self).__init__()
|
||||
self.conv1 = nn.Conv2d(numChannels, 24, (3, 3), padding=1)
|
||||
self.relu1 = nn.ReLU()
|
||||
self.maxpool1 = nn.MaxPool2d((2, 2), stride=2)
|
||||
self.conv2 = nn.Conv2d(24, 48, (3, 3), padding=1)
|
||||
self.relu2 = nn.ReLU()
|
||||
self.fc1 = nn.Linear(48*18*18, 800)
|
||||
self.relu3 = nn.ReLU()
|
||||
self.fc2 = nn.Linear(800, 400)
|
||||
self.relu4 = nn.ReLU()
|
||||
self.fc3 = nn.Linear(400, 4)
|
||||
self.logSoftmax = nn.LogSoftmax(dim=1)
|
||||
|
||||
self.batch_size = batch_size
|
||||
self.learning_rate = learning_rate
|
||||
|
||||
def forward(self, x):
|
||||
x = self.conv1(x)
|
||||
x = self.relu1(x)
|
||||
x = self.maxpool1(x)
|
||||
x = self.conv2(x)
|
||||
x = self.relu2(x)
|
||||
x = x.reshape(x.shape[0], -1)
|
||||
x = self.fc1(x)
|
||||
x = self.relu3(x)
|
||||
x = self.fc2(x)
|
||||
x = self.relu4(x)
|
||||
x = self.fc3(x)
|
||||
x = self.logSoftmax(x)
|
||||
return x
|
||||
|
||||
def configure_optimizers(self):
|
||||
optimizer = Adam(self.parameters(), lr=self.learning_rate)
|
||||
return optimizer
|
||||
|
||||
def training_step(self, batch, batch_idx):
|
||||
x, y = batch
|
||||
scores = self(x)
|
||||
loss = F.nll_loss(scores, y)
|
||||
return loss
|
||||
|
||||
def validation_step(self, batch, batch_idx):
|
||||
x, y = batch
|
||||
scores = self(x)
|
||||
val_loss = F.nll_loss(scores, y)
|
||||
self.log("val_loss", val_loss, on_step=True, on_epoch=True, sync_dist=True)
|
||||
|
||||
def test_step(self, batch, batch_idx):
|
||||
x, y = batch
|
||||
scores = self(x)
|
||||
test_loss = F.nll_loss(scores, y)
|
||||
self.log("test_loss", test_loss, on_step=True, on_epoch=True, sync_dist=True)
|
125
algorithms/neural_network/neural_network_interface.py
Normal file
125
algorithms/neural_network/neural_network_interface.py
Normal file
@ -0,0 +1,125 @@
|
||||
import torch
|
||||
import common.helpers
|
||||
from common.constants import DEVICE, BATCH_SIZE, NUM_EPOCHS, LEARNING_RATE, SETUP_PHOTOS, ID_TO_CLASS
|
||||
from watersandtreegrass import WaterSandTreeGrass
|
||||
from torch.utils.data import DataLoader
|
||||
from neural_network import NeuralNetwork
|
||||
from torchvision.io import read_image, ImageReadMode
|
||||
import torch.nn as nn
|
||||
from torch.optim import Adam
|
||||
import matplotlib.pyplot as plt
|
||||
import pytorch_lightning as pl
|
||||
from pytorch_lightning.callbacks import EarlyStopping
|
||||
import torchvision.transforms.functional as F
|
||||
from PIL import Image
|
||||
|
||||
|
||||
def check_accuracy_tiles():
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/grass_with_tree.jpg') == 'tree':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) grass_with_tree.jpg", answer)
|
||||
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/grass2.png') == 'grass':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) grass2.png", answer)
|
||||
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/grass3.png') == 'grass':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) grass3.png", answer)
|
||||
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/grass4.png') == 'grass':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) grass4.png", answer)
|
||||
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/grass1.png') == 'grass':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) grass1.png", answer)
|
||||
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/water.png') == 'water':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) water.png", answer)
|
||||
|
||||
answer = 0
|
||||
for i in range(100):
|
||||
if what_is_it('../../resources/textures/sand.png') == 'sand':
|
||||
answer = answer + 1
|
||||
print("Accuracy(%) sand.png", answer)
|
||||
|
||||
|
||||
def what_is_it(img_path, show_img=False):
|
||||
image = Image.open(img_path).convert('RGB')
|
||||
if show_img:
|
||||
plt.imshow(image)
|
||||
plt.show()
|
||||
|
||||
image = SETUP_PHOTOS(image).unsqueeze(0)
|
||||
model = NeuralNetwork.load_from_checkpoint('./lightning_logs/version_20/checkpoints/epoch=3-step=324.ckpt')
|
||||
|
||||
with torch.no_grad():
|
||||
model.eval()
|
||||
idx = int(model(image).argmax(dim=1))
|
||||
return ID_TO_CLASS[idx]
|
||||
|
||||
|
||||
def check_accuracy(tset):
|
||||
model = NeuralNetwork.load_from_checkpoint('./lightning_logs/version_23/checkpoints/epoch=3-step=324.ckpt')
|
||||
num_correct = 0
|
||||
num_samples = 0
|
||||
model = model.to(DEVICE)
|
||||
model.eval()
|
||||
|
||||
with torch.no_grad():
|
||||
for photo, label in tset:
|
||||
photo = photo.to(DEVICE)
|
||||
label = label.to(DEVICE)
|
||||
|
||||
scores = model(photo)
|
||||
predictions = scores.argmax(dim=1)
|
||||
num_correct += (predictions == label).sum()
|
||||
num_samples += predictions.size(0)
|
||||
|
||||
print(f'Got {num_correct} / {num_samples} with accuracy {float(num_correct)/float(num_samples)*100:.2f}%')
|
||||
|
||||
|
||||
def check_accuracy_data():
|
||||
trainset = WaterSandTreeGrass('./data/train_csv_file.csv', transform=SETUP_PHOTOS)
|
||||
testset = WaterSandTreeGrass('./data/test_csv_file.csv', transform=SETUP_PHOTOS)
|
||||
train_loader = DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True)
|
||||
test_loader = DataLoader(testset, batch_size=BATCH_SIZE)
|
||||
|
||||
print("Accuracy of train_set:")
|
||||
check_accuracy(train_loader)
|
||||
print("Accuracy of test_set:")
|
||||
check_accuracy(test_loader)
|
||||
|
||||
#CNN = NeuralNetwork()
|
||||
#common.helpers.createCSV()
|
||||
|
||||
#trainer = pl.Trainer(accelerator='gpu', callbacks=EarlyStopping('val_loss'), devices=1, max_epochs=NUM_EPOCHS)
|
||||
#trainer = pl.Trainer(accelerator='gpu', devices=1, auto_lr_find=True, max_epochs=NUM_EPOCHS)
|
||||
|
||||
#trainset = WaterSandTreeGrass('./data/train_csv_file.csv', transform=SETUP_PHOTOS)
|
||||
#testset = WaterSandTreeGrass('./data/test_csv_file.csv', transform=SETUP_PHOTOS)
|
||||
#train_loader = DataLoader(trainset, batch_size=BATCH_SIZE, shuffle=True)
|
||||
#test_loader = DataLoader(testset, batch_size=BATCH_SIZE)
|
||||
#trainer.fit(CNN, train_loader, test_loader)
|
||||
#trainer.tune(CNN, train_loader, test_loader)
|
||||
|
||||
|
||||
#print(what_is_it('../../resources/textures/grass2.png', True))
|
||||
|
||||
#check_accuracy_data()
|
||||
|
||||
#check_accuracy_tiles()
|
27
algorithms/neural_network/watersandtreegrass.py
Normal file
27
algorithms/neural_network/watersandtreegrass.py
Normal file
@ -0,0 +1,27 @@
|
||||
import torch
|
||||
from torch.utils.data import Dataset
|
||||
import pandas as pd
|
||||
from torchvision.io import read_image, ImageReadMode
|
||||
from common.helpers import createCSV
|
||||
from PIL import Image
|
||||
|
||||
|
||||
class WaterSandTreeGrass(Dataset):
|
||||
def __init__(self, annotations_file, transform=None):
|
||||
createCSV()
|
||||
self.img_labels = pd.read_csv(annotations_file)
|
||||
self.transform = transform
|
||||
|
||||
def __len__(self):
|
||||
return len(self.img_labels)
|
||||
|
||||
def __getitem__(self, idx):
|
||||
image = Image.open(self.img_labels.iloc[idx, 0]).convert('RGB')
|
||||
|
||||
label = torch.tensor(int(self.img_labels.iloc[idx, 1]))
|
||||
|
||||
if self.transform:
|
||||
image = self.transform(image)
|
||||
|
||||
return image, label
|
||||
|
@ -1,10 +1,12 @@
|
||||
from enum import Enum
|
||||
import torchvision.transforms as transforms
|
||||
import torch
|
||||
|
||||
GAME_TITLE = 'WMICraft'
|
||||
WINDOW_HEIGHT = 800
|
||||
WINDOW_WIDTH = 1360
|
||||
FPS_COUNT = 60
|
||||
TURN_INTERVAL = 300
|
||||
TURN_INTERVAL = 200
|
||||
|
||||
GRID_CELL_PADDING = 5
|
||||
GRID_CELL_SIZE = 36
|
||||
@ -63,12 +65,32 @@ ACTION = {
|
||||
"go": 0,
|
||||
}
|
||||
|
||||
LEFT = 'LEFT'
|
||||
RIGHT = 'RIGHT'
|
||||
UP = 'UP'
|
||||
DOWN = 'DOWN'
|
||||
|
||||
# HEALTH_BAR
|
||||
BAR_ANIMATION_SPEED = 1
|
||||
BAR_WIDTH_MULTIPLIER = 0.9 # (0;1>
|
||||
BAR_HEIGHT_MULTIPLIER = 0.1
|
||||
|
||||
LEFT = 'LEFT'
|
||||
RIGHT = 'RIGHT'
|
||||
UP = 'UP'
|
||||
DOWN = 'DOWN'
|
||||
|
||||
#NEURAL_NETWORK
|
||||
LEARNING_RATE = 0.000630957344480193
|
||||
BATCH_SIZE = 64
|
||||
NUM_EPOCHS = 9
|
||||
|
||||
DEVICE = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
|
||||
print("Using ", DEVICE)
|
||||
CLASSES = ['grass', 'sand', 'tree', 'water']
|
||||
|
||||
SETUP_PHOTOS = transforms.Compose([
|
||||
transforms.ToTensor(),
|
||||
transforms.Resize((36, 36)),
|
||||
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
|
||||
])
|
||||
|
||||
ID_TO_CLASS = {i: j for i, j in enumerate(CLASSES)}
|
||||
CLASS_TO_ID = {value: key for key, value in ID_TO_CLASS.items()}
|
||||
|
||||
|
@ -2,6 +2,11 @@ from typing import Tuple, List
|
||||
|
||||
import pygame
|
||||
|
||||
from algorithms.genetic.const import MAP_ALIASES
|
||||
from common.constants import GRID_CELL_PADDING, GRID_CELL_SIZE, COLUMNS, ROWS, CLASSES, CLASS_TO_ID
|
||||
import csv
|
||||
import os
|
||||
|
||||
from common.constants import GRID_CELL_PADDING, GRID_CELL_SIZE
|
||||
from common.constants import ROWS, COLUMNS, LEFT, RIGHT, UP, DOWN
|
||||
|
||||
@ -24,6 +29,44 @@ def draw_text(text, color, surface, x, y, text_size=30, is_bold=False):
|
||||
surface.blit(textobj, textrect)
|
||||
|
||||
|
||||
def createCSV():
|
||||
train_data_path = './data/train'
|
||||
test_data_path = './data/test'
|
||||
|
||||
if os.path.exists(train_data_path):
|
||||
train_csvfile = open('./data/train_csv_file.csv', 'w', newline="")
|
||||
writer = csv.writer(train_csvfile)
|
||||
writer.writerow(["filepath", "type"])
|
||||
|
||||
for class_name in CLASSES:
|
||||
class_dir = train_data_path + "/" + class_name
|
||||
for filename in os.listdir(class_dir):
|
||||
f = os.path.join(class_dir, filename)
|
||||
if os.path.isfile(f):
|
||||
writer.writerow([f, CLASS_TO_ID[class_name]])
|
||||
|
||||
train_csvfile.close()
|
||||
|
||||
else:
|
||||
print("Brak plików do uczenia")
|
||||
|
||||
if os.path.exists(test_data_path):
|
||||
test_csvfile = open('./data/test_csv_file.csv', 'w', newline="")
|
||||
writer = csv.writer(test_csvfile)
|
||||
writer.writerow(["filepath", "type"])
|
||||
|
||||
for class_name in CLASSES:
|
||||
class_dir = test_data_path + "/" + class_name
|
||||
for filename in os.listdir(class_dir):
|
||||
f = os.path.join(class_dir, filename)
|
||||
if os.path.isfile(f):
|
||||
writer.writerow([f, CLASS_TO_ID[class_name]])
|
||||
|
||||
test_csvfile.close()
|
||||
else:
|
||||
print("Brak plików do testowania")
|
||||
|
||||
|
||||
def print_numbers():
|
||||
display_surface = pygame.display.get_surface()
|
||||
font = pygame.font.SysFont('Arial', 16)
|
||||
@ -58,7 +101,7 @@ def castle_neighbors(map, castle_bottom_right_row, castle_bottom_right_col):
|
||||
return neighbors
|
||||
|
||||
|
||||
def find_neighbours(grid: List[List[str]], col: int, row: int) -> List[Tuple[int, int]]:
|
||||
def find_neighbours(grid: List[List[int]], col: int, row: int) -> List[Tuple[int, int]]:
|
||||
dr = [-1, 1, 0, 0]
|
||||
dc = [0, 0, -1, 1]
|
||||
|
||||
@ -70,7 +113,7 @@ def find_neighbours(grid: List[List[str]], col: int, row: int) -> List[Tuple[int
|
||||
|
||||
if rr < 0 or cc < 0: continue
|
||||
if rr >= ROWS or cc >= COLUMNS: continue
|
||||
if grid[rr][cc] not in ['g', 's', '.']: continue
|
||||
if grid[rr][cc] not in [MAP_ALIASES.get("GRASS"), MAP_ALIASES.get("SAND"), '.']: continue
|
||||
neighbours.append((rr, cc))
|
||||
|
||||
return neighbours
|
||||
|
@ -34,7 +34,7 @@ class DecisionTree:
|
||||
self.model = DecisionTreeClassifier(criterion='entropy')
|
||||
self.model.fit(self.train_set.values, self.goals)
|
||||
|
||||
def predict_move(self, grid: List[List[str]], current_knight: Knight, castle: Castle, monsters: List[Monster],
|
||||
def predict_move(self, grid: List[List[int]], current_knight: Knight, castle: Castle, monsters: List[Monster],
|
||||
opponents: List[Knight]) -> \
|
||||
List[Tuple[int, int]]:
|
||||
distance_to_castle = manhattan_distance(current_knight.position, castle.position)
|
||||
@ -42,22 +42,23 @@ class DecisionTree:
|
||||
monsters_parsed = []
|
||||
for monster in monsters:
|
||||
monsters_parsed.append((manhattan_distance(current_knight.position, monster.position), parse_hp(
|
||||
monster.current_hp)))
|
||||
monster.health_bar.current_hp)))
|
||||
|
||||
opponents_parsed = []
|
||||
for opponent in opponents:
|
||||
opponents_parsed.append(
|
||||
(manhattan_distance(current_knight.position, opponent.position), parse_hp(opponent.current_hp)))
|
||||
(manhattan_distance(current_knight.position, opponent.position),
|
||||
parse_hp(opponent.health_bar.current_hp)))
|
||||
|
||||
prediction = self.get_prediction(tower_dist=distance_to_castle, tower_hp=castle.current_hp,
|
||||
prediction = self.get_prediction(tower_dist=distance_to_castle, tower_hp=castle.health_bar.current_hp,
|
||||
mob1_dist=monsters_parsed[0][0], mob1_hp=monsters_parsed[0][1],
|
||||
mob2_dist=monsters_parsed[1][0], mob2_hp=monsters_parsed[1][1],
|
||||
opp1_dist=opponents_parsed[0][0], opp1_hp=opponents_parsed[0][1],
|
||||
opp2_dist=opponents_parsed[1][0], opp2_hp=opponents_parsed[1][1],
|
||||
opp3_dist=opponents_parsed[2][0], opp3_hp=opponents_parsed[2][1],
|
||||
opp4_dist=opponents_parsed[3][0], opp4_hp=opponents_parsed[3][1],
|
||||
agent_hp=current_knight.current_hp)
|
||||
print(prediction)
|
||||
agent_hp=current_knight.health_bar.current_hp)
|
||||
print(f'Prediction = {prediction}')
|
||||
if prediction == 'tower': # castle...
|
||||
return castle_neighbors(grid, castle_bottom_right_row=castle.position[0],
|
||||
castle_bottom_right_col=castle.position[1])
|
||||
|
@ -27,7 +27,6 @@ class Game:
|
||||
self.screens = {'credits': Credits(self.screen, self.clock), 'options': Options(self.screen, self.clock)}
|
||||
|
||||
|
||||
|
||||
def main_menu(self):
|
||||
menu = MainMenu(self.screen, self.clock, self.bg,
|
||||
self.game,
|
||||
@ -38,7 +37,6 @@ class Game:
|
||||
def game(self):
|
||||
logs = Logs(self.screen)
|
||||
level = Level(self.screen, logs)
|
||||
stats = Stats(self.screen)
|
||||
|
||||
# setup clock for rounds
|
||||
NEXT_TURN = pygame.USEREVENT + 1
|
||||
@ -46,6 +44,8 @@ class Game:
|
||||
|
||||
# create level
|
||||
level.create_map()
|
||||
stats = Stats(self.screen, level.list_knights_blue, level.list_knights_red)
|
||||
level.setup_stats(stats)
|
||||
|
||||
print_numbers_flag = False
|
||||
running = True
|
||||
@ -61,8 +61,7 @@ class Game:
|
||||
running = False
|
||||
if event.key == pygame.K_n:
|
||||
print_numbers_flag = not print_numbers_flag
|
||||
if event.key == pygame.K_r:
|
||||
stats.red_team_hp_bar.take_dmg(5)
|
||||
|
||||
if event.type == NEXT_TURN: # is called every 'TURN_INTERVAL' milliseconds
|
||||
level.handle_turn()
|
||||
|
||||
|
@ -9,7 +9,6 @@ class HealthBar:
|
||||
self.rect = rect
|
||||
self.screen = screen
|
||||
self.current_hp = current_hp
|
||||
self.target_hp = current_hp
|
||||
self.max_hp = max_hp
|
||||
self.x = self.rect.x
|
||||
self.y = self.rect.y
|
||||
@ -38,22 +37,22 @@ class HealthBar:
|
||||
|
||||
self.health_ratio = self.max_hp / self.width
|
||||
|
||||
def take_dmg(self, dmg_taken):
|
||||
if self.target_hp > 0:
|
||||
self.target_hp -= dmg_taken
|
||||
elif self.target_hp < 0:
|
||||
self.target_hp = 0
|
||||
def take_dmg(self, amount):
|
||||
if self.current_hp - amount > 0:
|
||||
self.current_hp -= amount
|
||||
elif self.current_hp - amount <= 0:
|
||||
self.current_hp = 0
|
||||
|
||||
def heal(self, amount):
|
||||
if self.target_hp < self.max_hp:
|
||||
self.target_hp += amount
|
||||
elif self.target_hp > self.max_hp:
|
||||
self.target_hp = self.max_hp
|
||||
if self.current_hp + amount < self.max_hp:
|
||||
self.current_hp += amount
|
||||
elif self.current_hp + amount >= self.max_hp:
|
||||
self.current_hp = self.max_hp
|
||||
|
||||
def show(self):
|
||||
pygame.Surface.fill(self.screen, BLACK, (self.x-1, self.y-1, self.width+2, self.height+2))
|
||||
pygame.Surface.fill(self.screen, RED, (self.x, self.y, self.width, self.height))
|
||||
pygame.Surface.fill(self.screen, GREEN, (self.x, self.y, int(self.target_hp / self.health_ratio), self.height))
|
||||
pygame.Surface.fill(self.screen, GREEN, (self.x, self.y, int(self.current_hp / self.health_ratio), self.height))
|
||||
|
||||
|
||||
|
||||
|
@ -10,7 +10,7 @@ class KnightsQueue:
|
||||
def dequeue_knight(self):
|
||||
if self.both_teams_alive():
|
||||
knight = self.queues[self.team_idx_turn].popleft()
|
||||
if knight.max_hp <= 0:
|
||||
if knight.health_bar.current_hp <= 0:
|
||||
return self.dequeue_knight()
|
||||
else:
|
||||
self.queues[self.team_idx_turn].append(knight)
|
||||
|
198
logic/level.py
198
logic/level.py
@ -3,10 +3,11 @@ import random
|
||||
import pygame
|
||||
|
||||
from algorithms.a_star import a_star, State, TURN_RIGHT, TURN_LEFT, FORWARD
|
||||
from algorithms.genetic.const import MAP_ALIASES
|
||||
from algorithms.genetic.map_importer_exporter import import_random_map
|
||||
from common.constants import *
|
||||
from learning.decision_tree import DecisionTree
|
||||
from logic.knights_queue import KnightsQueue
|
||||
from logic.spawner import Spawner
|
||||
from models.castle import Castle
|
||||
from models.knight import Knight
|
||||
from models.monster import Monster
|
||||
@ -21,7 +22,7 @@ class Level:
|
||||
# sprite group setup
|
||||
self.sprites = pygame.sprite.LayeredUpdates()
|
||||
|
||||
self.map = [['g' for _ in range(COLUMNS)] for y in range(ROWS)]
|
||||
self.map = []
|
||||
|
||||
self.list_knights_blue = []
|
||||
self.list_knights_red = []
|
||||
@ -30,28 +31,21 @@ class Level:
|
||||
|
||||
self.knights_queue = None
|
||||
|
||||
self.stats = None
|
||||
|
||||
def setup_stats(self, stats):
|
||||
self.stats = stats
|
||||
|
||||
def add_points(self, team, points_to_add):
|
||||
if self.stats is not None:
|
||||
self.stats.add_points(team, points_to_add)
|
||||
|
||||
def create_map(self):
|
||||
self.generate_map()
|
||||
self.map = import_random_map()
|
||||
self.setup_base_tiles()
|
||||
self.setup_objects()
|
||||
self.knights_queue = KnightsQueue(self.list_knights_blue, self.list_knights_red)
|
||||
|
||||
def generate_map(self):
|
||||
spawner = Spawner(self.map)
|
||||
spawner.spawn_where_possible(['w' for _ in range(NBR_OF_WATER)])
|
||||
spawner.spawn_where_possible(['t' for _ in range(NBR_OF_TREES)])
|
||||
spawner.spawn_where_possible(['s' for _ in range(NBR_OF_SANDS)])
|
||||
|
||||
spawner.spawn_in_area(['k_b' for _ in range(4)], LEFT_KNIGHTS_SPAWN_FIRST_ROW, LEFT_KNIGHTS_SPAWN_FIRST_COL,
|
||||
KNIGHTS_SPAWN_WIDTH, KNIGHTS_SPAWN_HEIGHT)
|
||||
spawner.spawn_in_area(['k_r' for _ in range(4)], RIGHT_KNIGHTS_SPAWN_FIRST_ROW, RIGHT_KNIGHTS_SPAWN_FIRST_COL,
|
||||
KNIGHTS_SPAWN_WIDTH, KNIGHTS_SPAWN_HEIGHT)
|
||||
|
||||
spawner.spawn_in_area(['c'], CASTLE_SPAWN_FIRST_ROW, CASTLE_SPAWN_FIRST_COL, CASTLE_SPAWN_WIDTH,
|
||||
CASTLE_SPAWN_HEIGHT, 2)
|
||||
|
||||
spawner.spawn_where_possible(['m' for _ in range(NBR_OF_MONSTERS)])
|
||||
|
||||
def setup_base_tiles(self):
|
||||
textures = []
|
||||
for texture_path in TILES:
|
||||
@ -63,15 +57,15 @@ class Level:
|
||||
for col_index, col in enumerate(row):
|
||||
|
||||
# add base tiles, e.g. water, tree, grass
|
||||
if col == "w":
|
||||
if col == MAP_ALIASES.get('WATER'):
|
||||
texture_index = 5
|
||||
texture_surface = textures[texture_index][1]
|
||||
Tile((col_index, row_index), texture_surface, self.sprites, 'w')
|
||||
elif col == "t":
|
||||
elif col == MAP_ALIASES.get('TREE'):
|
||||
texture_index = 6
|
||||
texture_surface = textures[texture_index][1]
|
||||
Tile((col_index, row_index), texture_surface, self.sprites, 't')
|
||||
elif col == "s":
|
||||
elif col == MAP_ALIASES.get('SAND'):
|
||||
texture_index = 4
|
||||
texture_surface = textures[texture_index][1]
|
||||
Tile((col_index, row_index), texture_surface, self.sprites)
|
||||
@ -88,37 +82,148 @@ class Level:
|
||||
for col_index, col in enumerate(row):
|
||||
|
||||
# add objects, e.g. knights, monsters, castle
|
||||
if col == "k_b":
|
||||
if col == MAP_ALIASES.get('KNIGHT_BLUE'):
|
||||
knight = Knight(self.screen, (col_index, row_index), self.sprites, "blue")
|
||||
self.map[row_index][col_index] = knight
|
||||
self.list_knights_blue.append(knight)
|
||||
elif col == "k_r":
|
||||
elif col == MAP_ALIASES.get('KNIGHT_RED'):
|
||||
knight = Knight(self.screen, (col_index, row_index), self.sprites, "red")
|
||||
self.map[row_index][col_index] = knight
|
||||
self.list_knights_red.append(knight)
|
||||
elif col == "m":
|
||||
elif col == MAP_ALIASES.get('MONSTER'):
|
||||
monster = Monster(self.screen, (col_index, row_index), self.sprites)
|
||||
self.map[row_index][col_index] = monster
|
||||
self.list_monsters.append(monster)
|
||||
elif col == "c":
|
||||
elif col == MAP_ALIASES.get('CASTLE'):
|
||||
castle_count += 1
|
||||
if castle_count == 4:
|
||||
castle = Castle(self.screen, (col_index, row_index), self.sprites)
|
||||
self.map[row_index][col_index] = castle
|
||||
self.list_castles.append(castle)
|
||||
|
||||
#def attack_knight(self, knights_list, positions, current_knight):
|
||||
# op_pos_1 = current_knight.position[0] - 1, current_knight.position[1]
|
||||
# positions.append(op_pos_1)
|
||||
# op_pos_2 = current_knight.position[0], current_knight.position[1] - 1
|
||||
# positions.append(op_pos_2)
|
||||
# op_pos_3 = current_knight.position[0] + 1, current_knight.position[1]
|
||||
# positions.append(op_pos_3)
|
||||
# op_pos_4 = current_knight.position[0], current_knight.position[1] + 1
|
||||
# positions.append(op_pos_4)
|
||||
# for some_knight in knights_list:
|
||||
# for some_position in positions:
|
||||
# if (some_knight.position == some_position and some_knight.team != current_knight.team):
|
||||
# some_knight.health_bar.take_dmg(current_knight.attack)
|
||||
# if some_knight.health_bar.current_hp == 0:
|
||||
# some_knight.kill()
|
||||
# positions.clear()
|
||||
|
||||
def attack_knight_left(self, knights_list, current_knight):
|
||||
position_left = current_knight.position[0] - 1, current_knight.position[1]
|
||||
for some_knight in knights_list:
|
||||
if (some_knight.position == position_left and some_knight.team != current_knight.team):
|
||||
some_knight.health_bar.take_dmg(current_knight.attack)
|
||||
if some_knight.health_bar.current_hp <= 0:
|
||||
some_knight.kill()
|
||||
self.add_points(current_knight.team, 5)
|
||||
for monster in self.list_monsters:
|
||||
if monster.position == position_left:
|
||||
monster.health_bar.take_dmg(current_knight.attack)
|
||||
if monster.health_bar.current_hp <= 0:
|
||||
monster.kill()
|
||||
self.add_points(current_knight.team, monster.points)
|
||||
else:
|
||||
current_knight.health_bar.take_dmg(monster.attack)
|
||||
if current_knight.health_bar.current_hp <= 0:
|
||||
current_knight.kill()
|
||||
for castle in self.list_castles:
|
||||
if castle.position == position_left:
|
||||
castle.health_bar.take_dmg(current_knight.attack)
|
||||
|
||||
|
||||
def attack_knight_right(self, knights_list, current_knight):
|
||||
position_right = current_knight.position[0] + 1, current_knight.position[1]
|
||||
for some_knight in knights_list:
|
||||
if (some_knight.position == position_right and some_knight.team != current_knight.team):
|
||||
some_knight.health_bar.take_dmg(current_knight.attack)
|
||||
if some_knight.health_bar.current_hp == 0:
|
||||
some_knight.kill()
|
||||
self.add_points(current_knight.team, 5)
|
||||
for monster in self.list_monsters:
|
||||
if monster.position == position_right:
|
||||
monster.health_bar.take_dmg(current_knight.attack)
|
||||
if monster.health_bar.current_hp <= 0:
|
||||
monster.kill()
|
||||
self.add_points(current_knight.team, monster.points)
|
||||
else:
|
||||
current_knight.health_bar.take_dmg(monster.attack)
|
||||
if current_knight.health_bar.current_hp <= 0:
|
||||
current_knight.kill()
|
||||
for castle in self.list_castles:
|
||||
if castle.position == position_right:
|
||||
castle.health_bar.take_dmg(current_knight.attack)
|
||||
|
||||
def attack_knight_up(self, knights_list, current_knight):
|
||||
position_up = current_knight.position[0], current_knight.position[1] - 1
|
||||
for some_knight in knights_list:
|
||||
if (some_knight.position == position_up and some_knight.team != current_knight.team):
|
||||
some_knight.health_bar.take_dmg(current_knight.attack)
|
||||
if some_knight.health_bar.current_hp == 0:
|
||||
some_knight.kill()
|
||||
self.add_points(current_knight.team, 5)
|
||||
for monster in self.list_monsters:
|
||||
if monster.position == position_up:
|
||||
monster.health_bar.take_dmg(current_knight.attack)
|
||||
if monster.health_bar.current_hp <= 0:
|
||||
monster.kill()
|
||||
self.add_points(current_knight.team, monster.points)
|
||||
else:
|
||||
current_knight.health_bar.take_dmg(monster.attack)
|
||||
if current_knight.health_bar.current_hp <= 0:
|
||||
current_knight.kill()
|
||||
for castle in self.list_castles:
|
||||
if castle.position == position_up:
|
||||
castle.health_bar.take_dmg(current_knight.attack)
|
||||
|
||||
def attack_knight_down(self, knights_list, current_knight):
|
||||
position_down = current_knight.position[0], current_knight.position[1] + 1
|
||||
for some_knight in knights_list:
|
||||
if (some_knight.position == position_down and some_knight.team != current_knight.team):
|
||||
some_knight.health_bar.take_dmg(current_knight.attack)
|
||||
if some_knight.health_bar.current_hp == 0:
|
||||
some_knight.kill()
|
||||
self.add_points(current_knight.team, 5)
|
||||
for monster in self.list_monsters:
|
||||
if monster.position == position_down:
|
||||
monster.health_bar.take_dmg(current_knight.attack)
|
||||
if monster.health_bar.current_hp <= 0:
|
||||
monster.kill()
|
||||
self.add_points(current_knight.team, monster.points)
|
||||
else:
|
||||
current_knight.health_bar.take_dmg(monster.attack)
|
||||
if current_knight.health_bar.current_hp <= 0:
|
||||
current_knight.kill()
|
||||
for castle in self.list_castles:
|
||||
if castle.position == position_down:
|
||||
castle.health_bar.take_dmg(current_knight.attack)
|
||||
|
||||
def handle_turn(self):
|
||||
print("next turn")
|
||||
current_knight = self.knights_queue.dequeue_knight()
|
||||
knights_list = self.list_knights_red + self.list_knights_blue
|
||||
print("next turn " + current_knight.team)
|
||||
knight_pos_x = current_knight.position[0]
|
||||
knight_pos_y = current_knight.position[1]
|
||||
positions = []
|
||||
|
||||
goal_list = self.decision_tree.predict_move(grid=self.map, current_knight=current_knight,
|
||||
monsters=self.list_monsters,
|
||||
opponents=self.list_knights_red
|
||||
if current_knight.team_alias == 'k_r' else self.list_knights_blue,
|
||||
opponents=self.list_knights_blue
|
||||
if current_knight.team_alias() == 'k_r' else self.list_knights_red,
|
||||
castle=self.list_castles[0])
|
||||
|
||||
if (len(self.list_knights_blue) == 0 or len(self.list_knights_red) == 0):
|
||||
pygame.quit()
|
||||
|
||||
if len(goal_list) == 0:
|
||||
return
|
||||
|
||||
@ -131,6 +236,19 @@ class Level:
|
||||
return
|
||||
|
||||
next_action = action_list.pop(0)
|
||||
|
||||
#if current_knight.health_bar.current_hp != 0:
|
||||
#self.attack_knight(knights_list, positions, current_knight)
|
||||
|
||||
if current_knight.direction.name == UP:
|
||||
self.attack_knight_up(knights_list, current_knight)
|
||||
elif current_knight.direction.name == DOWN:
|
||||
self.attack_knight_down(knights_list, current_knight)
|
||||
elif current_knight.direction.name == RIGHT:
|
||||
self.attack_knight_right(knights_list, current_knight)
|
||||
elif current_knight.direction.name == LEFT:
|
||||
self.attack_knight_left(knights_list, current_knight)
|
||||
|
||||
if next_action == TURN_LEFT:
|
||||
self.logs.enqueue_log(f'AI {current_knight.team}: Obrót w lewo.')
|
||||
current_knight.rotate_left()
|
||||
@ -139,9 +257,9 @@ class Level:
|
||||
current_knight.rotate_right()
|
||||
elif next_action == FORWARD:
|
||||
current_knight.step_forward()
|
||||
self.map[knight_pos_y][knight_pos_x] = 'g'
|
||||
self.map[knight_pos_y][knight_pos_x] = MAP_ALIASES.get("GRASS")
|
||||
|
||||
# update knight on map
|
||||
# update knight on map
|
||||
if current_knight.direction.name == UP:
|
||||
self.logs.enqueue_log(f'AI {current_knight.team}: Ruch do góry.')
|
||||
self.map[knight_pos_y - 1][knight_pos_x] = current_knight.team_alias()
|
||||
@ -155,19 +273,6 @@ class Level:
|
||||
self.logs.enqueue_log(f'AI {current_knight.team}: Ruch w lewo.')
|
||||
self.map[knight_pos_y][knight_pos_x - 1] = current_knight.team_alias()
|
||||
|
||||
def update_health_bars(self):
|
||||
for knight in self.list_knights_blue:
|
||||
knight.health_bar.update()
|
||||
|
||||
for knight in self.list_knights_red:
|
||||
knight.health_bar.update()
|
||||
|
||||
for monster in self.list_monsters:
|
||||
monster.health_bar.update()
|
||||
|
||||
for castle in self.list_castles:
|
||||
castle.health_bar.update()
|
||||
|
||||
def update(self):
|
||||
bg_width = (GRID_CELL_PADDING + GRID_CELL_SIZE) * COLUMNS + BORDER_WIDTH
|
||||
bg_height = (GRID_CELL_PADDING + GRID_CELL_SIZE) * ROWS + BORDER_WIDTH
|
||||
@ -175,4 +280,7 @@ class Level:
|
||||
|
||||
# update and draw the game
|
||||
self.sprites.draw(self.screen)
|
||||
self.update_health_bars() # has to be called last
|
||||
self.sprites.update()
|
||||
|
||||
|
||||
|
||||
|
@ -16,5 +16,7 @@ class Castle(pygame.sprite.Sprite):
|
||||
position_in_px = (parse_cord(position[0]), parse_cord(position[1]))
|
||||
self.rect = self.image.get_rect(center=position_in_px)
|
||||
self.max_hp = 80
|
||||
self.current_hp = random.randint(1, self.max_hp)
|
||||
self.health_bar = HealthBar(screen, self.rect, current_hp=self.current_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)
|
||||
self.health_bar = HealthBar(screen, self.rect, current_hp=self.max_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)
|
||||
|
||||
def update(self):
|
||||
self.health_bar.update()
|
||||
|
@ -7,8 +7,11 @@ from common.helpers import parse_cord
|
||||
from logic.health_bar import HealthBar
|
||||
|
||||
|
||||
def load_knight_textures():
|
||||
random_index = random.randint(1, 4)
|
||||
def load_knight_textures(team):
|
||||
if team == "blue":
|
||||
random_index = 3
|
||||
else:
|
||||
random_index = 4
|
||||
states = [
|
||||
pygame.image.load(f'resources/textures/knight_{random_index}_up.png').convert_alpha(), # up = 0
|
||||
pygame.image.load(f'resources/textures/knight_{random_index}_right.png').convert_alpha(), # right = 1
|
||||
@ -24,7 +27,7 @@ class Knight(pygame.sprite.Sprite):
|
||||
super().__init__(group)
|
||||
|
||||
self.direction = Direction.DOWN
|
||||
self.states = load_knight_textures()
|
||||
self.states = load_knight_textures(team)
|
||||
|
||||
self.image = self.states[self.direction.value]
|
||||
self.position = position
|
||||
@ -33,21 +36,35 @@ class Knight(pygame.sprite.Sprite):
|
||||
self.rect = self.image.get_rect(topleft=position_in_px)
|
||||
|
||||
self.team = team
|
||||
self.max_hp = random.randint(7, 12)
|
||||
self.current_hp = random.randint(1, self.max_hp)
|
||||
self.attack = random.randint(4, 7)
|
||||
self.max_hp = random.randint(9, 13)
|
||||
self.attack = random.randint(2, 4)
|
||||
self.defense = random.randint(1, 4)
|
||||
self.points = 1
|
||||
self.health_bar = HealthBar(screen, self.rect, current_hp=self.current_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)
|
||||
self.health_bar = HealthBar(screen, self.rect, current_hp=self.max_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)
|
||||
|
||||
def rotate_left(self):
|
||||
self.direction = self.direction.left()
|
||||
self.image = self.states[self.direction.value]
|
||||
|
||||
def update(self):
|
||||
self.health_bar.update()
|
||||
|
||||
def rotate_right(self):
|
||||
self.direction = self.direction.right()
|
||||
self.image = self.states[self.direction.value]
|
||||
|
||||
def take_dmg(self, amount):
|
||||
self.health_bar.take_dmg(amount)
|
||||
|
||||
def heal(self, amount):
|
||||
self.health_bar.heal(amount)
|
||||
|
||||
def get_current_hp(self):
|
||||
return self.health_bar.current_hp
|
||||
|
||||
def get_max_hp(self):
|
||||
return self.health_bar.max_hp
|
||||
|
||||
def step_forward(self):
|
||||
if self.direction.name == 'UP':
|
||||
self.position = (self.position[0], self.position[1] - 1)
|
||||
|
@ -22,14 +22,13 @@ class Monster(pygame.sprite.Sprite):
|
||||
position_in_px = (parse_cord(position[0]), parse_cord(position[1]))
|
||||
self.rect = self.image.get_rect(topleft=position_in_px)
|
||||
self.position = position
|
||||
self.max_hp = random.randrange(15, 25)
|
||||
self.current_hp = random.randint(1, self.max_hp)
|
||||
self.health_bar = HealthBar(screen, self.rect, current_hp=self.current_hp, max_hp=self.max_hp,
|
||||
self.max_hp = random.randrange(15, 20)
|
||||
self.health_bar = HealthBar(screen, self.rect, current_hp=self.max_hp, max_hp=self.max_hp,
|
||||
calculate_xy=True, calculate_size=True)
|
||||
self.attack = random.randrange(2, 10)
|
||||
self.attack = random.randrange(4, 6)
|
||||
if self.image == monster_images[0]:
|
||||
self.max_hp = 20
|
||||
self.attack = 9
|
||||
self.attack = 6
|
||||
self.points = 10
|
||||
elif self.image == monster_images[1]:
|
||||
self.max_hp = 15
|
||||
@ -43,3 +42,6 @@ class Monster(pygame.sprite.Sprite):
|
||||
self.max_hp = 7
|
||||
self.attack = 2
|
||||
self.points = 2
|
||||
|
||||
def update(self):
|
||||
self.health_bar.update()
|
||||
|
BIN
requirements.txt
BIN
requirements.txt
Binary file not shown.
1
resources/maps/map_2022_06_02_13_27_18.json
Normal file
1
resources/maps/map_2022_06_02_13_27_18.json
Normal file
@ -0,0 +1 @@
|
||||
{"map": [[0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 3, 3, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3], [0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 3], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 0, 3], [0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 3, 3, 3, 0, 0, 0, 3, 3, 3, 3, 0, 2, 2, 2, 0, 0, 0, 0, 0, 7, 2, 0], [0, 0, 0, 6, 0, 0, 0, 2, 2, 2, 0, 5, 5, 0, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 5, 5, 0, 2, 0, 0, 0, 0, 2, 2, 1, 1, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 3, 1, 7], [6, 0, 0, 6, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 1, 1, 0], [6, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 3, 3, 0, 0, 0, 0, 3, 3, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 1, 1, 7, 0], [0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 3, 1, 1, 1, 0], [0, 3, 3, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 1, 0, 0], [0, 3, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
|
1
resources/maps/map_2022_06_06_14_55_49.json
Normal file
1
resources/maps/map_2022_06_06_14_55_49.json
Normal file
@ -0,0 +1 @@
|
||||
{"map": [[0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0], [0, 3, 3, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 0, 0, 0, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 2, 2, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 3, 0, 0, 0, 0, 0, 0, 3, 0, 0, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 3, 0, 0, 0, 0, 0, 3, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 3, 3, 0, 0, 0, 0, 0, 3, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 3, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 7, 7, 0, 0], [6, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 3, 7, 0, 0, 0], [0, 0, 6, 6, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0], [0, 2, 2, 2, 2, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0], [2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 2, 0, 0, 0, 0, 0, 4, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
|
1
resources/maps/map_2022_06_06_14_58_11.json
Normal file
1
resources/maps/map_2022_06_06_14_58_11.json
Normal file
@ -0,0 +1 @@
|
||||
{"map": [[0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 3], [0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 3, 0], [0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0, 0, 0, 2, 0], [0, 0, 3, 3, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 2, 0], [0, 0, 3, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0], [0, 0, 3, 3, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [0, 0, 0, 6, 0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 6, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 5, 5, 1, 2, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0, 4, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0], [0, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 4], [6, 0, 0, 6, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 1, 1, 0, 7, 0, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 3, 2, 0, 0, 0, 0, 0, 0], [0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0], [0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
|
@ -1,6 +1,31 @@
|
||||
from ui.screens.screen import Screen
|
||||
import pygame
|
||||
|
||||
from ui.screens.screen import Screen
|
||||
from common.colors import BLACK
|
||||
from common.helpers import draw_text
|
||||
|
||||
class Credits(Screen):
|
||||
|
||||
def __init__(self, screen, clock):
|
||||
super().__init__('credits', screen, clock)
|
||||
|
||||
def display_screen(self):
|
||||
running = True
|
||||
while running:
|
||||
self.screen.fill((252, 164, 12))
|
||||
draw_text('Twórcy :', BLACK, self.screen, 520, 150)
|
||||
draw_text('Angelika Iskra', BLACK, self.screen, 520, 250)
|
||||
draw_text('Dawid Korzępa', BLACK, self.screen, 520, 300)
|
||||
draw_text('Juliusz Sadowski', BLACK, self.screen, 520, 350)
|
||||
draw_text('Aleksandra Muczyńska', BLACK, self.screen, 520, 400)
|
||||
draw_text('Jerzy Tomaszewski', BLACK, self.screen, 520, 450)
|
||||
draw_text('Mateusz Konofał', BLACK, self.screen, 520, 500)
|
||||
for event in pygame.event.get():
|
||||
if event.type == pygame.QUIT:
|
||||
running = False
|
||||
if event.type == pygame.KEYDOWN:
|
||||
if event.key == pygame.K_ESCAPE:
|
||||
running = False
|
||||
pygame.display.update()
|
||||
self.clock.tick(60)
|
||||
|
||||
|
40
ui/stats.py
40
ui/stats.py
@ -8,13 +8,23 @@ from common.helpers import draw_text
|
||||
|
||||
|
||||
class Stats:
|
||||
def __init__(self, screen):
|
||||
def __init__(self, screen, list_knights_blue, list_knights_red):
|
||||
self.grid = []
|
||||
self.list_knights_blue = list_knights_blue
|
||||
self.list_knights_red = list_knights_red
|
||||
self.screen = screen
|
||||
self.x = (GRID_CELL_PADDING + GRID_CELL_SIZE) * COLUMNS + BORDER_WIDTH + 15
|
||||
self.y = 5
|
||||
self.blue_team_hp_bar = HealthBar(self.screen, pygame.Rect(self.x + 30, self.y + 210, 100, 15), current_hp=50, max_hp=100)
|
||||
self.red_team_hp_bar = HealthBar(self.screen, pygame.Rect(self.x + 210, self.y + 210, 100, 15), 100, 100)
|
||||
self.blue_team_hp_bar = HealthBar(self.screen,
|
||||
pygame.Rect(self.x + 30, self.y + 210, 100, 15),
|
||||
current_hp=sum([knight.get_current_hp() for knight in self.list_knights_blue]),
|
||||
max_hp=sum([knight.get_max_hp() for knight in self.list_knights_blue]))
|
||||
self.red_team_hp_bar = HealthBar(self.screen,
|
||||
pygame.Rect(self.x + 210, self.y + 210, 100, 15),
|
||||
current_hp=sum([knight.get_current_hp() for knight in self.list_knights_red]),
|
||||
max_hp=sum([knight.get_max_hp() for knight in self.list_knights_red]))
|
||||
self.blue_team_points = 0
|
||||
self.red_team_points = 0
|
||||
|
||||
def update(self):
|
||||
|
||||
@ -33,21 +43,25 @@ class Stats:
|
||||
draw_text('VS', FONT_DARK, self.screen, self.x + 150, self.y + 120, 36)
|
||||
|
||||
# HP bars
|
||||
#pygame.draw.rect(screen, RED, pygame.Rect(x + 30, y + 210, 100, 15), 0, 4)
|
||||
#pygame.draw.rect(screen, RED, pygame.Rect(x + 210, y + 210, 100, 15), 0, 4)
|
||||
self.red_team_hp_bar.take_dmg(self.red_team_hp_bar.current_hp -
|
||||
sum([knight.get_current_hp() for knight in self.list_knights_red]))
|
||||
self.blue_team_hp_bar.take_dmg(self.blue_team_hp_bar.current_hp -
|
||||
sum([knight.get_current_hp() for knight in self.list_knights_blue]))
|
||||
self.red_team_hp_bar.update()
|
||||
self.blue_team_hp_bar.update()
|
||||
|
||||
|
||||
|
||||
# texts
|
||||
draw_text('Rycerze: 2', FONT_DARK, self.screen, self.x + 35, self.y + 240, 18)
|
||||
draw_text('Fortece: 1', FONT_DARK, self.screen, self.x + 35, self.y + 270, 18)
|
||||
draw_text('Rycerze: ' + str(len(self.list_knights_blue)), FONT_DARK, self.screen, self.x + 35, self.y + 240, 18) # blue
|
||||
|
||||
draw_text('Rycerze: 4', FONT_DARK, self.screen, self.x + 215, self.y + 240, 18)
|
||||
draw_text('Fortece: 0', FONT_DARK, self.screen, self.x + 215, self.y + 270, 18)
|
||||
draw_text('Rycerze: ' + str(len(self.list_knights_red)), FONT_DARK, self.screen, self.x + 215, self.y + 240, 18)
|
||||
|
||||
# points
|
||||
pygame.draw.rect(self.screen, ORANGE, pygame.Rect(self.x, self.y + 390, 340, 3))
|
||||
draw_text('PUNKTY: 10', FONT_DARK, self.screen, self.x + 35, self.y + 408, 18, True)
|
||||
draw_text('PUNKTY: 10', FONT_DARK, self.screen, self.x + 215, self.y + 408, 18, True)
|
||||
draw_text('PUNKTY: ' + str(self.blue_team_points), FONT_DARK, self.screen, self.x + 35, self.y + 408, 18, True)
|
||||
draw_text('PUNKTY: ' + str(self.red_team_points), FONT_DARK, self.screen, self.x + 215, self.y + 408, 18, True)
|
||||
|
||||
def add_points(self, team, points):
|
||||
if team == "blue":
|
||||
self.blue_team_points += points
|
||||
else:
|
||||
self.red_team_points += points
|
||||
|
Loading…
Reference in New Issue
Block a user