def __init__(self):
self.g1 = grid.Grid()
self.g2 = grid.Grid()
self.ships = []
self.hits = []
self.misses = []
self.damage = 0
def __init__(self, map=""):
self.gridMap = [[None for x in range(0, self.MAP_WIDTH)]
for y in range(0, self.MAP_HEIGHT)]
# Need to use IF since there cannot be > 1 constructor
if len(map) > 0:
# Map iterator
i = 0
for n in range(0, self.MAP_HEIGHT):
for m in range(0, self.MAP_WIDTH):
if map[i] == '0':
self.gridMap[n][m] = Grid(n, m, GridState.UNEXPLORED)
elif map[i] == '1':
self.gridMap[n][m] = Grid(
n, m, GridState.EXPLORED_NO_OBSTACLE)
elif map[i] == '2':
self.gridMap[n][m] = Grid(
n, m, GridState.EXPLORED_WITH_OBSTACLE)
i += 1
else:
for n in range(0, self.MAP_HEIGHT):
for m in range(0, self.MAP_WIDTH):
self.gridMap[n][m] = Grid(n, m)
# Determine where the START and END zone are
for i in range(0, 3):
for j in range(0, 3):
self.gridMap[i][j].setGridState(GridState.START_ZONE)
self.gridMap[self.MAP_HEIGHT - i - 1][self.MAP_WIDTH - j -
1].setGridState(
GridState.END_ZONE)
def main():
# One of the 2 dimension of the window. (Window must be a square)
square_size = int(input('Insert one dimension of the square: '))
# Window settings
win = GraphWin('Sorter', square_size, square_size)
win.setBackground('black')
# Text settings
txt = Text(Point((square_size / 2) + (square_size / 4), 20), "swap=0")
txt.setTextColor('white')
txt.draw(win)
txt_for_pause = Text(Point(square_size / 2, square_size / 2),
'Click on the screen to start')
txt_for_pause.setTextColor('white')
# Grid settings
grid = Grid(square_size)
grid.shuffle()
# Draws all the point on the canvas
draw_points(win, grid.pixel_grid)
# Draws a text befor starting the sort
txt_for_pause.draw(win)
win.getMouse()
txt_for_pause.undraw()
# Starts the bubble sorting
bubble_sort(win, grid, txt)
# Wait for user input
win.getMouse()
win.close()
def reformGrid(self, arr):
"""
Ants transmit the following data structure
Integer specifying the length of foodLocSet
Integer specifying the length of the unexploredLocSet
A 1-dimensional array and the length of the rows
and returns a 2-dimensional array.
Assumes that there are an equal number of rows and cols
"""
offset1, offset2, offset3, offset4 = arr[0], arr[1], arr[2], arr[3]
externalUnexploredLocSet = arr[offset1:offset2]
externalFoodLocSet = arr[offset2:offset3]
externalExhaustedFoodLoc = arr[offset3:offset4]
externalMap = arr[offset4:]
## internal maps are square. the square root of the array
## gives us the length of the rows
N = int(math.sqrt(len(externalMap)))
output = Grid(N,N)
for row in xrange(N):
for col in xrange(N):
output.setAt(row, col, externalMap[row*N + col])
return (externalUnexploredLocSet, externalFoodLocSet, externalExhaustedFoodLoc, output)
def setGrids(self, number):
self.grids = []
for i in range(number - 1):
if i % 2 == 0:
grid = Grid.Grid(self.screen,
position=(50 + 100 * i,
random.randint(280, 400)),
scale=0.4)
else:
grid = Grid.Grid(self.screen,
position=(50 + 100 * i,
random.randint(80, 150)),
scale=0.4)
if random.uniform(0, 1) >= 0.3:
grid.setTrap(True)
self.grids.append(grid)
grid = Grid.Grid(self.screen,
image="gridFlag.png",
image2="gridFlag2.png",
position=(50 + 100 * (i + 1), random.randint(80,
150)),
scale=0.4)
if random.uniform(0, 1) >= 0.7:
grid.setTrap(True)
self.grids.append(grid)
def __init__(self):
self.grid = Grid(16, 30, 0.2)
# self.grid.generateSpecificGrid()
self.grid.generateGrid()
self.grid.markMineNumber()
self.totalNumOfMine = self.grid.numOfMine
self.currentNumOfMine = self.totalNumOfMine
def __init__(self, window):
'''
This method is called when the scene is created
Create and/or load any assets (images, buttons, sounds)
that you need for this scene
:param window:
'''
# Save window in instance variable
self.window = window
# 4 - Load assets: image(s), sounds, etc.
self.oGrid = Grid(window)
self.oPlayer = Player(window)
self.oBackground = pygwidgets.Image(window, (0, 0), 'images/background.jpg')
self.oLevelDisplay = pygwidgets.DisplayText(window, (20, 15), '', fontSize=28)
self.oLivesDisplay = pygwidgets.DisplayText(window, (120, 15), '', fontSize=28)
self.oScoreDisplay = pygwidgets.DisplayText(window, (220, 15), '', fontSize=28)
self.oBonusDisplay = pygwidgets.DisplayText(window, (350, 15), '', fontSize=28, textColor=(0, 153, 0))
self.dingSound = pygame.mixer.Sound('sounds/ding.wav')
self.winSound = pygame.mixer.Sound('sounds/win.wav')
self.upSound = pygame.mixer.Sound('sounds/plus.wav')
self.downSound = pygame.mixer.Sound('sounds/minus.wav')
self.bonusSound = pygame.mixer.Sound('sounds/bonus.wav')
self.splatSound = pygame.mixer.Sound('sounds/splat.wav')
self.loseSound = pygame.mixer.Sound('sounds/lose.wav')
self.state = ScenePlay.STATE_PLAYING
self.oTimer = pyghelpers.Timer(.75, callBack=self.startNextRound) # wait 3/5 sec between rounds
self.reset()
def reformGrid(self, arr):
"""
Ants transmit the following data structure
Integer specifying the length of foodLocSet
Integer specifying the length of the unexploredLocSet
A 1-dimensional array and the length of the rows
and returns a 2-dimensional array.
Assumes that there are an equal number of rows and cols
"""
offset1, offset2, offset3, offset4 = arr[0], arr[1], arr[2], arr[3]
externalUnexploredLocSet = arr[offset1:offset2]
externalFoodLocSet = arr[offset2:offset3]
externalExhaustedFoodLoc = arr[offset3:offset4]
externalMap = arr[offset4:]
## internal maps are square. the square root of the array
## gives us the length of the rows
N = int(math.sqrt(len(externalMap)))
output = Grid(N, N)
for row in xrange(N):
for col in xrange(N):
output.setAt(row, col, externalMap[row * N + col])
return (externalUnexploredLocSet, externalFoodLocSet,
externalExhaustedFoodLoc, output)
def test_generators(self):
m = 5
n = 8
self.assertEqual(len(list(Grid.diagonal_generator(n))), n**2)
self.assertEqual(len(list(Grid.matrix2d_generator(m, n))), m * n)
def test_addData_time(self):
#检查addData后若time小于之前的更新时间，是否会抛出异常
g=Grid()
g._Grid__time_update=1000
with self.assertRaisesRegex(ValueError,"time_update"):
raw=HelperForTest.randomLegalRawData()
g.addData(raw,500)
def testSynthetic():
'''Test against a synthetic set of pedestrians'''
SIZE = 10.0
# define the domain
minCorner = Vector2( -SIZE / 2.0, -SIZE / 2.0 )
domainSize = Vector2( SIZE, SIZE )
RES = int( SIZE / CELL_SIZE )
resolution = Vector2( RES, RES )
# define the signal ( a single point, moving from the origin to the corner
traj, STEP_COUNT = syntheticPedestrians( SIZE )
print "Maximum kernel value:", kernel.data.max()
print "Kernel sum: ", kernel.data.sum()
grids = []
pedDomain = Grid.RectDomain( minCorner, domainSize )
sig = Signals.DiracSignal( pedDomain )
for i in xrange( STEP_COUNT ):
sig.setData( traj[:, :, i] )
grid = Grid.DataGrid( minCorner, domainSize, resolution )
kernel.convolve( sig, grid )
## grid.cells /= ( CELL_SIZE * CELL_SIZE )
grids.append( grid )
visGrids( grids )
def test_walk(self):
for grid in generate_test_grids():
# iterate points
for x in range(grid.xmax):
for y in range(grid.ymax):
num = 0
for point in [
grid.above(Grid.Point(x, y)),
grid.below(Grid.Point(x, y)),
grid.right(Grid.Point(x, y)),
grid.left(Grid.Point(x, y))
]:
if point is not None:
if point.status is not '0':
num += 1
if x == 0 and y == 0:
self.assertEqual(len(grid.walk(Grid.Point(x, y))), num,
"FAIL on minimum corner")
elif x == grid.xmax - 1 and y == grid.ymax - 1:
self.assertEqual(len(grid.walk(Grid.Point(x, y))), num,
"FAIL on maximum corner")
elif x == 0 or y == 0:
self.assertEqual(len(grid.walk(Grid.Point(x, y))), num,
"FAIL on minimum edge")
elif x == grid.xmax - 1 or y == grid.ymax - 1:
self.assertEqual(len(grid.walk(Grid.Point(x, y))), num,
"FAIL on maximum edge")
else:
self.assertEqual(len(grid.walk(Grid.Point(x, y))), num,
"FAIL internal point")
# try point outside range
x = 2 * grid.xmax
y = 2 * grid.ymax
self.assertEqual(len(grid.walk(Grid.Point(x, y))), 0,
"FAIL external point")
def getGrids(self) : self.__grids = [] nbRows_l = self.__worksheet.nrows - 1 nbCols_l = self.__worksheet.ncols - 1 currRow_l = -1 # start at first line while currRow_l < nbRows_l: grid_l = Grid() currRow_l += 1 row_l = self.__worksheet.row(currRow_l) #print 'Row:', currRow_l if self.__worksheet.cell_type(currRow_l, 0) != 0 : # not emty cell currCol_l = -1 # first col while currCol_l < nbCols_l: currCol_l += 1 # Cell Types: 0=Empty, 1=Text, 2=Number, 3=Date, 4=Boolean, 5=Error, 6=Blank cellType_l = self.__worksheet.cell_type(currRow_l, currCol_l) cellValue_l = self.__worksheet.cell_value(currRow_l, currCol_l) #print ' ', cellType_l, ':', cellValue_l if currCol_l == 0 : grid_l.setBet(cellValue_l) else : grid_l.setNextCell(cellValue_l, cellType_l) self.__grids.append(copy.deepcopy(grid_l)) else : nbRows_l = currRow_l return self.__grids
def main():
# CHANGE THE Constants.TO_RUN VARIABLE TO CHANGE THE ALGORITHM BEING RAN. OPTIONS:
# BFS
# DIJKSTRA
# ASTAR
algorithmToRun = Constants.TO_RUN
pygame.init()
SCREEN = pygame.display.set_mode(Constants.SCREEN)
SCREEN.fill(Constants.WHITE)
grid = Grid(Constants.SCREEN_WIDTH_AND_HEIGHT, 10)
draw = Draw(SCREEN, grid.get_grid(), grid.get_room_per_node())
draw.draw_grid()
pygame.display.flip()
run = Run(grid, draw)
if algorithmToRun == Constants.BFS:
run.run_bfs()
elif algorithmToRun == Constants.DIJKSTRA:
run.run_dijkstra()
elif algorithmToRun == Constants.ASTAR:
run.run_astar()
else:
run.run_bfs()
def __init__(self, width, height, *board):
self.__board = Grid(width, height, ConwaysLogic.TRAITS)
self.__width = width
self.__height = height
if board:
for i in range(0, width):
for j in range(0, height):
self.__board.setValue(i, j, "Value", board[i][j])
def __init__(self, name, species="human", score=0):
self.remaining_shots = {}
self.species = species
self.name = name
self.score = score
self.grid = Grid(self.species, self.name)
self.eliminated = False
self.occupied_spaces = {}
def set_grid(self):
if(len(self.args_grid)!=0):
if(self.args_grid[2]==1):
temp=Grid.get_simple_grid(self.args_grid[0],self.args_grid[1])
self.grid=temp
if (self.args_grid[2] == 2):
temp = Grid.get_powerlaw_grid(self.args_grid[0], self.args_grid[1],self.args_grid[3],)
self.grid = temp
def test_addData_timeUpdate(self):
g = Grid()
t=1
rawData=HelperForTest.randomLegalRawData()
for i in range(1,50):
t+=random.randint(1,500)
g.addData(rawData,t)
self.assertEqual(g._Grid__time_update,t)
def __init__(self, width, height, numMines):
self.__width = width
self.__height = height
if numMines > width * height - MineSweeperLogic.NUM_EMPTY:
self.__numMines = width * height - MineSweeperLogic.NUM_EMPTY
else:
self.__numMines = numMines
self.__board = Grid(width, height, MineSweeperLogic.TRAITS)
def test_size(self):
#case1:返回正确的size
cluster=Cluster(1)
self.assertEqual(len(cluster._Cluster__grid_dic),cluster.size())
for i in range(1,10):
grid=Grid()
grid._Grid__key=i
cluster.addGrid(grid)
self.assertEqual(len(cluster._Cluster__grid_dic), cluster.size())
def test_isGridExistWithKey(self):
# case1:存在返回True
cluster=Cluster(1)
self.assertFalse(cluster.isGridExistWithKey(1))
# case2：不存在返回false
grid=Grid()
grid._Grid__key=1
cluster.addGrid(grid)
self.assertTrue(cluster.isGridExistWithKey(1))
def test_key(self):
# TODO:制造100个随机的合法rawData，测key（）函数能否正确返回该key值
for i in range(1, 100 + 1):
rawData = HelperForTest.randomLegalRawData()
right_key = Helper().getKeyFromRawData(rawData)
g = Grid()
g.addData(rawData, random.randint(1,10000))
totest_key =g.key()
self.assertEqual(right_key,totest_key)
def test_densityThreshold(self):
last_time = random.randint(1, 10000)
cur_time=last_time+random.randint(1,10000)
value=Helper().Cl*(1-Helper().lamb**(cur_time-last_time+1))/(Helper().N*(1-Helper().lamb))
g=Grid()
g._Grid__time_update=last_time
self.assertEqual(value,g.densityThreshold(cur_time))
def test_addData_key(self):
#TODO：add之后检查key是否正确，检查错误的rawData抛出异常，检查当前更新时间是否正确、想办法测试change，测试TODELETE
g=Grid()
rawData=HelperForTest.randomLegalRawData()
correct_key=Helper.getKeyFromRawData(rawData)
g.addData(rawData,1)
self.assertEqual(correct_key,g.key())
self.assertEqual(1,g._Grid__time_update)
def _move(self):
debug("MOVE");
pos = self._one_ahead();
if Grid.get_pos(pos) == Grid.states.EMPTY:
# Set where we were to empty
Grid.set_pos(self._pos, Grid.states.EMPTY)
# Set new position to filled
self._pos = pos
Grid.set_pos(pos, self)
def _move(self):
debug("MOVE")
pos = self._one_ahead()
if Grid.get_pos(pos) == Grid.states.EMPTY:
# Set where we were to empty
Grid.set_pos(self._pos, Grid.states.EMPTY)
# Set new position to filled
self._pos = pos
Grid.set_pos(pos, self)
def addNewData(self, rawData, time):
logging.debug("Pw:" + str(rawData.PW) + " RF:" + str(rawData.RF) +
" DOA:" + str(rawData.DOA) + " time:" + str(time))
key = Helper().getKeyFromRawData(rawData)
if not key in self.__grid_list:
grid_object = Grid()
grid_object.addData(rawData, time)
self.__grid_list[key] = grid_object
else:
self.__grid_list[key].addData(rawData, time)
def visualize(self, states):
clock = pygame.time.Clock()
for i in range(len(states)):
#print (states[i][1].topLeftXBlock, states[i][1].topLeftYBlock)
grid = Grid.Grid(self.gridWidth, self.gridHeight)
grid = Grid.states_to_grid(states[i], grid)
self.drawGrid(self.screen, grid, 100, 100, 20, 1, states[i][1])
pygame.display.update()
clock.tick(120)
def __init__(self, *args, **kwargs):
super(MyWindow, self).__init__(*args, **kwargs)
#this clear thing affect the background color
#comment it out to get a black background
glClearColor(1, 1.0, 1.0, 1)
self.fps_display = FPSDisplay(self)
self.car = CarSprite()
self.key_handler = key.KeyStateHandler()
self.testTrack = Track([40, 60, 1200, 600], [240, 260, 800, 200])
self.testGrid = Grid(40, 60, 1200, 600, 50)
def test_isGridExist(self):
#case1:存在返回False
cluster=Cluster(1)
grid=Grid()
grid._Grid__key=342
self.assertFalse(cluster.isGridExist(grid))
#case2：不存在返回True
cluster.addGrid(grid)
self.assertTrue(cluster.isGridExist(grid))
def main(size, colors, max_iteration):
grid = Grid(size)
X = []
Y = []
iteration = 0
while iteration < max_iteration :
grid.perform_next_step(colors)
mapped_states = np.array(grid.get_states_colors())
plt.figure(figsize=(10, 10))
start = time.time()
for color in colors:
if iteration is not 0:
grid.reload_grid()
for i in range(grid.get_grid_size()):
for j in range(grid.get_grid_size()):
if mapped_states[i][j] == color:
X = np.insert(X, len(X),i)
Y = np.insert(Y, len(Y),j)
plt.scatter(X, Y, s=1, marker = 's', c = color)
X = []
Y = []
end = time.time()
print('Time of performing next iteration: ' + str(end - start))
plt.axis([-1, size, -1, size])
plt.title('Iteration: ' + str(iteration))
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
iteration += 1
def test_getGrid(self):
#case1:key不存在，抛出异常
cluster=Cluster(1)
with self.assertRaises(KeyError):
cluster.getGrid(1)
#case2：grid存在得到对应的Grid
grid=Grid()
cluster.addGrid(grid)
g=cluster.getGrid(grid.key())
self.assertEqual(grid.key(),g.key())
def test_getAllGrids(self):
#case1：返回本Cluster的所有Grids
cluster=Cluster(1)
grid_dic=cluster.getAllGrids()
self.assertEqual(len(grid_dic),len(cluster._Cluster__grid_dic))
for i in range(1,10):
grid=Grid()
grid._Grid__key=i
cluster.addGrid(grid)
grid_dic = cluster.getAllGrids()
self.assertEqual(len(grid_dic), len(cluster._Cluster__grid_dic))
def __init__(self, pos, facing, team):
'''
Constructor takes a starting pc and a reference to code array.
'''
self.team = team
self._pc = team.bugCode[0]
self._code = team.bugCode
self._stack = []
self._pos = pos
self._direction = facing
# Indicate where we've placed the bug is taken
Grid.set_pos(pos, self)
def _check_cond(self, test):
what_is_next = Grid.get_pos(self._one_ahead())
next_bug = self._next_is_bug()
if test == Constants.codes.JUMP_IF_NOT_NEXT_IS_EMPTY and \
what_is_next != Grid.states.EMPTY:
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_NOT_EMPTY and \
what_is_next == Grid.states.EMPTY:
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_ENEMY and \
(not next_bug or next_bug.team.id == self.team.id):
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_NOT_ENEMY and \
(next_bug and next_bug.team.id != self.team.id):
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_FRIEND and \
(not next_bug or next_bug.team.id != self.team.id):
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_NOT_FRIEND and \
(next_bug and next_bug.team.id == self.team.id):
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_WALL and \
what_is_next != Grid.states.WALL:
return True
elif test == Constants.codes.JUMP_IF_NOT_NEXT_IS_NOT_WALL and \
what_is_next == Grid.states.WALL:
return True
elif test == Constants.codes.JUMP_IF_NOT_RANDOM and \
randint(0, 1):
return True
else: # JUMP IF NOT TRUE
return False
def populate(self):
'''
Creates the bug objects and corresponding canvas graphics.
'''
for team in range(len(teams)):
for i in range(teams[team].numBugs):
x = randint(0,19)
y = randint(0,19)
while Grid.get_pos([x,y]) != Grid.states.EMPTY:
x = randint(0,19)
y = randint(0,19)
bug = Bug([x,y], randint(0,3), teams[team])
self.buglist.append(bug)
self.bugimages.append(self.canvas.create_image(bug._pos[0]*20+14,bug._pos[1]*20+14, \
image=self.bugdict["bug"+str(team+1)+str(bug._direction)]))
# Set up graphics for bug statistics in the right panel
self.canvas.create_rectangle(415, team * 70 + 2, 595, team * 70 + 64, \
fill="#fafafa", outline="#ddd")
self.teamLabels.append(self.canvas.create_text(420, team * 70 + 6, text="Team " + str(team+1), anchor=NW, font=("Helvetica", "13"), fill="#444"))
self.teamCurrentLabels.append(self.canvas.create_text(420, team * 70 + 44, text="Current: " + str(teams[team].numBugs), anchor=NW, fill="#444"))
self.teamMinLabels.append(self.canvas.create_text(495, team * 70 + 44, text="Min: " + str(teams[team].minBugs), anchor=NW, fill="#444"))
self.teamMaxLabels.append(self.canvas.create_text(550, team * 70 + 44, text="Max: " + str(teams[team].maxBugs), anchor=NW, fill="#444"))
self.teamGraphs.append(self.canvas.create_rectangle(415, \
team * 70 + 27, 420 + 167 * teams[team].percent(), \
team * 70 + 42, fill=colors[team], outline=borders[team]))
def testAlgo(model, init=0):
i = 0
if init == 0:
state = Grid.initGrid()
elif init == 1:
state = Grid.initGridPlayer()
elif init == 2:
state = Grid.initGridRand()
print("Initial State:")
print(Grid.dispGrid(state))
status = 1
# while game still in progress
while (status == 1):
qval = model.predict(state.reshape(1, 64), batch_size=1)
action = (np.argmax(qval)) # take action with highest Q-value
print('Move #: %s; Taking action: %s' % (i, action))
state = Grid.makeMove(state, action)
print(Grid.dispGrid(state))
reward = Grid.getReward(state)
if reward != -1:
status = 0
print("Reward: %s" % (reward,))
i += 1 # If we're taking more than 10 actions, just stop, we probably can't win this game
if i > 10:
print("Game lost; too many moves.")
break
def _next_is_bug(self):
nxt = Grid.get_pos(self._one_ahead())
if nxt != Grid.states.EMPTY and \
nxt != Grid.states.WALL:
return nxt
else:
# the next position is either a wall or empty
return 0
def __init__(self):
self.grid = Grid(gridWidth, gridHeight)
for i in range(numBots):
self.age = 0.0
bot = Bot()
x = random.randint(0, gridWidth-1)
y = random.randint(0, gridWidth-1)
self.grid.getNode(x, y).add(bot)
self.createCode()
self.stepCount = 0
def rotated2geo(lon, lat, pole_latitude, pole_longitude):
'''
Use function from PyRemo to convert from rotated to geographical coordinates.
pole_latitude - latitude of rotated north pole
pole_longitude - longitude of rotated north pole
'''
grid_lon, grid_lat = gr.rotated_grid_transform(lon, lat, pole_latitude,pole_longitude)
return grid_lon, grid_lat
def main():
"""
The main core of the program.
"""
global time
global MAX_ITER
global output_dt
# ==========================================================================
# Initialize
# - Returns a dictionary of dictionaries, which are the parameters from the
# configuration file (by section) and from the command line (listed as
# section 'CommandLine')
params = init()
# ==========================================================================
# Evolution loop
prev_write = -1
for n_iter in xrange(MAX_ITER):
# Exceeded maximum time
if time >= tmax:
break
# Unexpected exit? (e.g. like "touch .dump_restart")
# TODO
# Write output
do_write = False
if output_dt > 0:
curr_write = int(math.floor(time / output_dt))
if curr_write > prev_write:
do_write = True
prev_write = curr_write
if do_write: # to allow for a condition based on step number
Grid.write_data(n_iter)
# Boundary condition fill
Grid.fill_boundary_conditions()
# Compute step size
dt = compute_time_step()
# Evolve a single step
Hydro.one_step(dt)
# Update time
time = time + dt
# End evolution loop
# ==========================================================================
# Finalize
# Write final output
Grid.write_data(n_iter+1)
finalize()
def lancer_niveau():
"""Launch a level"""
global ig
global grid
global Secret_grid
Nom = my_listbox.get(my_listbox.curselection())
for widget in fenetre.winfo_children():
widget.destroy()
Secret_grid = Grid()
Secret_grid.Load(Nom)
grid = Grid(Secret_grid.getLargeur(),Secret_grid.getHauteur())
ig = Game(Secret_grid, fenetre)
ig.Zone_dessin.bind("<Button-1>",pointerB1)
ig.Zone_dessin.bind("<Button-3>",pointerB3)
ig.Zone_dessin.bind("<B1-Motion>",slideB1)
ig.Zone_dessin.bind("<B3-Motion>",slideB3)
ig.Bouton_Effacer.config(command=effacer)
ig.Bouton_Retour.config(command=retour)
def parseInitialConditions(self, msg):
'''
The first thing the Server will do when the game is signaled to begin is to send
the initial conditions so that each client can set up, getting info about which player
ID its been assigned, how large the grid is, and where the bases are for each player on
the grid.
'''
m = re.match("([0-9]*)\.([0-9]*)\.([0-9]*)\.([0-9]*)\.([0-9]*)\.([0-9]*)\.([0-9]*)\.([0-9]*)", msg)
if m and int(m.group(1)) == GAME_START_CODE:
# So the client knows which player it's displaying information for
playerID = int(m.group(2))
self.playerID = playerID
numRows = int(m.group(3))
numCols = int(m.group(4))
aBaseRow = int(m.group(5))
aBaseCol = int(m.group(6))
bBaseRow = int(m.group(7))
bBaseCol = int(m.group(8))
# The player always starts off in the middle of his base
myPlayer = False
enemyPlayer = False
i = 1
while i < 3:
playerRow = 0
playerCol = 0
if i == 1:
playerRow = aBaseRow + int(math.ceil(BASE_SIZE / 2))
playerCol = aBaseCol + int(math.ceil(BASE_SIZE / 2))
else:
playerRow = bBaseRow + int(math.ceil(BASE_SIZE / 2))
playerCol = bBaseCol + int(math.ceil(BASE_SIZE / 2))
self.players.append(PlayerSprite(i, playerRow, playerCol))
if i == self.playerID:
myPlayer = self.players[i-1]
else:
enemyPlayer = self.players[i-1]
i+= 1
self.grid = Grid(numRows, numCols)
self.grid.addBase(aBaseRow, aBaseCol, A_BASE_UNIT)
self.grid.addBase(bBaseRow, bBaseCol, B_BASE_UNIT)
self.gameStarted = True
self.viewport = Viewport(self.grid, myPlayer, enemyPlayer)
else:
print "invalid initial conditions"
def __init__(self,inputPrintActions):
"""
Ants are initialized with a 20x20 internal map. All tiles (except the
starting tile) on the internal map are initially set to -100 which
represents unexplored tiles.
The starting position of the ant is assumed to be (row, col)
(9,9), the center of the internal map.
Ants are initialized with zero food.
Ants are intialzied with no route plan.
The internal representation for ants is as follows:
-100: unknown tile
-101: travelable tile
-102: untravelable tile
-103: home tile
0-127: food
"""
self._foodKnown = False
self._hasFood = False
self._newFoodFound = False
self._gridLen = 20
self._receiveMap = False
self._routePlan = []
self._routePlanType = "UNKNOWN"
self._memo = {}
self._row = 9
self._col = 9
self._homeRow = 9
self._homeCol = 9
self._foodLoc = (0,0)
self._unexploredLoc = (0,0)
self._foodLocSet = set()
self._unexploredLocSet = set()
self._exhaustedFoodLocSet = set()
self._dirs = dict([("NORTH",(-1,0)),("EAST",(0,1)),("SOUTH",(1,0)),("WEST",(0,-1))])
self._nReceives = 0
self._printActions = inputPrintActions
## create a 2-dimensional grid to represent the world
## for the ant
self._internalMap = Grid(self._gridLen, self._gridLen, -100)
self._internalMap.setAt(self._homeRow, self._homeCol, -103) ##103 represents the home tile
def test_1(): allcells=[] x = 10 y = 10 g = Grid.grid(10,10) print g for i in range(0,y): column = [] for j in range(0,x): column.append(Cell.cell((i,j))) allcells.append(column) c = Cell.cell((0,0)) c.getNeighbours()
def __init__(self, playerHandlers, numRows, numCols, server):
self.timestep = 0
self.changes = ""
self.handlersReady = []
self.commands = []
self.bullets = []
self.nextBulletID = 3
self.server = server
self.gameAlreadyOver = False
self.grid = Grid(numRows, numCols)
aBaseRow, aBaseCol = self.grid.createRandomBasePosition()
bBaseRow, bBaseCol = self.grid.createRandomBasePosition()
self.grid.addBase(aBaseRow, aBaseCol, A_BASE_UNIT)
self.grid.addBase(bBaseRow, bBaseCol, B_BASE_UNIT)
self.playerHandlers = playerHandlers
self.createPlayers(aBaseRow, aBaseCol, bBaseRow, bBaseCol)
self.sendInitialGameConditions()
def __init__(self, **kwargs):
super(Knot_Display, self).__init__(**kwargs)
self.t = 0.0
self.orientation = Quat(1, Vec3(0,0,0))
self.zoom = 1.0
self.grid = Grid(100, 100)
self.program = ShaderProgram(
FragmentShader('''#version 130
uniform float pi = 3.14159;
varying vec2 uv;
//vec4 torus_normal(float v15, float v16) { return vec4((-6.28318520000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * pow(((39.4784162574990 * pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v16)), 2)) + (-39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2))), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v15)) * cos((6.28318520000000 * v16))), (-6.28318520000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * pow(((39.4784162574990 * pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v16)), 2)) + (-39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2))), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v16)) * sin((6.28318520000000 * v15))), (pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (-12.5663704000000 + (6.28318520000000 * cos((6.28318520000000 * v16)))) * sin((6.28318520000000 * v16))), 1.0); }
//vec4 torus_normal(float v15, float v16) { return vec4((pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (12.5663704000000 + (-6.28318520000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v15)) * cos((6.28318520000000 * v16))), (pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (12.5663704000000 + (-6.28318520000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v16)) * sin((6.28318520000000 * v15))), (pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (-12.5663704000000 + (6.28318520000000 * cos((6.28318520000000 * v16)))) * sin((6.28318520000000 * v16))), 1.0); }
vec4 torus_normal(float v15, float v16) { return vec4((-1.00000000000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v15)) * cos((6.28318520000000 * v16))), (-1.00000000000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v16)) * sin((6.28318520000000 * v15))), (1.00000000000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * sin((6.28318520000000 * v16))), 1.0); }
float tf(float f) { return 0.5*sin(4*pi*f) + 0.5; }
out vec4 outputColor; void main() {
/*
outputColor = gl_FrontFacing ?
vec4(tf(uv.x), tf(uv.y), 0, 1) :
vec4(1, 1 - tf(uv.x), 1 - tf(uv.y), 1);
*/
outputColor = vec4(0.8, 0.8, 0.8, 1);
vec4 n = normalize( torus_normal(uv.x, uv.y) );
float lambert = max( dot(vec4(0.7, 0, 0.7, 0), n), 0);
outputColor *= (lambert + 0.2);
}'''),
VertexShader('''#version 130
uniform float pi = 3.14159;
/* layout(location = 0) */ in vec2 param;
varying vec2 uv;
vec4 torus(float v25, float v26) { return vec4(((2.00000000000000 * cos((6.28318520000000 * v25))) + (-1.00000000000000 * cos((6.28318520000000 * v25)) * cos((6.28318520000000 * v26)))), ((2.00000000000000 * sin((6.28318520000000 * v25))) + (-1.00000000000000 * cos((6.28318520000000 * v26)) * sin((6.28318520000000 * v25)))), (1.00000000000000 * sin((6.28318520000000 * v26))), 1.0); }
//vec4 knot(float v15, float v16) { return vec4(((-1.00000000000000 * cos((18.8495556000000 * v15)) * cos((12.5663704000000 * v15))) + (2.00000000000000 * cos((12.5663704000000 * v15)))), ((2.00000000000000 * sin((12.5663704000000 * v15))) + (-1.00000000000000 * cos((18.8495556000000 * v15)) * sin((12.5663704000000 * v15)))), (1.00000000000000 * sin((18.8495556000000 * v15))), 1.0); }
void main() {
vec4 p = torus(param.x, param.y);
//vec4 p = knot(param.x, param.y);
//vec4 p = vec4(param.x, param.y, 0, 1);
uv = param.xy;
gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * p;
}''')
)
# This is for VS code only. import vsEnvironSetup vsEnvironSetup.setVariables() import Grid # The number of passes to go through the grid passCount = 1 Grid.runGrid(passCount, filename='lists/binaries3.dat')
def finalize(): Grid.finalize() Hydro.finalize()
class Knot_Display(pyglet.window.Window):
def __init__(self, **kwargs):
super(Knot_Display, self).__init__(**kwargs)
self.t = 0.0
self.orientation = Quat(1, Vec3(0,0,0))
self.zoom = 1.0
self.grid = Grid(100, 100)
self.program = ShaderProgram(
FragmentShader('''#version 130
uniform float pi = 3.14159;
varying vec2 uv;
//vec4 torus_normal(float v15, float v16) { return vec4((-6.28318520000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * pow(((39.4784162574990 * pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v16)), 2)) + (-39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2))), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v15)) * cos((6.28318520000000 * v16))), (-6.28318520000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * pow(((39.4784162574990 * pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2)) + (39.4784162574990 * pow(cos((6.28318520000000 * v16)), 2)) + (-39.4784162574990 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2))), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v16)) * sin((6.28318520000000 * v15))), (pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (-12.5663704000000 + (6.28318520000000 * cos((6.28318520000000 * v16)))) * sin((6.28318520000000 * v16))), 1.0); }
//vec4 torus_normal(float v15, float v16) { return vec4((pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (12.5663704000000 + (-6.28318520000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v15)) * cos((6.28318520000000 * v16))), (pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (12.5663704000000 + (-6.28318520000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v16)) * sin((6.28318520000000 * v15))), (pow((197.392081287495 + (-39.4784162574990 * pow(sin((6.28318520000000 * v16)), 2)) + (-157.913665029996 * cos((6.28318520000000 * v16)))), (-1/2)) * pow(((-1 * pow(cos((6.28318520000000 * v15)), 2) * pow(cos((6.28318520000000 * v16)), 2)) + (pow(sin((6.28318520000000 * v15)), 2) * pow(sin((6.28318520000000 * v16)), 2)) + pow(cos((6.28318520000000 * v16)), 2) + pow(cos((6.28318520000000 * v15)), 2)), (-1/2)) * (-12.5663704000000 + (6.28318520000000 * cos((6.28318520000000 * v16)))) * sin((6.28318520000000 * v16))), 1.0); }
vec4 torus_normal(float v15, float v16) { return vec4((-1.00000000000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v15)) * cos((6.28318520000000 * v16))), (-1.00000000000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * cos((6.28318520000000 * v16)) * sin((6.28318520000000 * v15))), (1.00000000000000 * pow(pow((-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))), 2), (-1/2)) * (-2.00000000000000 + (1.00000000000000 * cos((6.28318520000000 * v16)))) * sin((6.28318520000000 * v16))), 1.0); }
float tf(float f) { return 0.5*sin(4*pi*f) + 0.5; }
out vec4 outputColor; void main() {
/*
outputColor = gl_FrontFacing ?
vec4(tf(uv.x), tf(uv.y), 0, 1) :
vec4(1, 1 - tf(uv.x), 1 - tf(uv.y), 1);
*/
outputColor = vec4(0.8, 0.8, 0.8, 1);
vec4 n = normalize( torus_normal(uv.x, uv.y) );
float lambert = max( dot(vec4(0.7, 0, 0.7, 0), n), 0);
outputColor *= (lambert + 0.2);
}'''),
VertexShader('''#version 130
uniform float pi = 3.14159;
/* layout(location = 0) */ in vec2 param;
varying vec2 uv;
vec4 torus(float v25, float v26) { return vec4(((2.00000000000000 * cos((6.28318520000000 * v25))) + (-1.00000000000000 * cos((6.28318520000000 * v25)) * cos((6.28318520000000 * v26)))), ((2.00000000000000 * sin((6.28318520000000 * v25))) + (-1.00000000000000 * cos((6.28318520000000 * v26)) * sin((6.28318520000000 * v25)))), (1.00000000000000 * sin((6.28318520000000 * v26))), 1.0); }
//vec4 knot(float v15, float v16) { return vec4(((-1.00000000000000 * cos((18.8495556000000 * v15)) * cos((12.5663704000000 * v15))) + (2.00000000000000 * cos((12.5663704000000 * v15)))), ((2.00000000000000 * sin((12.5663704000000 * v15))) + (-1.00000000000000 * cos((18.8495556000000 * v15)) * sin((12.5663704000000 * v15)))), (1.00000000000000 * sin((18.8495556000000 * v15))), 1.0); }
void main() {
vec4 p = torus(param.x, param.y);
//vec4 p = knot(param.x, param.y);
//vec4 p = vec4(param.x, param.y, 0, 1);
uv = param.xy;
gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * p;
}''')
)
def update(self, dt):
self.t += dt
def on_resize(self, width, height):
glViewport(0, 0, width, height)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(50, width / float(height), .01, 100)
glMatrixMode(GL_MODELVIEW)
glDepthFunc(GL_LESS)
glEnable(GL_DEPTH_TEST)
return pyglet.event.EVENT_HANDLED
def on_mouse_press(self, x, y, button, modifiers):
# self.set_exclusive_mouse()
return
def on_mouse_release(self, x, y, button, modifiers):
# self.set_exclusive_mouse(exclusive=False)
return
def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
# rotate on left-drag
if buttons & 1:
# the rotation vector is the displacement vector rotated by 90 degrees
v = Vec3(dy, -dx, 0).scale(0.002)
# update the current orientation
self.orientation = self.orientation * v.rotation()
# zoom on right-drag
if buttons & 4:
self.zoom += self.zoom * dy*0.01
def on_draw(self):
glDepthFunc(GL_LESS)
glEnable(GL_DEPTH_TEST)
self.clear()
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glTranslatef(0, 0, -7.0)
glScalef(self.zoom, self.zoom, self.zoom)
r = self.orientation.conj().matrix()
# column-major order
m = [r.X.x, r.X.y, r.X.z, 0,
r.Y.x, r.Y.y, r.Y.z, 0,
r.Z.x, r.Z.y, r.Z.z, 0,
0, 0, 0, 1,]
array = (GLfloat * len(m))()
for index, value in enumerate(m):
array[index] = value
glMultMatrixf(array);
glPointSize(1.8)
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
with self.program:
self.grid.draw_triangles()
glPopMatrix()
class Tetris():
NORMAL_MODE = 0
BOOZE_MODE = 1
DESIGNATED_DRIVER_MODE = 2
SINGLE_DRINK_MODE = 3
def __init__(self):
self._event_handlers = []
self._setup_states()
self._state["game_over"] = True
self._setup_display()
self._joystick = None
if pygame.joystick.get_count() > 0:
print "FOUND A JOYSTICK!"
self._joystick = pygame.joystick.Joystick(0)
self._joystick.init()
def _setup_states(self, mode = 0):
self._params = {
"fullscreen" : False,
"fullscreen_width" : 1024,
"fullscreen_height" : 768,
"num_cells_wide" : 10,
"num_cells_high" : 20,
"cell_width" : 25,
"cell_height" : 25,
"drink_pouring_time" : 10.0,
"starting_cell_x" : 4,
"starting_cell_y" : 1,
"grid_top_x" : 0,
"grid_top_y" : 0,
"modes" : ["(N)ormal Mode", "(B)ooze Mode", "(S)ingle Drink Mode", "(D)esignated Driver Mode", "(Q)uit"]
}
self._level_params = {
"moving_rate" : [0.00005,.00004,0.00003,0.00002,0.00001],
"rotating_rate" : [0.00009,0.00008,0.00007,0.00006,0.00005],
"falling_rate" : [0.00050,0.00035,0.00020,0.00010,0.00005]
}
self._state = {
"last_falling_time" : 0,
"falling_rate" : self._level_params["falling_rate"][0],
"last_moving_time" : 0,
"last_rotating_time" : 0,
"level_up_line_count" : 5,
"last_num_lines_cleared" : 0,
"top_y" : 0,
"times_found" : 0,
"current_level" : 1,
"game_over" : False,
"all_finished" : False,
"current_y" : 0,
"holding_down" : False
}
if mode in [self.NORMAL_MODE, self.SINGLE_DRINK_MODE]:
self._color_dict = {1: COLORS["blue"], 6 : COLORS["brown"], 10: COLORS["darkGrey"]}
elif mode == self.BOOZE_MODE:
self._color_dict = {3 : COLORS["brown"], 10: COLORS["darkGrey"]}
elif mode == self.DESIGNATED_DRIVER_MODE:
self._color_dict = {10: COLORS["blue"]}
if mode == self.SINGLE_DRINK_MODE or mode == self.BOOZE_MODE:
self._level_params = {
"moving_rate" : [0.00005],
"rotating_rate" : [0.00009],
"falling_rate" : [0.00040]
}
self._params["drink_pouring_time"] = 20.0
self._color_range = 10
self._textBuff = 2
self._grid = Grid( 1, 1, self._params["cell_width"], self._params["cell_height"], self._params["num_cells_wide"], self._params["num_cells_high"], COLORS["black"], self._params["fullscreen"], self._params["fullscreen_width"], self._params["fullscreen_height"])
if self._params["fullscreen"]:
self._params["grid_top_x"] = (self._params["fullscreen_width"] / 2) - (self._grid.width / 2)
self._params["grid_top_y"] = (self._params["fullscreen_height"] / 2) - (self._grid.height / 2)
self._tetrominoList = ['T','I','O','S','Z','L','J']
self._sound = Sound()
self._new_tetromino()
def _setup_display(self):
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
if self._params["fullscreen"]:
self._screen = pygame.display.set_mode((1024, 768), pygame.FULLSCREEN, 24)
else:
self._screen = pygame.display.set_mode((self._grid.width+self._textBuff,self._grid.height+self._textBuff),0,32)
if pygame.font:
self._font = pygame.font.Font(None, 18)
def init_game(self):
pygame.display.set_caption("Python Tetris")
def run_game(self):
time.sleep(0.01)
if self._state["game_over"]:
self._menu_state()
else:
self._game_loop()
self._render()
return
def _menu_state(self):
current_key = ''
for event in pygame.event.get():
if event.type == QUIT:
raise QuitException()
if event.type == pygame.KEYDOWN:
current_key = event.key
if current_key == K_q:
raise QuitException()
elif current_key == K_n:
self._setup_states(self.NORMAL_MODE)
elif current_key == K_b:
self._setup_states(self.BOOZE_MODE)
elif current_key == K_d:
self._setup_states(self.DESIGNATED_DRIVER_MODE)
elif current_key == K_s:
self._setup_states(self.SINGLE_DRINK_MODE)
def _game_loop(self):
# Grab vars
if self._tetromino.active:
self._move_tetromino()
else: #New Tetromino
osc.sendMsg("/tetris/piece_down", [0], "localhost", 9001)
self._new_tetromino()
#Levels and Speedup
if self._grid.num_lines_cleared >= (self._state["level_up_line_count"] * self._state["current_level"]) and self._state["last_num_lines_cleared"] != self._grid.num_lines_cleared:
self._level_up()
def _move_tetromino(self):
current_key = ''
up_key = ''
for event in pygame.event.get():
legal_moves = {
"down" : self._tetromino.max_y < self._grid.height,
"left" : self._tetromino.min_x > 0 and self._grid.accept(self._tetromino.id,self._tetromino.positions[self._tetromino.currentPosition],-1,0),
"right" : self._tetromino.max_x < self._grid.width and self._grid.accept(self._tetromino.id,self._tetromino.positions[self._tetromino.currentPosition],1,0),
}
if event.type == QUIT:
break
if event.type == pygame.JOYAXISMOTION:
a = event.axis
p = event.value
#turn joystick into key simulations
if a == 0:
if p < -0.01:
current_key = K_LEFT
elif p > 0.01:
current_key = K_RIGHT
else:
if p > 0.01:
current_key = K_DOWN
elif p < 0.01 and p > -0.01:
up_key = K_DOWN
if event.type == pygame.JOYBUTTONDOWN:
if event.button == 1:
current_key = K_z
else:
current_key = K_x
if event.type == pygame.KEYDOWN:
current_key = event.key
elif event.type == pygame.KEYUP:
up_key = event.key
if current_key == K_RIGHT and legal_moves["right"]:
self._tetromino.move(self._grid,1,0)
if current_key == K_LEFT and legal_moves["left"]:
self._tetromino.move(self._grid,-1,0)
if current_key == K_DOWN:
self._state["holding_down"] = True
osc.sendMsg("/mario/speed", [40], "localhost", 9001)
elif up_key == K_DOWN:
osc.sendMsg("/mario/speed", [0], "localhost", 9001)
self._state["holding_down"] = False
#TODO: Fix rotation states
if current_key == K_z and False not in legal_moves.values():
self._tetromino.rotate(self._grid, -1)
if current_key == K_x and False not in legal_moves.values():
self._tetromino.rotate(self._grid, 1)
#ADDED: quit current_key
if current_key == K_q:
raise QuitException()
legal_moves = {
"down" : self._tetromino.max_y < self._grid.height,
"left" : self._tetromino.min_x > 0 and self._grid.accept(self._tetromino.id,self._tetromino.positions[self._tetromino.currentPosition],-1,0),
"right" : self._tetromino.max_x < self._grid.width and self._grid.accept(self._tetromino.id,self._tetromino.positions[self._tetromino.currentPosition],1,0),
}
current_time = time.time()/1000.0
falling_time = current_time - self._state["last_falling_time"]
#Downward fall
if self._state["holding_down"] is True and legal_moves["down"]:
self._tetromino.move(self._grid,0,1)
self._state["current_y"] += 1
elif falling_time >= self._state["falling_rate"] and legal_moves["down"]:
self._state["last_falling_time"] = current_time
self._tetromino.move(self._grid,0,1)
self._state["current_y"] += 1
elif not legal_moves["down"] and falling_time >= self._state["falling_rate"]:
self._tetromino.cluck.play()
self._tetromino.active = False
def _new_tetromino(self):
#ADDED: Set tetromino color to one of our three allowed colors
color_index = random.randint(0,self._color_range)
color = ()
for color_probability in sorted(self._color_dict.keys()):
if color_index <= color_probability:
color = self._color_dict[color_probability]
break
rand = random.randint(0,len(self._tetrominoList)-1)
self._tetromino = Tetromino(self._params["starting_cell_x"], self._params["starting_cell_y"], COLORS["black"],color,self._tetrominoList[rand])
self._state["holding_down"] = False
if self._grid.checkForLines():
for e in self._event_handlers:
e.on_line_created(self)
#Test for GAME OVER
top_y = self._grid.topY()
if top_y <= 2:
self._state["times_found"] += 1
if self._state["times_found"] > 3:
self._state["game_over"] = True
def _level_up(self):
self._state["last_num_lines_cleared"] = self._grid.num_lines_cleared
self._state["current_level"] += 1
if self._state["current_level"] < len(self._level_params["falling_rate"]):
self._state["falling_rate"] = self._level_params["falling_rate"][self._state["current_level"]]
else:
self._state["all_finished"] = True
self._state["game_over"] = True
self._sound.play("../sound/levelup.wav")
for e in self._event_handlers:
e.on_level_up(self)
def _render(self):
#render Background
pygame.draw.rect(self._screen,(255,255,255),Rect(self._params["grid_top_x"], self._params["grid_top_y"],self._grid.width+2,self._grid.height+2))
#Render Grid
self._grid.render(self._screen)
self._render_status()
pygame.display.update()
def _render_status(self):
if not self._state["game_over"]:
lineText = "Lines: " + str(self._grid.num_lines_cleared) + " Level: " + str(self._state["current_level"])
lines_text = self._font.render(lineText, 1, COLORS["white"])
lines_text_pos = Rect((self._params["grid_top_x"]+1, self._params["grid_top_y"]+1),(self._params["grid_top_x"] + 300, self._params["grid_top_y"] + 20))
self._screen.blit(lines_text, lines_text_pos)
else:
game_over_text = self._font.render("GAME OVER... LEVEL: "+str( self._state["current_level"])+" LINES: " + str(self._grid.num_lines_cleared),1, COLORS["red"])
if self._state["all_finished"]:
game_over_text = self._font.render("ALL LEVELS FINISHED! LEVEL: "+str( self._state["current_level"])+" LINES: " + str(self._grid.num_lines_cleared),1, COLORS["red"])
game_over_text_pos = Rect((self._params["grid_top_x"]+1, self._params["grid_top_y"]+1),(self._params["grid_top_x"] + 300, self._params["grid_top_y"] + 20))
self._screen.blit(game_over_text,game_over_text_pos)
for i in range(0, len(self._params["modes"])):
pLineText = self._params["modes"][i]
p_lines_text = self._font.render(pLineText, 1, COLORS["white"])
p_lines_text_pos = Rect((1+self._params["grid_top_x"],100+(i*25)+self._params["grid_top_y"]),(300,250))
self._screen.blit(p_lines_text, p_lines_text_pos)
def add_event_handler(self, eh):
self._event_handlers.append(eh)
def _setup_states(self, mode = 0):
self._params = {
"fullscreen" : False,
"fullscreen_width" : 1024,
"fullscreen_height" : 768,
"num_cells_wide" : 10,
"num_cells_high" : 20,
"cell_width" : 25,
"cell_height" : 25,
"drink_pouring_time" : 10.0,
"starting_cell_x" : 4,
"starting_cell_y" : 1,
"grid_top_x" : 0,
"grid_top_y" : 0,
"modes" : ["(N)ormal Mode", "(B)ooze Mode", "(S)ingle Drink Mode", "(D)esignated Driver Mode", "(Q)uit"]
}
self._level_params = {
"moving_rate" : [0.00005,.00004,0.00003,0.00002,0.00001],
"rotating_rate" : [0.00009,0.00008,0.00007,0.00006,0.00005],
"falling_rate" : [0.00050,0.00035,0.00020,0.00010,0.00005]
}
self._state = {
"last_falling_time" : 0,
"falling_rate" : self._level_params["falling_rate"][0],
"last_moving_time" : 0,
"last_rotating_time" : 0,
"level_up_line_count" : 5,
"last_num_lines_cleared" : 0,
"top_y" : 0,
"times_found" : 0,
"current_level" : 1,
"game_over" : False,
"all_finished" : False,
"current_y" : 0,
"holding_down" : False
}
if mode in [self.NORMAL_MODE, self.SINGLE_DRINK_MODE]:
self._color_dict = {1: COLORS["blue"], 6 : COLORS["brown"], 10: COLORS["darkGrey"]}
elif mode == self.BOOZE_MODE:
self._color_dict = {3 : COLORS["brown"], 10: COLORS["darkGrey"]}
elif mode == self.DESIGNATED_DRIVER_MODE:
self._color_dict = {10: COLORS["blue"]}
if mode == self.SINGLE_DRINK_MODE or mode == self.BOOZE_MODE:
self._level_params = {
"moving_rate" : [0.00005],
"rotating_rate" : [0.00009],
"falling_rate" : [0.00040]
}
self._params["drink_pouring_time"] = 20.0
self._color_range = 10
self._textBuff = 2
self._grid = Grid( 1, 1, self._params["cell_width"], self._params["cell_height"], self._params["num_cells_wide"], self._params["num_cells_high"], COLORS["black"], self._params["fullscreen"], self._params["fullscreen_width"], self._params["fullscreen_height"])
if self._params["fullscreen"]:
self._params["grid_top_x"] = (self._params["fullscreen_width"] / 2) - (self._grid.width / 2)
self._params["grid_top_y"] = (self._params["fullscreen_height"] / 2) - (self._grid.height / 2)
self._tetrominoList = ['T','I','O','S','Z','L','J']
self._sound = Sound()
self._new_tetromino()
class GridSimulation(object):
"inititialize the world"
def __init__(self):
self.grid = Grid(gridWidth, gridHeight)
for i in range(numBots):
self.age = 0.0
bot = Bot()
x = random.randint(0, gridWidth-1)
y = random.randint(0, gridWidth-1)
self.grid.getNode(x, y).add(bot)
self.createCode()
self.stepCount = 0
def createCode(self):
#self.code = nprandom.random_integers(0, 1, codeSize)
self.code = zeros(codeSize)
for i in range(codeSize):
self.code[i] = random.randint(0, 1)
self.refreshAge = self.age + random.expovariate(codeRefreshRate)
"run the simulation"
def elapseTime(self, time):
goalAge = self.age + time
while (self.age < goalAge):
"report"
if (self.stepCount <= 0):
self.stepCount += stepsPerReport
numBots = self.grid.numBots()
numCorrect = self.grid.numCorrect()
print 'Time:', self.age, 'Number of Bots:', numBots, 'Code:', self.code, \
'Percent correct:', float(numCorrect)/numBots
self.stepCount -= 1
self.age += timeStepSize
if (self.age > self.refreshAge):
self.createCode()
"run the bots"
for x in range(self.grid.width):
for y in range(self.grid.height):
node = self.grid.getNode(x, y)
for bot in node.bots:
"push their outputs to the node"
node.data += bot.outputs.dataOut
for bot in node.bots.copy():
"listen to accumulated outputs"
bot.inputs.dataIn = node.data
node.clearData()
"determine move"
left = bot.outputs.left > random.random()
right = bot.outputs.right > random.random()
up = bot.outputs.up > random.random()
down = bot.outputs.down > random.random()
if (left and right):
left = False
right = False
if (up and down):
up = False
down = False
"determine new coordinates"
newx = x
newy = y
if (left):
newx -= 1
if (right):
newx += 1
if (up):
newy += 1
if (down):
newy -= 1
node2 = node
"make move"
if ((x, y) != (newx, newy)):
node.remove(bot)
node2 = self.grid.getNode(newx, newy)
node2.add(bot)
"reproduce"
if (bot.spawnTime <= 0.0):
node2.add(bot.spawn())
"elapse bot time and remove dead bots"
guess = bot.outputs.code
guess = maximum(guess, 0)
guess = minimum(guess, 1)
correct = reduce(lambda x, y : x * y, abs(guess - self.code)) < random.random()
#bot.inputs.correct = 1 if correct else 0
#debug
bot.inputs.correct = self.code[0]
print correct
alive = bot.elapseTime(timeStepSize)
if (not alive):
node2.remove(bot)
"kill extra bots"
bots = []
for x in range(self.grid.width):
for y in range(self.grid.height):
node = self.grid.getNode(x, y)
bots.extend(node.bots)
random.shuffle(bots)
for i in range(maxBots, len(bots)):
bots[i].node.remove(bots[i])
def __init__(self, width, height, blocked, food):
"""
Initializes a worldMap with the specified
width and height
The percentage of tiles specified by blocked are set at
random to be non-traversable
The percentage of tiles specified by food are
seeded at random with food in an amount between 1-5 units
The anthill location is set at random
width: an integer > 0
height: an integer > 0
blocked: a float 0.8 > float > 0.0
food: a float 0.8 > float > 0.0
Mapping of hash table values
Open (i.e. traversable): 100
Blocked: 101
Home: 102
Food: 1-5
"""
self._width = width
self._height = height
self._dirs = dict([("NORTH",(-1,0)),("EAST",(0,1)),("SOUTH",(1,0)),("WEST",(0,-1))])
## create the map of the world
## create an empty 2-dimensional array
self._grid = Grid(height, width)
## populate the 2-dimensional array with open tiles
for row in range(height):
for col in range(width):
self._grid.setAt(row, col, tile())
## set randomly selected tiles to be blocked
assert blocked >= 0.0
assert blocked <= 0.8
for i in range(int(width*height*blocked)):
val = random.choice(range(width*height))
self._grid.getAt(val/width, val%width).setIsTravelable(False)
## set randomly selected tiles to be seeded with food
assert food >= 0.0
assert blocked <= 0.8
for i in range(int(width*height*food)):
val = random.choice(range(width*height))
## check that tile isn't blocked before seeding with food
if self._grid.getAt(val/width, val%width).isTravelable():
self._grid.getAt(val/width, val%width).setNumFood(random.choice(range(1,6)))
## set the anthill location
while(True):
home = random.choice(range(width*height))
## check that tile isn't blocked before setting to be home
currTile = self._grid.getAt(home/width, home%width)
if currTile.isTravelable() and currTile.getAmountOfFood() == 0:
self._grid.getAt(home/width, home%width).setIsHome(True)
break;
## create a map of the ants in the world
## create an empty 2-dimensional array populated with empty lists
self._antGrid = [[[] for col in xrange(width)] for row in xrange(height)]
class worldMap:
"""
A worldMap represents a world
A worldMap has a width and a height and contains (width*height) tiles
"""
def __init__(self, width, height, blocked, food):
"""
Initializes a worldMap with the specified
width and height
The percentage of tiles specified by blocked are set at
random to be non-traversable
The percentage of tiles specified by food are
seeded at random with food in an amount between 1-5 units
The anthill location is set at random
width: an integer > 0
height: an integer > 0
blocked: a float 0.8 > float > 0.0
food: a float 0.8 > float > 0.0
Mapping of hash table values
Open (i.e. traversable): 100
Blocked: 101
Home: 102
Food: 1-5
"""
self._width = width
self._height = height
self._dirs = dict([("NORTH",(-1,0)),("EAST",(0,1)),("SOUTH",(1,0)),("WEST",(0,-1))])
## create the map of the world
## create an empty 2-dimensional array
self._grid = Grid(height, width)
## populate the 2-dimensional array with open tiles
for row in range(height):
for col in range(width):
self._grid.setAt(row, col, tile())
## set randomly selected tiles to be blocked
assert blocked >= 0.0
assert blocked <= 0.8
for i in range(int(width*height*blocked)):
val = random.choice(range(width*height))
self._grid.getAt(val/width, val%width).setIsTravelable(False)
## set randomly selected tiles to be seeded with food
assert food >= 0.0
assert blocked <= 0.8
for i in range(int(width*height*food)):
val = random.choice(range(width*height))
## check that tile isn't blocked before seeding with food
if self._grid.getAt(val/width, val%width).isTravelable():
self._grid.getAt(val/width, val%width).setNumFood(random.choice(range(1,6)))
## set the anthill location
while(True):
home = random.choice(range(width*height))
## check that tile isn't blocked before setting to be home
currTile = self._grid.getAt(home/width, home%width)
if currTile.isTravelable() and currTile.getAmountOfFood() == 0:
self._grid.getAt(home/width, home%width).setIsHome(True)
break;
## create a map of the ants in the world
## create an empty 2-dimensional array populated with empty lists
self._antGrid = [[[] for col in xrange(width)] for row in xrange(height)]
def getWorldWidth(self):
return self._width
def getWorldHeight(self):
return self._height
def getTile(self, row, col):
"""
return the tile at the specified position
"""
return self._grid.getAt(row, col)
def getSurroundings(self, row, col):
"""
return a hash table of the Surroundings of the position
specified by the (row, col) position
"""
output = {}
output["Current"] = self._grid.getAt(row, col)
## iterate through each possible direction (NORTH, EAST, SOUTH, WEST)
for direction, move in self._dirs.items():
newRow = row + move[0]
newCol = col + move[1]
## validate that the new position is in the world
if newRow >= 0 and newRow < self._height and newCol >= 0 and newCol < self._width:
output[direction] = self._grid.getAt(newRow, newCol)
## dragons be here: off the map, set to blocked tile with 0 food, 0 ant
else:
output[direction] = tile(0,0,False)
return output
#!/bin/python from Grid import * from Thing import * import time, sys g = Grid(6, 9) g.addWall180([2,3], EAST) g.addWall180([4,3], EAST) g.addWall180([4,2], EAST) g.addWall180([3,1], SOUTH) g.addWall180([0,3], SOUTH) g.addWall180([1,2], SOUTH) g.addWall180([1,2], WEST) a = Alice() m = Mirror() c = Chess() f = Feather() a.spawn(g, (5,0)) m.spawn(g, (1,4)) # m.spawn(g, (2,5)) #c.spawn(g, (0,5)) f.spawn(g, (0,8)) print g.positionOf(a) try: tick = float(sys.argv[1]) except:
class Ant:
"""
Represents an ant.
The ant has an internal map and maps its position relative to
the starting point
"""
def __init__(self,inputPrintActions):
"""
Ants are initialized with a 20x20 internal map. All tiles (except the
starting tile) on the internal map are initially set to -100 which
represents unexplored tiles.
The starting position of the ant is assumed to be (row, col)
(9,9), the center of the internal map.
Ants are initialized with zero food.
Ants are intialzied with no route plan.
The internal representation for ants is as follows:
-100: unknown tile
-101: travelable tile
-102: untravelable tile
-103: home tile
0-127: food
"""
self._foodKnown = False
self._hasFood = False
self._newFoodFound = False
self._gridLen = 20
self._receiveMap = False
self._routePlan = []
self._routePlanType = "UNKNOWN"
self._memo = {}
self._row = 9
self._col = 9
self._homeRow = 9
self._homeCol = 9
self._foodLoc = (0,0)
self._unexploredLoc = (0,0)
self._foodLocSet = set()
self._unexploredLocSet = set()
self._exhaustedFoodLocSet = set()
self._dirs = dict([("NORTH",(-1,0)),("EAST",(0,1)),("SOUTH",(1,0)),("WEST",(0,-1))])
self._nReceives = 0
self._printActions = inputPrintActions
## create a 2-dimensional grid to represent the world
## for the ant
self._internalMap = Grid(self._gridLen, self._gridLen, -100)
self._internalMap.setAt(self._homeRow, self._homeCol, -103) ##103 represents the home tile
def getAntHasFood(self):
return self._hasFood
def setAntHasFood(self, hasFood):
"""
set the boolean value for whether the ant has food
"""
self._hasFood = hasFood
def antGather(self):
"""
represents and ant collecting food
"""
## validate that the ant has no food
assert self._hasFood == False
self._hasFood = True
def antDropoff(self):
"""
represents and ant dropping off food
"""
## validate that the ant has food
assert self._hasFood == True
self._hasFood = False
def setAntReceiveMap(self, mapFromOtherAnt):
self._receiveMap = mapFromOtherAnt
def getAntReceiveMap(self):
return self._receiveMap
def getPrintActions(self):
return self._printActions
def checkMap(self):
"""
iterates through known food locations and know unexplored locations
to find the nearest tile of the respective type(food/unexplored).
Stores the nearest location for use with A*.
"""
self._foodLoc = (float("inf"),0)
self._unexploredLoc = (float("inf"),0)
for (row, col) in self._foodLocSet:
## A* hueristic: for each food location, calculate the distance form
## the current location
foodDistance = math.sqrt((self._row - row)**2 + (self._col - col)**2)
if foodDistance < self._foodLoc[0]:
self._foodLoc = (foodDistance,(row,col))
for (row, col) in self._unexploredLocSet:
assert self._internalMap.getAt(row, col) == -100
## A* hueristic: for each unexplored location, calculate the distance form
## the current location
unexploredDistance = math.sqrt((self._row - row)**2 + (self._col - col)**2)
if unexploredDistance < self._unexploredLoc[0]:
self._unexploredLoc = (unexploredDistance,(row,col))
def finalCheckMap(self):
"""
iterates through the internal map to determine if there
are any unexplored locations
"""
for row in xrange(self._gridLen):
for col in xrange(self._gridLen):
if self._internalMap.getAt(row, col) == -101:
self.addUnexploredLocs(row,col)
def updateMapPos(self, action):
"""
updateMapPos takes a string value representing a movement.
updateMapOs updates the relative location of the ant on the
internal map
"""
self._row = self._row + (self._dirs[action])[0]
self._col = self._col + (self._dirs[action])[1]
## if the new position is within 5 tiles of the boundry of the ant's internal map
## then we increase the size of the internal map
if self._row <= 5 or self._row > self._gridLen - 5 or self._col <= 5 or self._col > self._gridLen - 5:
self.resize()
def resizeInstanceVariables(self, rowDelta, colDelta):
"""
resizeInstanceVaribles adjusts the instance variables
so the instance variables stay consistent with the resized map
"""
self._row += rowDelta
self._col += colDelta
self._homeRow += rowDelta
self._homeCol += colDelta
## update the lists of food, unexplored, and exhausted
self._foodLocSet = set(map(lambda x: (x[0] + rowDelta, x[1] + colDelta), self._foodLocSet))
self._unexploredLocSet = set(map(lambda x: (x[0] + rowDelta, x[1] + colDelta), self._unexploredLocSet))
self._exhaustedFoodLocSet = set(map(lambda x: (x[0] + rowDelta, x[1] + colDelta), self._exhaustedFoodLocSet))
def resize(self):
"""
resizes the ants internal map by adding 10 rows / 10 cols.
"""
oldLength = self._gridLen
self._gridLen += 20
## increase the ant's internal map. New tiles are set to -100 to represent unexplored
self._internalMap.resize(10,10,-100)
## update the ant's position in the internal map
self.resizeInstanceVariables(10,10)
def shortest_path_search(self, startPos, fSuccessors, fIsGoal, goalObjective):
"""returns a list of the shortest path to a goal state.
startPosition is a (row position,col position) tuple (i.e. coordinates) that
specifies the starting location. SPS takes the staring state, the
function successors, the function is_goal, and the variable goalType"""
if fIsGoal([startPos], goalObjective):
return [startPos]
fail = []
## memoize paths to home and to food
## don't memoize paths to unexplored tiles as the unexplored tiles change
## check to see if we've memoized the shortest path
if (startPos, goalObjective) in self._memo:
## if the goal is to get home, we can use the memoized path
if goalObjective == "HOME":
return self._memo[(startPos, goalObjective)]
## if the goal is to find food, we need to confirm that
## we still believe there is food at the location
elif goalObjective == "FOOD":
## pull the end position off the path and unpack the tuple
endRow, endCol = (self._memo[(startPos, goalObjective)])[-1]
## if we believe there is still food at the end point
## we can take the memoized path
if (endRow,endCol) in self._foodLocSet:
return self._memo[(startPos, goalObjective)]
## if there's no food left, delete the path
else:
del self._memo[(startPos, goalObjective)]
## algorithm for shortest_path_search
explored = set([])
frontier = Queue.PriorityQueue()
frontier.put([1, [startPos]])
while(frontier):
## path with lowest cost gValue is expanded first
path = frontier.get()
## calculate the number of steps in the path to this point len(path[1])/2.
numSteps, state = len(path[1])/2., (path[1])[-1]
for (action,state) in fSuccessors(state).items():
## if our path intersects a known path for returning to the
## home tile, stop SPS and take the known path
if goalObjective == "HOME" and (state, "HOME") in self._memo:
path2 = path[1] + [action] + self._memo[(state, "HOME")]
return path2
## state is a tuple of row,col offsets
if state not in explored:
explored.add(state)
## path is in the form [(0,0),"NORTH",(-1,0),"WEST",(-1,-1),"NORTH",(-2,-1)]
path2 = path[1] + [action, state]
## calculations for A*: Calculate the euclidean distance from the
## expansion location to the goal location. The distance will be used
## to guide which location is expanded in subsequent steps
rowOffset, colOffset = state
newRow = self._homeRow + rowOffset
newCol = self._homeCol + colOffset
if goalObjective == "HOME":
aStarDist = math.sqrt((rowOffset)**2 + (colOffset)**2)
elif goalObjective == "FOOD":
foodRow, foodCol = self._foodLoc[1]
aStarDist = math.sqrt((foodRow - newRow)**2 + (foodCol - newCol)**2)
else:
assert goalObjective == "UNKNOWN"
unexploredRow, unexploredCol = self._unexploredLoc[1]
aStarDist = math.sqrt((unexploredRow - newRow)**2 + (unexploredCol - newCol)**2)
## the gValue is the number of steps in the path so far plus the euclidean
## distance to the goal
gValPath = [numSteps + aStarDist, path2]
if fIsGoal(path2, goalObjective):
## only memoize food paths starting at the home tile. Note 1
if goalObjective == "HOME" or (goalObjective == "FOOD" and startPos == (self._homeRow, self._homeCol)):
self._memo[(startPos, goalObjective)] = path2
return path2
else:
frontier.put(gValPath)
return fail
def fSuccessors(self, state):
"""returns a hash table of all possible sucessor states to the starting state
key:value pairs consist of the action:new state. State is a row offset,col offset
tuple (i.e. coordinates)."""
## unpack the state tuple (row, col)
## this is the end state of the path we are checking
rowOffset, colOffset = state
output = {}
## iterate through each direction:state pair in the hash table
for (direction,move) in self._dirs.items():
## update the row,col position by the move that corresponds to the direction
newRowOffset = rowOffset + move[0]
newColOffset = colOffset + move[1]
newRow = self._homeRow + newRowOffset
newCol = self._homeCol + newColOffset
## if the new row,col position isn't blocked
## and the new row,col position isn't unexplored
## add position to the hash table of possible successor states
if (self._internalMap.getAt(newRow, newCol) != -100 and self._internalMap.getAt(newRow, newCol) != -102):
output[direction] = (newRowOffset,newColOffset)
return output
## helper function for shortest_path_search
def fIsGoal(self, path, goalType):
"""returns a boolean whether the state represents a goal state
there are 3 potential goals: home , food , and unknown
"""
## unpack the coordinate tuple
rowOffset, colOffset = path[-1]
row = self._homeRow + rowOffset
col = self._homeCol + colOffset
## check if the path ends at the home tile
if goalType == "HOME":
return self._internalMap.getAt(row, col) == -103
## check if the path ends at food
elif goalType == "FOOD":
return (row, col) == self._foodLoc[1]
## check if we're on a tile that can sense() an unexplored tile
else:
## if not 1 or 2, goalType must be 0
assert goalType == "UNKNOWN"
output = False
for move in self._dirs.values():
newRow = row + move[0]
newCol = col + move[1]
if self._internalMap.getAt(newRow, newCol) == -100:
output = True
return output
def getAction(self,Surroundings):
"""
returns a string value representing the ant's next action.
Possible actions: GATHER, DROPOFF, HALT, NORTH, SOUTH, EAST, WEST
"""
## extract the current tile from Surroundings
currTile = Surroundings.getCurrentTile()
## if there are other ants on the current tile, receive data from the other ants
if len(currTile.getAnts()) > 0:
for ant in currTile.getAnts():
## ants only communicate with other ants every 5th turn to reduce computational expense
if ant != self and self._nReceives%2 == 0:
self.receive(ant.send())
## sense the Surroundings
self.sense(Surroundings)
## ant waits at home until it receives a map from a mature ant
if not self.getAntReceiveMap():
return "HALT"
## if the ant has a route plan, follow the plan
if len(self._routePlan) > 0:
action = self._routePlan.pop(0)
self.updateMapPos(action)
if self.getPrintActions():
print action
return action
## if the ant has food and the ant is on the
## ant mound, drop off the food, DROPOFF
## the program decrements the ants food
if self.getAntHasFood() and self._internalMap.getAt(self._row, self._col) == -103:
if self.getPrintActions():
print 'DROPOFF'
return "DROPOFF"
## if the ant doesn't have food and the current tile does have food
## set a path for home, then GATHER
if currTile.getAmountOfFood() > 0 and not self.getAntHasFood() and self._internalMap.getAt(self._row, self._col) != -103:
rowOffset = self._row - self._homeRow
colOffset = self._col - self._homeCol
path = self.shortest_path_search((rowOffset, colOffset), self.fSuccessors, self.fIsGoal, "HOME")
self._routePlan = path[1::2]
self._routePlanType = "HOME"
## If there is only one unit of food delete the location as a food location
if currTile.getAmountOfFood() == 1:
self._foodLocSet.remove((self._row,self._col))
self._exhaustedFoodLocSet.add((self._row, self._col))
## there's no longer food at the location so we no longer need the path
if self._memo.has_key(((self._homeRow,self._homeCol), "FOOD")):
del self._memo[((self._homeRow, self._homeCol), "FOOD")]
if self.getPrintActions():
print "GATHER"
return "GATHER"
## if the ant is aware of a food location plot the shortest path to food
if len(self._foodLocSet) > 0:
assert not self.getAntHasFood()
rowOffset = self._row - self._homeRow
colOffset = self._col - self._homeCol
path = self.shortest_path_search((rowOffset,colOffset),self.fSuccessors, self.fIsGoal, "FOOD")
self._routePlan = path[1::2]
self._routePlanType = "FOOD"
## update internal location and
## return the next action in the route plan
action = self._routePlan.pop(0)
self.updateMapPos(action)
if self.getPrintActions():
print action
return action
## otherwise, the location of food is not known and the
## ant does not have a route, so plot a path to the
## nearest unexplored tile
if len(self._foodLocSet) == 0 and len(self._unexploredLocSet) > 0:
rowOffset = self._row - self._homeRow
colOffset = self._col - self._homeCol
path = self.shortest_path_search((rowOffset, colOffset),self.fSuccessors, self.fIsGoal, "UNKNOWN")
self._routePlan = path[1::2]
self._routePlanType = "UNKNOWN"
action = self._routePlan.pop(0)
self.updateMapPos(action)
if self.getPrintActions():
print action
return action
## Otherwise we're done. No unexplored tiles
else:
if self.getPrintActions():
print "HALT"
self.finalCheckMap();
return "HALT"
def receive(self, externalData):
"""
accepts an antMap from another ant and updates the ants
internal map with the new information
"""
self._nReceives += 1
## set the self.receiveMap field to true
self.setAntReceiveMap(True)
## convert the 1-dimensional array to a 2-dimensional map
extUnexploredLocSet, extFoodLocSet, extExhaustedFoodLocSet, extMap = self.reformGrid(externalData)
## maps are square. Extract the length of the sides
N = extMap.getRows()
## calculate the difference between the side of the internal map
## and the received map
difference = N - self._gridLen
halfDif = abs(difference/2)
## Size of internal map == size of external map
## update the internal map for the case where the size of the
## external map is the same as the size of the internal map
## Unexplored tiles on the internal map are updated where the
## tiles are known on the external map
if difference == 0:
for row in range(self._gridLen):
for col in range(self._gridLen):
if self._internalMap.getAt(row, col) == -100 and extMap.getAt(row, col) != -100:
self._internalMap.setAt(row, col, extMap.getAt(row, col))
## if the position was in the unexplored set, remove as it is no longer unexplored
self._unexploredLocSet.discard((row,col))
self.sychronizeData(extUnexploredLocSet, extFoodLocSet, extExhaustedFoodLocSet)
## Size of external map > size of internal map
## update for the case where the size of the
## external map greater than the size of the internal map
## Unexplored tiles on the internal map are updated where the
## tiles are known on the external map. After the update,
## the external map replaces the internal map
elif difference > 0:
## Copy information from internal map into external Grid
for row in range(halfDif, halfDif + self._gridLen):
for col in range(halfDif, halfDif + self._gridLen):
## for explored tiles on the internal map, overwrite the external map
if not self._internalMap.getAt(row - halfDif, col - halfDif) == -100:
extMap.setAt(row, col, self._internalMap.getAt(row - halfDif, col - halfDif))
## overwite internal map with external map
self._internalMap = extMap
self._gridLen = N
self.resizeInstanceVariables(halfDif, halfDif)
self.sychronizeData(extUnexploredLocSet, extFoodLocSet, extExhaustedFoodLocSet)
## Size of internal map > size of external map
## update for the case where the size of the
## internal map is greater than the size of the external map
## Unexplored tiles on the internal map are updated where the
## tiles are known on the external map.
else:
for row in range(halfDif, halfDif + N):
for col in range(halfDif, halfDif + N):
if self._internalMap.getAt(row, col) == -100 and extMap.getAt(row - halfDif, col - halfDif) != -100:
self._internalMap.setAt(row, col, extMap.getAt(row - halfDif, col - halfDif))
extUnexploredLocSet = set(map(lambda x: (x[0] + halfDif, x[1] + halfDif), extUnexploredLocSet))
extFoodLocSet = set(map(lambda x: (x[0] + halfDif, x[1] + halfDif), extFoodLocSet))
extExhaustedFoodLocSet = set(map(lambda x: (x[0] + halfDif, x[1] + halfDif), extExhaustedFoodLocSet))
self.sychronizeData(extUnexploredLocSet, extFoodLocSet, extExhaustedFoodLocSet)
def checkRoute(self, location):
"""
checkRoute is needed to check and clear the current route plan.
checkRoute is called when data is received from other ant
that indicates that the closest food location is exhausted
"""
if location == self._foodLoc[1]:
rowOffset, colOffset = self._routePlan[-1]
endRow = self._homeRow + rowOffset
endCol = self._homeCol + colOffset
if (endRow, endCol) == location:
self._routePlan = []
def sychronizeData(self,extUnexploredLocSet, extFoodLocSet, extExhaustedFoodLocSet):
"""
sychronize data integrates the date from an external ant
"""
self._exhaustedFoodLocSet.union(extExhaustedFoodLocSet)
self._foodLocSet.union(extFoodLocSet)
self._unexploredLocSet.union(extUnexploredLocSet)
## filter out locations that have already been explored
self._unexploredLocSet = set(filter(lambda x: self._internalMap.getAt(x[0], x[1]) == -100,self._unexploredLocSet))
## filter out food locations that are known to be exhausted
self._foodLocSet = set(filter(lambda x: x not in self._exhaustedFoodLocSet, self._foodLocSet))
## delete the current routePlan if the new data shows food has been exhausted at the current route plan destination
if self._foodLoc[1] in extExhaustedFoodLocSet and self._routePlanType == "FOOD":
self._routePlan = []
def reformGrid(self, arr):
"""
Ants transmit the following data structure
Integer specifying the length of foodLocSet
Integer specifying the length of the unexploredLocSet
A 1-dimensional array and the length of the rows
and returns a 2-dimensional array.
Assumes that there are an equal number of rows and cols
"""
offset1, offset2, offset3, offset4 = arr[0], arr[1], arr[2], arr[3]
externalUnexploredLocSet = arr[offset1:offset2]
externalFoodLocSet = arr[offset2:offset3]
externalExhaustedFoodLoc = arr[offset3:offset4]
externalMap = arr[offset4:]
## internal maps are square. the square root of the array
## gives us the length of the rows
N = int(math.sqrt(len(externalMap)))
output = Grid(N,N)
for row in xrange(N):
for col in xrange(N):
output.setAt(row, col, externalMap[row*N + col])
return (externalUnexploredLocSet, externalFoodLocSet, externalExhaustedFoodLoc, output)
def send(self):
"""
pack the key data into a 1-dimensional array for transmital to another ant.
The key data is the unexplored locations, food locations, and exhausted food
locations. We use the first found elements of the array to indicate the size
of the unexplored, food, and exhausted so the receiving ant can unpack the data
"""
unexploredLen = len(self._unexploredLocSet)
foodLen = len(self._foodLocSet)
exhaustedFoodLen = len(self._exhaustedFoodLocSet)
offset1 = 4
offset2 = offset1 + unexploredLen
offset3 = offset2 + foodLen
offset4 = offset3 + exhaustedFoodLen
output = [offset1, offset2, offset3, offset4]
return output + \
list(self._unexploredLocSet) + \
list(self._foodLocSet) + \
list(self._exhaustedFoodLocSet) + \
[self._internalMap.getAt(row,col) for row in xrange(self._gridLen) for col in xrange(self._gridLen)]
def addUnexploredLocs(self, row, col):
for move in self._dirs.values():
newRow = row + move[0]
newCol = col + move[1]
if self._internalMap.getAt(newRow, newCol) == -100:
self._unexploredLocSet.add((newRow, newCol))
def sense(self, Surroundings):
"""
sense takes a Surroundings object as input, examines the Surroundings,
and updates the internal map
"""
## handle the corner case where the food on the current tile was taken since the last turn
if self._internalMap.getAt(self._row, self._col) != -103 and Surroundings.getCurrentTile().getAmountOfFood() == 0 and \
(self._row, self._col) in self._foodLocSet:
self._exhaustedFoodLocSet.add((self._row, self._col))
self._foodLocSet.remove((self._row, self._col))
## iterate through each possible direction
for direction, move in self._dirs.items():
sensedTile = Surroundings.getTile(direction)
## calculate the relative position for the sensed tile
newRow = self._row + move[0]
newCol = self._col + move[1]
## check for food, home tile always ignored
if self._internalMap.getAt(newRow, newCol) != -103 and sensedTile.getAmountOfFood() > 0:
self._foodLocSet.add((newRow,newCol))
## note 2
if self._routePlanType == "UNKNOWN":
self._routePlan = []
## unpdate map for travelable/untravelable, home tile always ignored
if self._internalMap.getAt(newRow, newCol) == -103:
pass
elif sensedTile.isTravelable():
self._internalMap.setAt(newRow, newCol, -101)
self._unexploredLocSet.discard((newRow,newCol))
else:
self._internalMap.setAt(newRow, newCol, -102)
self._unexploredLocSet.discard((newRow,newCol))
##
for move1 in self._dirs.values():
newRow1 = self._row + move1[0]
newCol1 = self._col + move1[1]
if self._internalMap.getAt(newRow1, newCol1) == -101:
self.addUnexploredLocs(newRow1, newCol1)
## after the ant finishes sensing, update whether food is known
self.checkMap()
count=1
speed=0
steer=0
timer=0
deltaL=0
deltaR=0
encoder=Encoder()
navigation=Navigation()
scanner=Scanner()
karte=Karte(encoder)
plan=Plan()
kreis=0
motor=Motor()
grid=Grid(50,50)
logic=Logic()
manuell=Manuell()
json=Json()
weggeber=Weggeber()
grid.setZielInGrid(35,20)
grid.setStartInGrid(1,1)
karte.setRoboPosZero(0,0)
plan.setGlobalZiel(150,0)
def cleaning():
"""Do cleanup at end, command are visVersa"""
motor.setCommand(0,0)
atexit.register(cleaning)
def train(model):
epochs = 3000
gamma = 0.975
epsilon = 1
batch_size = 50
buffer = 100
replay = []
# stores tuples of (S, A, R, S')
h = 0
for i in range(epochs):
state = Grid.initGridPlayer() # using the harder state initialization function
status = 1
# while game still in progress
while status == 1:
# We are in state S
# Let's run our Q function on S to get Q values for all possible actions
qval = model.predict(state.reshape(1, 64), batch_size=1)
if random.random() < epsilon: # choose random action
action = np.random.randint(0, 4)
else: # choose best action from Q(s,a) values
action = (np.argmax(qval))
# Take action, observe new state S'
new_state = Grid.makeMove(state, action)
# Observe reward
reward = Grid.getReward(new_state)
# Experience replay storage
if len(replay) < buffer: # if buffer not filled, add to it
replay.append((state, action, reward, new_state))
else: # if buffer full, overwrite old values
if h < (buffer - 1):
h += 1
else:
h = 0
replay[h] = (state, action, reward, new_state)
# randomly sample our experience replay memory
minibatch = random.sample(replay, batch_size)
x_train = []
y_train = []
for memory in minibatch:
# Get max_Q(S',a)
old_state, action, reward, new_state = memory
old_qval = model.predict(old_state.reshape(1, 64), batch_size=1)
newQ = model.predict(new_state.reshape(1, 64), batch_size=1)
maxQ = np.max(newQ)
y = np.zeros((1, 4))
y[:] = old_qval[:]
if reward == -1: # non-terminal state
update = (reward + (gamma * maxQ))
else: # terminal state
update = reward
y[0][action] = update
x_train.append(old_state.reshape(64, ))
y_train.append(y.reshape(4, ))
x_train = np.array(x_train)
y_train = np.array(y_train)
print("Game #: %s" % (i,))
model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=1)
state = new_state
if reward != -1: # if reached terminal state, update game status
status = 0
clear_output(wait=True)
if epsilon > 0.1: # decrement epsilon over time
epsilon -= (1 / epochs)
def init():
"""
Handle the initialization for the Driver component.
"""
global MAX_ITER
global output_dt
global time
global tmax
# ==========================================================================
# Arguments and parameters
# Read the command-line arguments
cline_args = parse_command_line()
# Read the parameter file
cfile_args = parse_config_file(cline_args.config_file)
# Add the command-line arguments as section 'CommandLine'
# TODO --- test this
cfile_args['CommandLine'] = vars(cline_args)
# ==========================================================================
# Initialize the Driver component
if 'Driver' not in cfile_args:
cfile_args['Driver'] = {}
# Maximum number of iterations
if 'max_iter' in cfile_args['Driver']:
MAX_ITER = int(cfile_args['Driver']['max_iter'])
else:
MAX_ITER = 10
# Store either the default value or the value from the config file converted
# from string to integer
cfile_args['Driver']['max_iter'] = MAX_ITER
# Time step between outputs
if 'output_dt' in cfile_args['Driver']:
output_dt = float(cfile_args['Driver']['output_dt'])
else:
output_dt = 0.0
cfile_args['Driver']['output_dt'] = output_dt
# Current time
time = 0.0
# Final time
if 'tmax' in cfile_args['Driver']:
tmax = float(cfile_args['Driver']['tmax'])
else:
raise Exception("tmax required") #TODO
# ==========================================================================
# Initialize the other components
# - Each initialization updates its own parameters dictionary (adding
# default values for anything not specified on the command line or in the
# configuration file) and returns the updated dictionary for logging.
# Initialize the grid
if "Grid" not in cfile_args:
cfile_args['Grid'] = {}
cfile_args['Grid'] = Grid.init(cfile_args['Grid'])
# Initialize the hydro
if "Hydro" not in cfile_args:
cfile_args['Hydro'] = {}
cfile_args['Hydro'] = Hydro.init(cfile_args['Hydro'])
# ==========================================================================
# Write parameters to log file
if not os.path.exists("output"):
os.makedirs("output")
f = open("output/parameters.txt",'w')
for section in cfile_args:
f.write("[ " + section + " ]\n")
for item in cfile_args[section]:
f.write(" " + item + " : " + str(cfile_args[section][item]) + "\n")
f.close()
# ==========================================================================
# Set up initial conditions
IC.set_initial_conditions()
return cfile_args
