Merge pull request 'added points in stats;' (#41) from stats_update into master

Reviewed-on: #41

common/constants.py

@@ -6,7 +6,7 @@ GAME_TITLE = 'WMICraft'
 WINDOW_HEIGHT = 800
 WINDOW_WIDTH = 1360
 FPS_COUNT = 60
-TURN_INTERVAL = 500
+TURN_INTERVAL = 200
 
 GRID_CELL_PADDING = 5
 GRID_CELL_SIZE = 36

learning/dataset_tree_300.csv

@@ -299,4 +299,4 @@ tower_dist;mob1_dist;mob2_dist;opp1_dist;opp2_dist;opp3_dist;opp4_dist;agent_hp;
 29;25;30;19;35;38;33;6;68;5;1;0;5;11;6;mob1
 23;43;41;25;27;26;19;7;12;8;3;4;10;11;9;tower
 7;9;18;31;36;21;16;4;23;8;4;9;8;11;5;tower
-35;21;39;36;36;37;33;10;41;9;4;1;0;7;0;mob1
+35;21;39;36;36;37;33;10;41;9;4;1;0;7;0;mob1

learning/decision_tree.py

@@ -26,7 +26,7 @@ def parse_idx_of_opp_or_monster(s: str) -> int:
 
 class DecisionTree:
     def __init__(self) -> None:
-        data_frame = pd.read_csv('learning/dataset_tree.csv', delimiter=';')
+        data_frame = pd.read_csv('learning/dataset_tree_1000.csv', delimiter=';')
         unlabeled_goals = data_frame['goal']
         self.goals_label_encoder = LabelEncoder()
         self.goals = self.goals_label_encoder.fit_transform(unlabeled_goals)

logic/game.py

@@ -45,6 +45,7 @@ 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

logic/knights_queue.py

@@ -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)

logic/level.py

@@ -31,6 +31,15 @@ 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.map = import_random_map()
         self.setup_base_tiles()
@@ -92,6 +101,112 @@ class Level:
                         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):
         current_knight = self.knights_queue.dequeue_knight()
         knights_list = self.list_knights_red + self.list_knights_blue
@@ -99,14 +214,6 @@ class Level:
         knight_pos_x = current_knight.position[0]
         knight_pos_y = current_knight.position[1]
         positions = []
-        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)
 
         goal_list = self.decision_tree.predict_move(grid=self.map, current_knight=current_knight,
                                                     monsters=self.list_monsters,
@@ -114,6 +221,9 @@ class Level:
                                                     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
 
@@ -126,10 +236,18 @@ class Level:
             return
 
         next_action = action_list.pop(0)
-        for some_knight in knights_list:
-            for some_position in positions:
-                if some_knight.position == some_position:
-                    some_knight.health_bar.take_dmg(1)
+
+        #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.')
@@ -141,7 +259,7 @@ class Level:
             current_knight.step_forward()
             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()
@@ -163,3 +281,6 @@ class Level:
         # update and draw the game
         self.sprites.draw(self.screen)
         self.sprites.update()
+
+
+

models/castle.py

@@ -16,8 +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()

models/knight.py

@@ -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,8 +36,8 @@ 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.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.max_hp, max_hp=self.max_hp, calculate_xy=True, calculate_size=True)

models/monster.py

@@ -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

ui/screens/credits.py

@@ -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)
+

ui/stats.py

@@ -23,6 +23,8 @@ class Stats:
                                          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):
 
@@ -50,12 +52,16 @@ class Stats:
 
         # texts
         draw_text('Rycerze: ' + str(len(self.list_knights_blue)), FONT_DARK, self.screen, self.x + 35, self.y + 240, 18)  # blue
-        draw_text('Fortece: ' + str(len(self.list_knights_red)), FONT_DARK, self.screen, self.x + 35, self.y + 270, 18)  # red
 
-        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