376 lines
13 KiB
Python
376 lines
13 KiB
Python
import pygame as pg
|
|
import enum
|
|
import ctypes
|
|
import ast
|
|
import time
|
|
import copy
|
|
from settings import *
|
|
from maze import *
|
|
from learning import *
|
|
from nn import *
|
|
|
|
|
|
class Player(pg.sprite.Sprite):
|
|
def __init__(self, game, x, y, direction = 'Right'):
|
|
self.groups = game.all_sprites
|
|
pg.sprite.Sprite.__init__(self, self.groups)
|
|
self.game = game
|
|
#self.image = pg.Surface((TILESIZE, TILESIZE))
|
|
self.image = pg.image.load('images/robot3.bmp')
|
|
self.baseImage = pg.image.load('images/robot3.bmp')
|
|
#self.image.fill(YELLOW)
|
|
self.image = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.baseImage = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.rect = self.image.get_rect()
|
|
self.x = x
|
|
self.y = y
|
|
self.resetX = copy.deepcopy(x)
|
|
self.resetY = copy.deepcopy(y)
|
|
self.direction = direction
|
|
self.resetDirection = copy.deepcopy(direction)
|
|
self.maze = Maze()
|
|
self.moves = ''
|
|
self.my_learning = Learning()
|
|
self.ai_mode = "none"
|
|
#self.decision_tree_learning()
|
|
|
|
def reset(self):
|
|
self.x = copy.deepcopy(self.resetX)
|
|
self.y = copy.deepcopy(self.resetY)
|
|
self.direction = copy.deepcopy(self.resetDirection)
|
|
|
|
|
|
def set_direction(self, direction):
|
|
self.direction = direction
|
|
|
|
def move(self, dx=0, dy=0, move = ''):
|
|
if move == Moves.Right.name:
|
|
if self.direction == Direction.Right.name:
|
|
self.direction = Direction.Down.name
|
|
elif self.direction == Direction.Down.name:
|
|
self.direction = Direction.Left.name
|
|
elif self.direction == Direction.Left.name:
|
|
self.direction = Direction.Up.name
|
|
elif self.direction == Direction.Up.name:
|
|
self.direction = Direction.Right.name
|
|
elif move == Moves.Left.name:
|
|
if self.direction == Direction.Right.name:
|
|
self.direction = Direction.Up.name
|
|
elif self.direction == Direction.Down.name:
|
|
self.direction = Direction.Right.name
|
|
elif self.direction == Direction.Left.name:
|
|
self.direction = Direction.Down.name
|
|
elif self.direction == Direction.Up.name:
|
|
self.direction = Direction.Left.name
|
|
elif move == Moves.Forward.name:
|
|
if self.direction == Direction.Right.name:
|
|
if self.check_border(1):
|
|
if not self.collide_with_walls(1):
|
|
if self.collide_with_mines(1):
|
|
#ctypes.windll.user32.MessageBoxW(0, "Mine Ahead!", "Warning", 1)
|
|
print("Mine Ahead!")
|
|
self.x += 1
|
|
else:
|
|
self.x += 1
|
|
|
|
if self.direction == Direction.Up.name:
|
|
if self.check_border(0, -1):
|
|
if not self.collide_with_walls(0, -1):
|
|
if self.collide_with_mines(0, -1):
|
|
#ctypes.windll.user32.MessageBoxW(0, "Mine Ahead!", "Warning", 1)
|
|
print("Mine Ahead!")
|
|
self.y += -1
|
|
else:
|
|
self.y += -1
|
|
|
|
if self.direction == Direction.Down.name:
|
|
if self.check_border(0, 1):
|
|
if not self.collide_with_walls(0, 1):
|
|
if self.collide_with_mines(0, 1):
|
|
#ctypes.windll.user32.MessageBoxW(0, "Mine Ahead!", "Warning", 1)
|
|
print("Mine Ahead!")
|
|
self.y += 1
|
|
else:
|
|
self.y += 1
|
|
|
|
if self.direction == Direction.Left.name:
|
|
if self.check_border(-1):
|
|
if not self.collide_with_walls(-1):
|
|
if self.collide_with_mines(-1):
|
|
#ctypes.windll.user32.MessageBoxW(0, "Mine Ahead!", "Warning", 1)
|
|
print("Mine Ahead!")
|
|
self.x += -1
|
|
else:
|
|
self.x += -1
|
|
print("I move: " + str(self.direction))
|
|
|
|
print("My direction is: " + str(self.direction))
|
|
|
|
if str(self.ai_mode) == "tree":
|
|
self.check_bomb()
|
|
if str(self.ai_mode) == "neural":
|
|
self.check_bomb_neural()
|
|
if str(self.ai_mode) == "off":
|
|
pass
|
|
|
|
|
|
|
|
def set_ai_mode(self, mode):
|
|
self.ai_mode = mode
|
|
|
|
def check_border(self, dx=0, dy=0):
|
|
if (self.x + dx) < 0 or (self.y + dy) < 0 or (self.x + dx) >= MAP_SIZE or (self.y + dy) >= MAP_SIZE :
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
|
|
def collide_with_mines(self, dx=0, dy=0):
|
|
for mine in self.game.mines:
|
|
if mine.x == self.x + dx and mine.y == self.y + dy:
|
|
return True
|
|
return False
|
|
|
|
def collide_with_walls(self, dx=0, dy=0):
|
|
for wall in self.game.walls:
|
|
if wall.x == self.x + dx and wall.y == self.y + dy:
|
|
return True
|
|
return False
|
|
|
|
|
|
"""
|
|
right = 1
|
|
left = -1
|
|
if self.self.moves[n+1] != 'R':
|
|
if self.moves[n+1] == 'U':
|
|
module.insert(n, 'Turn Up')
|
|
if self.moves[n+1] == 'L':
|
|
module.insert(n, 'Turn Left')
|
|
if self.moves[n+1] == 'D':
|
|
module.insert(n, 'Turn Down')
|
|
"""
|
|
|
|
def parse_maze_moves(self):
|
|
self.moves = [char for char in self.maze.moves]
|
|
|
|
|
|
if self.moves[0] != 'R':
|
|
if self.moves[0] == 'D':
|
|
self.moves.insert(0, 'Turn Down')
|
|
if self.moves[0] == 'U':
|
|
self.moves.insert(0, 'Turn Up')
|
|
if self.moves[0] == 'L':
|
|
self.moves.insert(0, 'Turn Left')
|
|
|
|
for n, i in enumerate(self.moves):
|
|
if i == 'R':
|
|
self.moves[n] = 'Right'
|
|
if n != len(self.moves)-1:
|
|
if i != self.moves[n+1]:
|
|
if self.moves[n+1] == 'D':
|
|
self.moves.insert(n+1, 'Turn Down')
|
|
if self.moves[n+1] == 'U':
|
|
self.moves.insert(n+1, 'Turn Up')
|
|
if self.moves[n+1] == 'L':
|
|
self.moves.insert(n+1, 'Turn Left')
|
|
else:
|
|
self.move(dx=-1, direction='Right')
|
|
if i == 'L':
|
|
self.moves[n] = 'Left'
|
|
if n != len(self.moves)-1:
|
|
if i != self.moves[n+1]:
|
|
if self.moves[n+1] == 'D':
|
|
self.moves.insert(n+1, 'Turn Down')
|
|
if self.moves[n+1] == 'U':
|
|
self.moves.insert(n+1, 'Turn Up')
|
|
if self.moves[n+1] == 'R':
|
|
self.moves.insert(n+1, 'Turn Right')
|
|
if i == 'D':
|
|
self.moves[n] = 'Down'
|
|
if n != len(self.moves)-1:
|
|
if i != self.moves[n+1]:
|
|
if self.moves[n+1] == 'R':
|
|
self.moves.insert(n+1, 'Turn Right')
|
|
if self.moves[n+1] == 'U':
|
|
self.moves.insert(n+1, 'Turn Up')
|
|
if self.moves[n+1] == 'L':
|
|
self.moves.insert(n+1, 'Turn Left')
|
|
if i == 'U':
|
|
self.moves[n] = 'Up'
|
|
if n != len(self.moves)-1:
|
|
if i != self.moves[n+1]:
|
|
if self.moves[n+1] == 'D':
|
|
self.moves.insert(n+1, 'Turn Down')
|
|
if self.moves[n+1] == 'R':
|
|
self.moves.insert(n+1, 'Turn Right')
|
|
if self.moves[n+1] == 'L':
|
|
self.moves.insert(n+1, 'Turn Left')
|
|
|
|
print(self.moves)
|
|
|
|
def decision_tree_learning(self):
|
|
self.my_learning.load_data()
|
|
self.my_learning.learn()
|
|
self.my_learning.draw_tree()
|
|
print("new decision tree created")
|
|
print("restart to use saved decision tree")
|
|
#my_learning.predict()
|
|
|
|
|
|
|
|
""" sprawdzenie danych miny """
|
|
def check_bomb(self):
|
|
if self.check_if_on_mine():
|
|
current_mine = self.get_my_mine_object()
|
|
mine_params = current_mine.get_parameters()
|
|
self.my_learning.predict_on_saved_tree(mine_params)
|
|
return
|
|
|
|
def check_bomb_neural(self):
|
|
if self.check_if_on_mine():
|
|
current_mine = self.get_my_mine_object()
|
|
mine_params = current_mine.get_parameters()
|
|
self.call_net_runner()
|
|
return
|
|
|
|
def call_net_runner(self):
|
|
net_runner = NetRunner()
|
|
net_runner.prepare_data()
|
|
|
|
|
|
|
|
|
|
def check_if_on_mine(self):
|
|
for mine in self.game.mines:
|
|
if mine.x == self.x and mine.y == self.y:
|
|
return True
|
|
return False
|
|
|
|
def get_my_mine_object(self):
|
|
if self.check_if_on_mine():
|
|
for mine in self.game.mines:
|
|
if mine.x == self.x and mine.y == self.y:
|
|
return mine
|
|
|
|
|
|
|
|
|
|
def update(self):
|
|
#sleep(0.25)
|
|
self.rect.x = self.x * TILESIZE
|
|
self.rect.y = self.y * TILESIZE
|
|
|
|
|
|
class Direction(enum.Enum):
|
|
Up = 1;
|
|
Left = 2;
|
|
Down = 3;
|
|
Right = 4;
|
|
|
|
class Moves(enum.Enum):
|
|
Left = 1
|
|
Right = 2
|
|
Forward = 3
|
|
|
|
|
|
class Mine(pg.sprite.Sprite):
|
|
def __init__(self, game, x, y):
|
|
self.groups = game.all_sprites, game.mines
|
|
pg.sprite.Sprite.__init__(self, self.groups)
|
|
self.game = game
|
|
#self.image = pg.Surface((TILESIZE, TILESIZE))
|
|
self.image = pg.image.load('images/mine.bmp')
|
|
#self.image.fill(YELLOW)
|
|
self.image = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.rect = self.image.get_rect()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
|
|
def set_parameters(self, glebokosc, rozmiar, masa, moc, szkodliwosc, zabawka, teledysk, stan):
|
|
self.glebokosc = glebokosc
|
|
self.rozmiar = rozmiar
|
|
self.masa = masa
|
|
self.moc = moc
|
|
self.szkodliwosc = szkodliwosc
|
|
self.zabawka = zabawka
|
|
self.teledysk = teledysk
|
|
self.stan = stan
|
|
|
|
def get_parameters(self):
|
|
param_array = [self.glebokosc, self.rozmiar, self.masa, self.moc, self.szkodliwosc, self.zabawka, self.teledysk, self.stan]
|
|
return param_array
|
|
|
|
def update(self):
|
|
self.rect.x = self.x * TILESIZE
|
|
self.rect.y = self.y * TILESIZE
|
|
|
|
|
|
class Bomb(pg.sprite.Sprite):
|
|
def __init__(self, game, x, y):
|
|
self.groups = game.all_sprites, game.mines
|
|
pg.sprite.Sprite.__init__(self, self.groups)
|
|
self.game = game
|
|
#self.image = pg.Surface((TILESIZE, TILESIZE))
|
|
self.image = pg.image.load('images/bomb.bmp')
|
|
#self.image.fill(YELLOW)
|
|
self.image = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.rect = self.image.get_rect()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
def update(self):
|
|
self.rect.x = self.x * TILESIZE
|
|
self.rect.y = self.y * TILESIZE
|
|
|
|
|
|
class Grenade(pg.sprite.Sprite):
|
|
def __init__(self, game, x, y):
|
|
self.groups = game.all_sprites, game.mines
|
|
pg.sprite.Sprite.__init__(self, self.groups)
|
|
self.game = game
|
|
#self.image = pg.Surface((TILESIZE, TILESIZE))
|
|
self.image = pg.image.load('images/grenade.bmp')
|
|
#self.image.fill(YELLOW)
|
|
self.image = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.rect = self.image.get_rect()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
def update(self):
|
|
self.rect.x = self.x * TILESIZE
|
|
self.rect.y = self.y * TILESIZE
|
|
|
|
class Wall(pg.sprite.Sprite):
|
|
def __init__(self, game, x, y):
|
|
self.groups = game.all_sprites, game.walls
|
|
pg.sprite.Sprite.__init__(self, self.groups)
|
|
self.game = game
|
|
#self.image = pg.Surface((TILESIZE, TILESIZE))
|
|
self.image = pg.image.load('images/wall.bmp')
|
|
#self.image.fill(YELLOW)
|
|
self.image = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.rect = self.image.get_rect()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
def update(self):
|
|
self.rect.x = self.x * TILESIZE
|
|
self.rect.y = self.y * TILESIZE
|
|
|
|
class Puddle(pg.sprite.Sprite):
|
|
def __init__(self, game, x, y):
|
|
self.groups = game.all_sprites, game.puddles
|
|
pg.sprite.Sprite.__init__(self, self.groups)
|
|
self.game = game
|
|
self.image = pg.image.load('images/puddle.bmp')
|
|
self.image = pg.transform.scale(self.image, (TILESIZE, TILESIZE))
|
|
self.rect = self.image.get_rect()
|
|
self.x = x
|
|
self.y = y
|
|
|
|
def update(self):
|
|
self.rect.x = self.x * TILESIZE
|
|
self.rect.y = self.y * TILESIZE
|
|
|
|
|