GenericAI_Sweeper/sprites.py

import pygame as pg
import enum
import ctypes
import ast
import time
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.direction = direction
        self.maze = Maze()
        self.moves = ''
        self.my_learning = Learning()
        self.ai_mode = "none"
        #self.decision_tree_learning()

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

    

    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