CS-5820-Group-Project/simple_reflex_with_state.py at master · Prestophobia/CS-5820-Group-Project · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import sys
from math import sqrt
from math import pow
from math import degrees
from math import atan

from directions import *
from states import *
from agent import *

class SimpleReflexAgentWithEntireState(Agent):

    DirtyTiles = [] # Part of the state chosen is the agent knows all the dirty tiles
    targetPosition = None

    def __init__(self, startingPos, startingDir, environ):
        super().__init__(startingPos, startingDir, environ)
        self.AgentTypeName = "Simple Reflex Agent with entire State"
        self.GetDirtyTiles()

    def GetDirtyTiles(self):
        self.Log.append("finding all dirty tiles")
        for x in range(self.Environ.Width):
            for y in range(self.Environ.Height):
                if self.Environ.GetTileState((x,y)) == DIRTY:
                    self.DirtyTiles.append((x,y))

    def PrintDirtyTiles(self):
        self.Log.append("printing dirty tiles")
        print(len(self.DirtyTiles))
        for tile in self.DirtyTiles:
            print(tile)

    def GetClosestDirtyTile(self):
        closestTile = None
        closestDistance = sys.maxsize
        for tile in self.DirtyTiles:
            tempDistance = self.CalculateDistanceFromCurrent(tile)
            if closestDistance >= tempDistance:
                closestDistance = tempDistance
                closestTile = tile
        self.Log.append("ClosestDirtyTile=" + str(closestTile))
        return closestTile

    def RemoveFromKnownDirtyTiles(self, toRemove):
        for tile in self.DirtyTiles:
            if tile == toRemove:
                self.DirtyTiles.remove(tile)
                return

    def CalculateDistanceFromCurrent(self, target):
        currentX = self.Position[0]
        currentY = self.Position[1]
        targetX = target[0]
        targetY = target[1]

        # distance between two 2-d points formula
        return sqrt(pow((currentX - targetX),2) + pow((currentY - targetY),2))

    def GetPathTo(self, target):
        if target == None:
            return self.Position
        currentX = self.Position[0]
        currentY = self.Position[1]
        targetX = target[0]
        targetY = target[1]

        return ((targetX - currentX),(targetY - currentY))

    def GetDirection(self, current, target):
        # print("Current:" + str(current))
        # print("Target:" + str(target))
        if current != target:
            if current[0] == target[0]:
                if current[1] > target[1]:
                    direction = NORTH
                else:
                    direction = SOUTH
            elif current[1] == target[1]:
                if current[0] > target[0]:
                    direction = EAST
                else:
                    direction = WEST
            elif current[0] > target[0]: # east
                if current[1] > target[1]:
                    direction = NORTHEAST
                else:
                    direction = SOUTHEAST
            elif current[0] < target[0]: # west
                if current[1] > target[1]:
                    direction = NORTHWEST
                else:
                    direction = SOUTHWEST
            elif current[1] > target[1]: # south
                if current[0] > target[0]:
                    direction = SOUTHEAST
                else:
                    direction = SOUTHWEST
            elif current[1] < target [1]: # north
                if current[0] > target[0]:
                    direction = NORTHEAST
                else:
                    direction = NORTHWEST
            else:
                direction = WEST
        else:
            direction = WEST

        return direction

    def MoveTo(self, target):
        if target == None:
            return

        while self.Position != target:
            self.RotateUntil(self.GetDirection(self.Position, target))
            self.MoveForward()
        return

    def Run(self):
        while self.Environ.CountDirty() > 0:
            self.Log.append("DirtyCount=" + str(self.Environ.CountDirty()))
            self.GetPercept()
            if self.Status == DIRTY:
                self.CleanTile()
                self.RemoveFromKnownDirtyTiles(self.Position)

            self.MoveTo(self.GetClosestDirtyTile())
        return