Exemplo n.º 1
0
class Game(Widget):

    car = ObjectProperty(None)
    ball1 = ObjectProperty(None)
    ball2 = ObjectProperty(None)
    ball3 = ObjectProperty(None)

    def move_car(self, position):
        self.car.center = position
        self.ball1.pos = self.car.sensor1
        self.ball2.pos = self.car.sensor2
        self.ball3.pos = self.car.sensor3

    def rotate_car(self, angle):
        self.car.move(angle)

    def clear_canvas(self):
        global step_size, nrow, ncol
        global sand

        self.serve_car()
        sand = np.zeros((nrow, ncol))
        self.init_start()

    def serve_car(self):
        global step_size, nrow, ncol
        self.car.center = self.center
        self.car.velocity = Vector(1, 0)
        self.car.angle = 0

    def init_start(self):
        global step_size, nrow, ncol
        global sand, lineList
        nrow = 10
        ncol = 10
        if self.width < self.height:
            step_size = self.width
        else:
            step_size = self.height

        step_size = int(step_size / 1.2)
        step_size = int(step_size / ncol)

        init()
        no_obs = 20
        matrix, start_position = random_matrix(nrow, ncol, no_obs)

        for ln in lineList:
            self.canvas.remove(ln)
        lineList = []
        #print(start_position)
        with self.canvas:
            for i in range(nrow):
                for j in range(ncol):
                    wdt = 1
                    if matrix[i][j] != 0:
                        Color(1.0, 0.0, 0.1)
                        wdt = 3
                    else:
                        Color(0.0, 1.0, 0.1, 0.7)
                    scrX, scrY = self.car.grid_to_screen(i, j, nrow, ncol)
                    lineList.append(
                        Line(rectangle=(scrX - step_size / 2,
                                        scrY - step_size / 2, step_size,
                                        step_size),
                             width=wdt))

        sand = matrix.copy()
        matrix = [[]]

        srX, srY = self.car.grid_to_screen(start_position['x'],
                                           start_position['y'], nrow, ncol)

        self.move_car(Vector(srX, srY))
        self.car.move_init()
        print(sand)
        #start_position={'x': self.car.x, 'y': self.car.y}
        start_direction = 0

        # run with dfs
        self.robot = MyRobot(matrix, start_position, start_direction, self.car)
        # robot.log()
        self.sweeper = Sweeper(self.robot)
        self.sweeper.loggable = False
        self.robot.loggable = False

    def update(self, dt):
        global step_size, nrow, ncol
        global move_car_now
        global lineList
        if first_update:
            lineList = []
            self.init_start()

        #if move_car_now == True:
        #self.sweeper.get_move()
        #move_car_now=False
        #print(step_size)
        self.sweeper.get_move()
        self.ball1.pos = self.car.sensor1
        self.ball2.pos = self.car.sensor2
        self.ball3.pos = self.car.sensor3
Exemplo n.º 2
0
class Game(Widget):

    car = ObjectProperty(None)
    ball1 = ObjectProperty(None)
    ball2 = ObjectProperty(None)
    ball3 = ObjectProperty(None)

    def clear_canvas(self):
        global longueur
        global largeur
        self.canvas.clear()
        self.serve_car()
        sand = np.zeros((longueur, largeur))
        start_position = {'x': self.car.x, 'y': self.car.y}
        start_direction = 0  #random.randint(0, 3)

        # run with dfs
        self.robot = MyRobot(sand, start_position, start_direction)
        # robot.log()
        self.sweeper = Sweeper(self.robot)
        self.sweeper.loggable = False
        self.robot.loggable = False

    def serve_car(self):
        global longueur
        global largeur
        self.car.center = self.center
        self.car.velocity = Vector(1, 0)
        self.car.angle = 0

    def update(self, dt):

        global brain
        global last_reward
        global scores
        global last_distance
        global goal_x
        global goal_y
        global longueur
        global largeur
        global last_tm
        global time_elapsed
        global time_max
        global rects

        if first_update:
            longueur = int(self.width)
            largeur = int(self.height)
            longueur = int(longueur / size)
            largeur = int(largeur / size)
            init()
            no_obs = int(longueur * largeur / 5)
            matrix, start_position = random_matrix(longueur, largeur, no_obs)

            sand = matrix
            print(sand)
            start_position = {'x': self.car.x, 'y': self.car.y}
            start_direction = 0  #random.randint(0, 3)

            # run with dfs
            self.robot = MyRobot(sand, start_position, start_direction)
            # robot.log()
            self.sweeper = Sweeper(self.robot)
            self.sweeper.loggable = False
            self.robot.loggable = False

    # print("rotation")
        rotation = self.sweeper.get_move()
        if rotation == -1 or rotation == None:
            #self.car.move(0)
            pass
            #pass #self.car.velocity= Vector(1, 0).rotate(self.car.angle)*0 # Stop the car
        else:
            self.car.move(rotation)
        print(rotation)
        #print(rotation)
        self.ball1.pos = self.car.sensor1
        self.ball2.pos = self.car.sensor2
        self.ball3.pos = self.car.sensor3