GenericAI_Sweeper/main.py

import pygame as pg
import sys
import ctypes
from os import path

from matplotlib import pyplot
from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree

from maze import *
from grid import *
from settings import *
from sprites import *
from graphsearch import *
from astar2 import *
from pizza import *
from learning import *



class Game:
    def __init__(self):
        pg.init()
        self.screen = pg.display.set_mode((WIDTH, HEIGHT))
        pg.display.set_caption(TITLE)
        self.clock = pg.time.Clock()
        pg.key.set_repeat(500, 100)
        self.load_data()
        self.wentyl_bezpieczenstwa = 0 
        #ExampleGenerator.generate(ExampleGenerator)

    def load_data(self):
        game_folder = path.dirname(__file__)
        self.map_data = []
        with open(path.join(game_folder, 'main_map.txt'), 'rt') as f:
            for line in f:
                self.map_data.append(line)

    def new(self):
        # initialize all variables and do all the setup for a new game
        #glebokosc rozmiar masa moc szkodliwosc zabawka stan teledysk
        self.all_sprites = pg.sprite.Group()
        self.walls = pg.sprite.Group()
        self.mines = pg.sprite.Group()
        self.puddles = pg.sprite.Group()
        for row, tiles in enumerate(self.map_data):
            for col, tile in enumerate(tiles):
                if tile == '2':
                    Mine(self, col, row)
                    Mine.set_parameters(Mine,18,32,6,7,0,0,0,0)
                if tile == '3':
                    Bomb(self, col, row)
                if tile == '4':
                    Grenade(self, col, row)
                if tile == "#":
                    Wall(self, col, row)
                if tile == 'p':
                    Puddle(self, col, row)
                if tile == '>':
                    self.player = Player(self, col, row, Direction.Right.name)
                if tile == '^':
                    self.player = Player(self, col, row, Direction.Up.name)
                if tile == '<':
                    self.player = Player(self, col, row, Direction.Left.name)
                if tile == 'v':
                    self.player = Player(self, col, row, Direction.Down.name)
        

    def run(self):
        # game loop - set self.playing = False to end the game
        self.playing = True
        while self.playing:
            self.events()
            self.update()
            self.draw()

    def quit(self):
        pg.quit()
        sys.exit()

    def update(self):
        # update portion of the game loop
        self.all_sprites.update()

    def draw_grid(self):
        for x in range(0, WIDTH, TILESIZE):
            pg.draw.line(self.screen, LIGHTGREY, (x, 0), (x, HEIGHT))
        for y in range(0, HEIGHT, TILESIZE):
            pg.draw.line(self.screen, LIGHTGREY, (0, y), (WIDTH, y))

    def draw(self):
        self.screen.fill(BGCOLOR)
        self.draw_grid()
        self.all_sprites.draw(self.screen)
        pg.display.flip()

    def events(self):
        # catch all events here
        
        for event in pg.event.get():
            if event.type == pg.QUIT:
                self.quit()
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_ESCAPE:
                    self.quit()
                if event.key == pg.K_LEFT:
                    self.player.move(dx=0, move='Left')
                if event.key == pg.K_RIGHT:
                    self.player.move(dx=0, move='Right')
                if event.key == pg.K_UP:
                    self.player.move(dy=0, move='Forward')
                if event.key == pg.K_F2 and self.wentyl_bezpieczenstwa == 0:
                    
                    self.player.maze.run()
                    self.player.parse_maze_moves()
                    self.i_like_to_move_it()
                    self.wentyl_bezpieczenstwa = 1
                if event.key == pg.K_F3:
                    pg.event.clear()
                    player_moves = BFS.run()
                    self.graph_move(player_moves)
                    #self.wentyl_bezpieczenstwa = 1
                if event.key == pg.K_F4 and self.wentyl_bezpieczenstwa == 0:
                    pg.event.clear()
                    #print("test1")
                    agent = SweeperAgent()
                    player_moves = SweeperAgent.run(agent)
                    self.graph_move(player_moves)
                    self.wentyl_bezpieczenstwa = 1
                    
                    # Test.run()
                if event.key == pg.K_F5:
                    self.player.decision_tree_learning()
                    #print("lol xD")
                    pg.event.clear()
                if event.key == pg.K_F6:
                    pg.event.clear()
                    #self.wentyl_bezpieczenstwa = 1
                    """X = [[6,15,31,5,0,0,1,0],[6,36,5,8,1,1,1,0],
                         [13,40,29,3,0,0,0,0], [15,25,23,7,0,0,1,1],
                         [17,34,5,5,1,1,0,1], [3,9,28,8,0,0,1,0],
                         [18,38,43,6,1,1,1,1], [3,8,53,4,1,1,1,1],
                         [9,40,47,1,1,0,1,1],[11,23,31,5,0,0,1,1]]
                    Y = [1,5,1,1,4,1,2,2,1,1]
                    clf = tree.DecisionTreeClassifier()
                    clf = clf.fit(X,Y)
                    tree.plot_tree(clf)"""

                    """my_learning = Learning()
                    my_learning.load_data()
                    my_learning.learn()
                    my_learning.draw_tree()
                    my_learning.predict()"""
                    
                    


                

    
    def graph_move(self, moves):
        for i in moves:
            if i == 'Right':
                self.player.move(dx=0, move='Right')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Left':
                self.player.move(dx=0, move='Left')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Forward':
                self.player.move(dx=0, move='Forward')
                self.update()
                self.draw()
                pg.time.delay(250)

    
    def i_like_to_move_it(self):
        for i in self.player.moves:
            if i == 'Right':
                self.player.move(dx=1, direction='Right')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Turn Right':
                self.player.move(0, 0, direction='Right')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Left':
                self.player.move(dx=-1, direction='Left')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Turn Left':
                self.player.move(0, 0, direction='Left')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Down':
                self.player.move(dy=1, direction='Down')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Turn Down':
                self.player.move(0, 0, direction='Down')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Up':
                self.player.move(dy=-1, direction='Up')
                self.update()
                self.draw()
                pg.time.delay(250)
            if i == 'Turn Up':
                self.player.move(0, 0, direction='Up')
                self.update()
                self.draw()
                pg.time.delay(250)


    def show_start_screen(self):
        pass

    def show_go_screen(self):
        pass

# create the game object
g = Game()
g.show_start_screen()

#m = Maze()
#m.run()

while True:
    g.new()
    g.run()
    g.show_go_screen()