def ResetGame(self):
for option in self.UiAdvancedOptions:
option.Delete()
self.UiAdvancedOptions = []
self.InAMiddleOfEating = False
self.someoneWin = False
self.justEat = False
for i in range(self.NumberOfCellsInAxis):
for j in range(self.NumberOfCellsInAxis):
if (self.BoardState[i][j] is not None):
self.BoardState[i][j].Delete()
self.BoardState[i][j] = None
if ((i + j) % 2 == 0):
if (i < 3):
self.BoardState[i][j] = Solider(
self.BoardUi, "black", Position(i, j), False,
self.OnSoliderPressed)
elif (i > 4):
self.BoardState[i][j] = Solider(
self.BoardUi, "white", Position(i, j), False,
self.OnSoliderPressed)
else:
self.BoardState[i][j] = None
else:
self.BoardState[i][j] = None
self.playerTurn = "white"
self.whitePlayersCount = 12
self.blackPlayersCount = 12
self.gameMenu.UpdateBlackSoliderCounter(self.blackPlayersCount)
self.gameMenu.UpdateWhiteSoliderCounter(self.whitePlayersCount)
self.gameMenu.UpdatePlayerTurn(self.playerTurn)
def getPossibleActions(self, state):
r = state.m_agentPos.row
c = state.m_agentPos.col
action = None
l = []
oponent_color = -1
if self.m_color == 0: # white pawn
oponent_color = 1
elif self.m_color == 1: # black pawn
oponent_color = 1
if state.m_board[r + 1][c] == Utils.empty: # standard pawn move
l.append(Action(state.m_agentPos, Position(r + 1, c)))
if r == 1 and (state.m_board[r + 2][c]
== Utils.empty): # starting pawn move
l.append(Action(state.m_agentPos, Position(r + 2, c)))
if c > 0 and (state.m_board[r + 1][c - 1] != Utils.empty) and (
Utils.getColorPiece(
state.m_board[r + 1][c - 1]) == oponent_color): # capture
l.append(Action(state.m_agentPos, Position(r + 1, c - 1)))
if c < (state.m_boardSize - 1) and (
state.m_board[r + 1][c + 1] !=
Utils.empty) and (Utils.getColorPiece(
state.m_board[r + 1][c + 1]) == oponent_color): # capture
l.append(Action(state.m_agentPos, Position(r + 1, c + 1)))
return l
def estIntacte(self,Position): # Return True si la case a un bateau et n'a pas déjà été tiré res = False for PositionCur in self.positionsOcuppees: if (Position.getX() == PositionCur.getX() and Position.getY() == PositionCur.getY() and not(PositionCur.get_Tire())): res = True return res
def positions(self, tank, world):
positions = []
for i in range(self.width - 1):
positions.append(
Position(world.width * (1 + i) / (self.width + 1),
world.height - self.distance,
"LOW BORDER %s/%s" % (i + 1, self.width)))
positions.append(
Position(world.width * (1 + i) / (self.width + 1),
self.distance,
"TOP BORDER %s/%s" % (i + 1, self.width)))
for j in range(self.height - 1):
positions.append(
Position(world.width - self.distance,
world.height * (1 + j) / (self.height + 1),
"RIGHT BORDER %s/%s" % (j + 1, self.height)))
positions.append(
Position(self.distance,
world.height * (1 + j) / (self.height + 1),
"LEFT BORDER %s/%s" % (j + 1, self.height)))
return positions
def find_center(start, end):
center = Position()
center.x = (start.x + end.x) / 2.0
center.y = (start.y + end.y) / 2.0
center.z = (start.z + end.z) / 2.0
return center
def __init__(self,tweets, blacklist= []) :
self.tweets=sorted(tweets,key=lambda tweet : tweet.time)
self.eventStartingTime=self.tweets[0].time
self.eventEndingTime=self.tweets[0].time
self.eventMedianTime=self.tweets[len(tweets)/2].time
self.estimatedEventDuration=self.tweets[len(tweets)/10].delay(self.tweets[(9*len(tweets))/10])
userIdSet=set()
#----- Calcul du centre (latitude,longitude) -----#
self.eventCenter=Position(0,0)
for tweet in tweets :
userIdSet.add(tweet.userId)
self.eventCenter.latitude+=tweet.position.latitude
self.eventCenter.longitude+=tweet.position.longitude
if (tweet.time<self.eventStartingTime) :
self.eventStartingTime=tweet.time
elif (tweet.time>self.eventEndingTime) :
self.eventEndingTime=tweet.time
self.eventCenter.latitude/=len(tweets)
self.eventCenter.longitude/=len(tweets)
#---- Calcul de la distance angulaire maximale -----#
self.eventRadius=self.eventCenter.distance(tweets[0].position)
for tweet in tweets :
distance=self.eventCenter.distance(tweet.position)
if (distance>self.eventRadius) :
self.eventRadius=distance
self.userNumber=len(userIdSet)
self.importantHashtags=self.getImportantHashtags(20, blacklist)
self.hashtags=self.getImportantHashtags(20, blacklist, False)
def __init__(self, char_id, name, user_id, experience, lvl, weapon_id, armor_id, trait_id,
exp_gain_time, x, y, trait_bonus, alive, connection, weapon=None, armor=None, trait=None):
self.__char_id = char_id
self.cache[self.__char_id] = self
self.name = name
self.user_id = user_id
self.experience = experience
self.lvl = lvl
if exp_gain_time.tzinfo is None:
exp_gain_time = utc.localize(exp_gain_time)
self.exp_gain_time = exp_gain_time
self.weapon_id = weapon_id
self._weapon = weapon
self.armor_id = armor_id
self._armor = armor
self.trait_id = Trait.Traits(trait_id) # This is an enum
self._trait = trait
self.trait_bonus = trait_bonus
self._specials = None
self.position = Position(x, y)
self.alive = alive
self.connection = connection
def initiate(self):
i = 0
for player in self.players:
i += 1
print("jugador: ", i)
posX = 0
posY = 0
for index in range(3):
#tam = int(input("Tamaño del barco "))-1
tam = index + 1
#posX = int(input("Posicion X del barco "))
posX += 2
#posY = int(input("Posicion Y del barco "))
posY = posX
start = Position(posX, posY)
#dir = input("Direccion del barco [U,R,D,L] ")
dir = "D"
if (dir == "U"): #Up
posY -= tam
elif (dir == "D"): #Down
posY += tam
elif (dir == "R"): #Right
posX += tam
elif (dir == "L"): #Left
posX -= tam
end = Position(posX, posY)
player.hud.boatsBoard.pushNewBoat(Boat(start, end))
player.hud.mostrarBB()
def Move(self):
"""
input:
none
output:
none
Description:
Moves the snake's head one unit in the direction of travel, as def-
ined by self.direction. The rest of the snake's body will move to
where the previous segment used to be.
"""
grow = self.segmentsToGrow > 0
if (grow):
self.segmentsToGrow -= 1
lastPosition = Position(
self.snakeSegments[-1].position.coordinates)
oldSnakeSegments = [
Snake_Segment(Position(snakeSeg.position.coordinates[:]))
for snakeSeg in self.snakeSegments
]
for index, segment in enumerate(self.snakeSegments[1:]):
self.snakeSegments[index +
1].position.coordinates = oldSnakeSegments[
index].position.coordinates[:]
if (grow):
self.snakeSegments.append(Snake_Segment(lastPosition))
self.snakeSegments[
0].position = self.snakeSegments[0].position + self.direction
def testPositionInSet(self):
mySet = set([Position.zero(), Position(0, 1)])
self.assertEqual(len(mySet), 2)
mySet.add(Position.zero())
self.assertEqual(len(mySet), 2)
self.assertEqual(Position.zero() in mySet, True)
def GetAdvancePositionForSpecificDirection(self, solider,
verticalDirection,
horizontalDirection):
try:
if (solider.Position.Row + verticalDirection < 0
or solider.Position.Column + horizontalDirection < 0):
return None
if (self.BoardState[solider.Position.Row + verticalDirection][
solider.Position.Column + horizontalDirection] == None):
return Position(solider.Position.Row + verticalDirection,
solider.Position.Column + horizontalDirection)
if (solider.Position.Row + 2 * verticalDirection < 0
or solider.Position.Column + 2 * horizontalDirection < 0):
return None
if (solider.color !=
self.BoardState[solider.Position.Row + verticalDirection][
solider.Position.Column + horizontalDirection].Color):
if (self.BoardState[solider.Position.Row + verticalDirection *
2][solider.Position.Column +
2 * horizontalDirection] == None):
return Position(
solider.Position.Row + verticalDirection * 2,
solider.Position.Column + 2 * horizontalDirection)
except IndexError:
return None
def getShips(agent):
carrier = Ship("Carrier", [1, 1, 1, 1, 1],
100,
Position(2, 3),
Ship.ORIENTATION_90_DEG,
immovable=True)
battleship = Ship("Battleship", [1, 1, 1, 1],
80,
Position(0, 0),
Ship.ORIENTATION_0_DEG,
immovable=True)
cruiser = Ship("Cruiser", [1, 1, 1],
60,
Position(6, 2),
Ship.ORIENTATION_180_DEG,
immovable=True)
submarine = Ship("Submarine", [1, 1, 1],
60,
Position(8, 1),
Ship.ORIENTATION_90_DEG,
immovable=True)
destroyer = Ship("Destroyer", [1, 1],
40,
Position(6, 6),
Ship.ORIENTATION_0_DEG,
immovable=True)
return [carrier, battleship, cruiser, submarine, destroyer]
def test_update(self):
pos = Position(toVector(500., 1100., 250.))
vel = Velocity(toVector(10., 20., 5.))
pos.update(vel, 1.)
self.assertEqual(510., pos.values[0])
self.assertEqual(1120., pos.values[1])
self.assertEqual(255., pos.values[2])
def __init__(self, maze_dim = None, file_path = None):
if file_path is not None:
with open(file_path, 'rb') as f_in:
# First line should be an integer with the maze dimensions
self.dim = int(f_in.next())
else:
self.dim = maze_dim
self.cells = {}
for x in range(self.dim):
for y in range(self.dim):
pos = Position(x, y)
cell = MazeCell(pos)
self.cells[pos] = cell
# West wall
if pos.x == 0:
cell.walls[w] = Wall(True)
else:
cell.walls[w] = self.cells[pos.add(w)].walls[e]
# East wall
if pos.x == self.dim-1 or (pos.x == 0 and pos.y == 0):
cell.walls[e] = Wall(True)
else:
cell.walls[e] = Wall(None)
# South wall
if pos.y == 0:
cell.walls[s] = Wall(True)
else:
cell.walls[s] = self.cells[pos.add(s)].walls[n]
# North wall
if pos.y == self.dim-1:
cell.walls[n] = Wall(True)
else:
cell.walls[n] = Wall(None)
if file_path is not None:
self.read_from_file(file_path)
def __init__(self, direction: float, port: int, ip: str ='keuper-labs.org'):
self.measurements = None
self.IP = ip
self.PORT = port
zumi_no = int(int(self.PORT) - 9000)
# Connecting via RPC
rpyc.core.protocol.DEFAULT_CONFIG['allow_pickle'] = True
conn = rpyc.connect(ip, port)
self.zumi = conn.root
self.position = Position(zumi_no, direction)
# Creating directory for zumi data
self.directory = "Zumi_{}".format(port - 9000)
try:
os.makedirs(self.directory)
except FileExistsError:
# directory already exists
pass
# Creating directory for top-cam data
self.directory_two = "{}/Data_from_{}".format(self.directory, datetime.now().strftime("%m-%d-%Y"))
try:
os.makedirs(self.directory_two)
except FileExistsError:
# directory already exists
pass
self.csv_name = "{}/IR_from_{}.csv".format(self.directory_two, datetime.now().strftime("%H-%M-%S"))
# self.csv_name = "{}/IR_from_{}.csv".format(self.directory,datetime.now().strftime("%H-%M-%S"))
print("Zumi Initialized")
def __init__(self, tweets):
self.tweets = sorted(tweets, key=lambda tweet: tweet.time)
self.eventStartingTime = self.tweets[0].time
self.eventEndingTime = self.tweets[0].time
self.eventMedianTime = self.tweets[len(tweets) / 2].time
self.estimatedEventDuration = self.tweets[len(tweets) / 10].delay(
self.tweets[(9 * len(tweets)) / 10])
userIdSet = set()
self.eventCenter = Position(0, 0)
for tweet in tweets:
userIdSet.add(tweet.userId)
self.eventCenter.latitude += tweet.position.latitude
self.eventCenter.longitude += tweet.position.longitude
if (tweet.time < self.eventStartingTime):
self.eventStartingTime = tweet.time
elif (tweet.time > self.eventEndingTime):
self.eventEndingTime = tweet.time
self.eventCenter.latitude /= len(tweets)
self.eventCenter.longitude /= len(tweets)
self.eventRadius = self.eventCenter.distance(tweets[0].position)
for tweet in tweets:
distance = self.eventCenter.distance(tweet.position)
if (distance > self.eventRadius):
self.eventRadius = distance
self.userNumber = len(userIdSet)
self.importantHashtags = self.getImportantHashtags()
def main():
#Construct nodes
start_a = Position(2, 3, 4)
end_a = Position(0, 1, 2)
length_a = 4
width_a = 6
height_a = 2
node_a = Node(start_a, end_a, length_a, width_a, height_a)
start_b = Position(0, 0, 1)
end_b = Position(0, 1, 1)
length_b = 3
width_b = 2
height_b = 8
node_b = Node(start_b, end_b, length_b, width_b, height_b)
#Check for static collision
static_hit = CollisionDetection.check_for_collision(node_a, node_b)
print('Static hit: ' + str(static_hit))
#Check for linear velocity collision
time_step = 0.2
linear_hit = CollisionDetection.check_for_collision_velocity(
node_a, node_b, time_step)
print('Linear hit with time step (' + str(time_step) + ' seconds): ' +
str(linear_hit))
return
class GameEngine:
"""This is the Game Engine"""
"""Create our ball (i.e, the ConcreteSubject)"""
ball = Football()
"""Create few players (i.e, ConcreteObservers)"""
Owen = Player(ball, "Owen")
Ronaldo = Player(ball, "Ronaldp")
Rivaldo = Player(ball, "Rivaldo")
"""Create few referees (i.e, ConcreteObservers)"""
Mike = Referee(ball, "Mike")
John = Referee(ball, "John")
"""Attach them with the ball"""
ball.AttachObserver(Owen)
ball.AttachObserver(Ronaldo)
ball.AttachObserver(Rivaldo)
ball.AttachObserver(Mike)
ball.AttachObserver(John)
print " After attaching the observers..."
print "Update the position of the ball."
print "At this point, all the observers should be notified"
ball.SetBallPosition(Position())
"""Remove some observers"""
ball.DetachObserver(Owen)
ball.DetachObserver(John)
print " After detaching Owen and John..."
print "Updating the position of ball again"
print "At this point, all the observers should be notified"
ball.SetBallPosition(Position(10, 10, 30))
print "Press any key to continue.."
raw_input()
def open_position(self, action, currency, open_value, currency_amount):
position_id = self.get_id()
# Check if position can be created
if action == "buy":
if open_value > self.balance:
print("buy value exceeds balance")
else:
currency_amount = self.get_currency_amount_from_value(
currency, open_value)
self.positions[position_id] = Position(action, currency,
open_value,
currency_amount,
self.client)
self.balance -= open_value
self.currencies[currency] += currency_amount
if action == "sell":
if currency_amount > self.currencies[currency]:
print("sell value exceeds {} balance".format(currency))
else:
open_value = self.get_value_from_currency_amount(
currency, currency_amount)
self.positions[position_id] = Position(action, currency,
open_value,
currency_amount,
self.client)
self.currencies[currency] -= currency_amount
self.balance += open_value
def can_attack(self, from_pos: Position, to_pos: Position):
if not from_pos.is_in_boundary(self.SIZE) or not to_pos.is_in_boundary(
self.SIZE):
return False
from_piece: Piece = self.board[from_pos.x][from_pos.y]
if from_piece is None:
return False
to_piece: Piece = self.board[to_pos.x][to_pos.y]
if to_piece is None:
return False
if from_piece.player == to_piece.player:
return False
# should beck special moves also (not per piece only)
if to_piece.id == 'K':
available_moves = self.available_piece_moves_c(from_piece,
attack=True)
else:
available_moves = self.available_piece_moves(from_piece,
attack=True)
if to_pos in available_moves:
return True
return False
def getNeighboringPositions(self):
result = []
positions = self.world.getNeighboringPositions(self.position)
for pos in positions:
Org = self.world.getOrganismFromPosition(pos)
print(Org)
if Org.__class__.__name__ == 'Wolf':
antelope_next_pos_x = self.position.x + (self.position.x -
Org.position.x) * 2
antelope_next_pos_y = self.position.y + (self.position.y -
Org.position.y) * 2
if antelope_next_pos_x >= 0 and antelope_next_pos_x < self.world.worldX and antelope_next_pos_y >= 0 and antelope_next_pos_y < self.world.worldY:
result.append(
Position(xPosition=antelope_next_pos_x,
yPosition=antelope_next_pos_y))
else:
print("Atakuję ")
antelope_next_pos_x = Org.position.x
antelope_next_pos_y = Org.position.y
result.append(
Position(xPosition=antelope_next_pos_x,
yPosition=antelope_next_pos_y))
return result
return self.world.filterPositionsWithoutAnimals(
self.world.getNeighboringPositions(self.position))
def __init__(self, _pos="A0", _player=0, _inGoal=False, _outHome=False):
self.pos = Position(_pos)
self.x = self.pos.getX()
self.y = self.pos.getY()
self.occupyplayer = _player # integer
self.inGoal = _inGoal # boolean
self.outHome = _outHome # boolean
def print_city_with_cars(self, car_position_list):
"""
Prints City Grid, adding cars in given positions
"""
g_str = ""
g_str += "".ljust(3)
for i in range(len(self.grid)):
g_str += str(i).ljust(4)
g_str += "\n"
for i in range(len(self.grid)):
g_str += str(i).ljust(4)
for j in range(len(self.grid[0])):
if Position(j, i) in car_position_list:
g_str += (
"c" +
str(car_position_list.index(Position(j, i)))).ljust(4)
elif (j + 1, i + 1) in self.building_positions:
g_str += str(self.num_free_park_spaces(j + 1,
i + 1)).ljust(4)
elif self.grid[i][j] == LaneType.Building:
g_str += str(self.grid[i][j]).ljust(
4, str(self.grid[i][j]))
else:
g_str += str(self.grid[i][j]).ljust(4)
g_str += "\n"
g_str = g_str[:len(g_str) - 1]
return g_str
def use_lizard(self, action, game_map, player_info):
max_ = speed_bracket[player_info.damage]
if action == Commands.USE_LIZARD:
if not itemize_command(action) in player_info.power_ups:
return {
"player_info": player_info,
"game_map": game_map,
"progression": False,
"additional_score": -1000
}
y = player_info.position.y
x = player_info.position.x + player_info.speed
progress = True # goes deeper into the game tree?
if not x in game_map[y].keys():
x = [i for i in game_map[y].keys()][-1]
progress = False
a = AStar()
path = a.forward(player_info.position, Position(y, x), game_map)
p_speed = 0 # plaussible speeds
if not player_info.boosting:
if "BOOST" in player_info.power_ups:
p_speed = max_ - player_info.speed
else:
n_speed = max_ if player_info.boosting else speeds[
player_info.speed].right
p_speed = n_speed if n_speed else player_info.speed
score = 0
if True:
score += 4
player_info.power_ups.remove(itemize_command(action))
score -= abs((player_info.position.x + player_info.speed) -
(player_info.position.x + p_speed))
score -= abs((player_info.position.x + player_info.speed) -
[i for i in game_map[y].keys()][-1])
# walking the paths to collect damages/speed-deduction and points
path_walk = self.walk_path(path, game_map, is_lizard=True)
score += len(
path_walk["powerups"]
) * 4 # <-- actually using of powerups will justify this more
score += self.compute_wall_damages(path_walk["obstacles"],
player_info)
player_info.power_ups += path_walk["powerups"]
if progress: player_info.position = Position(y, x)
return {
"player_info": player_info,
"game_map": game_map,
"progression": progress,
"additional_score": score
}
def aUnBateau(self,Position): # Renvoie True si la un bateau se trouve à une position donnée res = False for PositionCur in self.positionsOcuppees: if (Position.getX() == PositionCur.getX() and Position.getY() == PositionCur.getY()): res = True return res
def consequences(self, atackingOrganism): result = [] if self.power > atackingOrganism.power: result.append(Action(ActionEnum.A_REMOVE, Position(xPosition=-1, yPosition=-1), 0, atackingOrganism)) else: result.append(Action(ActionEnum.A_REMOVE, Position(xPosition=-1, yPosition=-1), 0, self)) return result
class Vehicle():
def __init__(self, row, col):
self.position = Position(row, col)
self.colected_food = 0
self.solution = None
'''
direction: indica a direcao a qual o veiculo devera se mover (o valor deve ser uma das constantes em OperationTypes.py) // 'up' | 'right' | ...
'''
def move(self, direction, limit=None):
if direction == OperationTypes.MOVE_UP:
new_position = self.position.move_up()
if new_position is not None:
self.position = new_position
elif direction == OperationTypes.MOVE_RIGHT:
new_position = self.position.move_right(limit)
if new_position is not None:
self.position = new_position
elif direction == OperationTypes.MOVE_DOWN:
new_position = self.position.move_down(limit)
if new_position is not None:
self.position = new_position
elif direction == OperationTypes.MOVE_LEFT:
new_position = self.position.move_left()
if new_position is not None:
self.position = new_position
'''
matrix: corresponde apenas a uma matriz de objetos do tipo Cell
search_type: indica o tipo de busca a ser realizada // 'DFS' | 'BFS' | ...
'''
def search_food(self, matrix, search_type):
cell_food = Cell()
cell_food.set_type(CellTypes.TYPE_FOOD, CellTypes.FOOD_COLOR)
self.solution = search(self.position, cell_food, matrix, search_type)
return self.solution
def run_solution(self, row_limit, col_limit, env):
if self.solution is not None:
operations = self.get_operations(self.solution, [])
for op in operations:
if op == OperationTypes.MOVE_LEFT or op == OperationTypes.MOVE_UP:
self.move(op)
elif op == OperationTypes.MOVE_RIGHT:
self.move(op, col_limit)
elif op == OperationTypes.MOVE_DOWN:
self.move(op, row_limit)
env.update_vehicle_position(self.position)
self.colected_food += 1
def get_operations(self, node, operations):
if node.previousNode is not None:
operations.insert(0, node.operation)
return self.get_operations(node.previousNode, operations)
return operations
def test_turn_right_from_west(self):
position = Position(direction=Direction.west)
position.turn(Turn.right)
self.assertEqual(position.x_coord, 0)
self.assertEqual(position.y_coord, 0)
self.assertEqual(position.direction, Direction.north)
def test_go_forwards_3(self):
position = Position()
position.walk_forward(3)
self.assertEqual(position.x_coord, 0)
self.assertEqual(position.y_coord, 3)
self.assertEqual(position.direction, Direction.north)
def test_go_forwards_4_from_east(self):
position = Position(Direction.east)
position.walk_forward(4)
self.assertEqual(position.x_coord, 4)
self.assertEqual(position.y_coord, 0)
self.assertEqual(position.direction, Direction.east)
def test_turn_left_from_west(self):
position = Position(direction=Direction.west)
position.turn(Turn.left)
self.assertEqual(position.x_coord, 0)
self.assertEqual(position.y_coord, 0)
self.assertEqual(position.direction, Direction.south)
def kill_neighbors(self):
position = self.position
for dx in range(-1, 1):
for dy in range(-1, 1):
if not (dx == 0 and dx == dy):
killing_position = Position(position.x + dx, position.y + dy)
if killing_position.is_valid():
self.kill_if_animal(killing_position)
def test_go_forwards_2_from_south(self):
position = Position(Direction.south)
position.walk_forward(2)
self.assertEqual(position.x_coord, 0)
self.assertEqual(position.y_coord, -2)
self.assertEqual(position.direction, Direction.south)
def send_station(self, x, y): if self.Name == self.state.Turn: input = str(x)+","+str(y) pos = Position(input, self.Name) if is_valid(self.state.Board, pos) == False: print "[Position Invalid, Enter Again]" else: self.sock.send(pos.to_str())
class Event :
def __init__(self,tweets) :
self.tweets=sorted(tweets,key=lambda tweet : tweet.time)
self.eventStartingTime=self.tweets[0].time
self.eventEndingTime=self.tweets[0].time
self.eventMedianTime=self.tweets[len(tweets)/2].time
self.estimatedEventDuration=self.tweets[len(tweets)/10].delay(self.tweets[(9*len(tweets))/10])
userIdSet=set()
self.eventCenter=Position(0,0)
for tweet in tweets :
userIdSet.add(tweet.userId)
self.eventCenter.latitude+=tweet.position.latitude
self.eventCenter.longitude+=tweet.position.longitude
if (tweet.time<self.eventStartingTime) :
self.eventStartingTime=tweet.time
elif (tweet.time>self.eventEndingTime) :
self.eventEndingTime=tweet.time
self.eventCenter.latitude/=len(tweets)
self.eventCenter.longitude/=len(tweets)
self.eventRadius=self.eventCenter.distance(tweets[0].position)
for tweet in tweets :
distance=self.eventCenter.distance(tweet.position)
if (distance>self.eventRadius) :
self.eventRadius=distance
self.userNumber=len(userIdSet)
self.importantHashtags=self.getImportantHashtags()
def getImportantHashtags(self, topk=10) :
dictHashtags={}
for t in self.tweets :
for h in t.hashtags :
try : dictHashtags[h.lower()]+=1
except KeyError : dictHashtags[h.lower()]=1
importantHashtags=sorted(list(dictHashtags), key=lambda element : dictHashtags[element], reverse=True)[0:min(topk,len(dictHashtags))]
return importantHashtags
#---------------- Visualize -----------------------------------------------------------------------#
def __str__(self) :
NUM_DIGIT=10**2
SEPARATOR="\t|"
S="|"+SEPARATOR.join([str(self.eventMedianTime),
str(int(self.estimatedEventDuration)),
str(float(int(NUM_DIGIT*self.eventCenter.latitude))/NUM_DIGIT),
str(float(int(NUM_DIGIT*self.eventCenter.longitude))/NUM_DIGIT),
str(float(int(NUM_DIGIT*self.eventRadius))/NUM_DIGIT),
str(self.userNumber),
str(len(self.tweets)),
",".join(self.importantHashtags)])+SEPARATOR
return S.encode("utf-8")
def from_string( string ):
components = string.replace("[","").replace("]","").replace(" ","").split(";")
state = []
for position in components:
if position is not "":
state.append( Position.from_string( position ) )
return Pattern( state )
def __init__(self,tweets) :
self.tweets=sorted(tweets,key=lambda tweet : tweet.time)
self.eventStartingTime=self.tweets[0].time
self.eventEndingTime=self.tweets[0].time
self.eventMedianTime=self.tweets[len(tweets)/2].time
self.estimatedEventDuration=self.tweets[len(tweets)/10].delay(self.tweets[(9*len(tweets))/10])
userIdSet=set()
self.eventCenter=Position(0,0)
for tweet in tweets :
userIdSet.add(tweet.userId)
self.eventCenter.latitude+=tweet.position.latitude
self.eventCenter.longitude+=tweet.position.longitude
if (tweet.time<self.eventStartingTime) :
self.eventStartingTime=tweet.time
elif (tweet.time>self.eventEndingTime) :
self.eventEndingTime=tweet.time
self.eventCenter.latitude/=len(tweets)
self.eventCenter.longitude/=len(tweets)
self.eventRadius=self.eventCenter.distance(tweets[0].position)
for tweet in tweets :
distance=self.eventCenter.distance(tweet.position)
if (distance>self.eventRadius) :
self.eventRadius=distance
self.userNumber=len(userIdSet)
self.importantHashtags=self.getImportantHashtags()
def __init__(self, maze_dim, dump_mazes=False):
self.location = Position(0, 0)
self.heading = Direction(0)
self.maze_map = MazeMap(maze_dim)
self.timestep = 0
self.run_number = 0
self.found_goal = False
self.dump_mazes = dump_mazes
self.planner = Planner(self.maze_map) # planner needs to be set by sub-class
def placerBateaux(i=0):
# i = BateauCourant
while (Partie.get_JoueurActif().get_Bateaux().get_NombreBateauxNonPlaces() > 0):
header()
print "===> Placer vos bateaux <====\n"
print Partie.get_JoueurActif().get_NomJoueur()+" >> "+str(Partie.get_JoueurActif().get_Bateaux().get_NombreBateauxNonPlaces())+ " bateaux à placer."
print "Bateau selectionné: \nTaille:"+str(Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).get_taille())+"\n"
print("Entrez une coordonnee: ")
X = int(raw_input("X: "))
Y = int(raw_input("Y: "))
LastPos=Position(X,Y,Partie.get_JoueurActif().get_Bateaux().get_Bateau(i))
try:
Partie.get_JoueurActif().get_Grille().marquerPosition(LastPos)
k=1
while(k < Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).get_taille()):
header()
print "===> Placer vos bateaux <====\n"
print Partie.get_JoueurActif().get_NomJoueur()+" >> "+str(Partie.get_JoueurActif().get_Bateaux().get_NombreBateauxNonPlaces())+ " bateaux à placer."
print "Bateau selectionné: \nTaille:"+str(Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).get_taille())+"\n"
print("Entrez une coordonnee: ")
X = int(raw_input("X: "))
Y = int(raw_input("Y: "))
pos=Position(X,Y,Partie.get_JoueurActif().get_Bateaux().get_Bateau(i))
if (pos.est_AdjacenteY(LastPos) or pos.est_AdjacenteX(LastPos)):
try:
Partie.get_JoueurActif().get_Grille().marquerPosition(pos)
k = k+1
LastPos = pos
except:
raw_input("Case occuppée et/ou hors grille !")
else:
raw_input("Mauvaise case, non adjacente.")
# k == taille(Bateau)
Partie.get_JoueurActif().get_Bateaux().get_Bateau(i).set_estPlace()
i=i+1
raw_input("Bateau place, Bateau suivant")
except:
raw_input("Case occuppée et/ou hors grille !")
placerBateaux(i)
def reset(self):
"""
Move the robot back to 0,0 and facing north. Also changes the run_number to 1. Call this when you are ready to
start the second run.
:return: Returns the reset string for convenience.
"""
self.location = Position(0, 0)
self.heading = Direction(0)
self.run_number = 1
print "Number of moves in first run: {}".format(self.timestep)
print "Exploration efficiency: {}".format(self.get_exploration_efficiency())
self.planner.replan(self.location, self.heading)
return "Reset", "Reset"
def runStrategy(self, ticker, merged):
print '\nRunning strategy on ' + ticker + '..'
time.sleep(2)
# First, do analytics to figure out how to execute the strategy.
# Return lagged correlations and (10dayMA) of those lagged correlations.
analyticsObj = Analytics()
s_p_r_ma = analyticsObj.getAnalytics(ticker, merged)
# Second, determine the position.
positionObj = Position()
s_p_r_ma_pos = positionObj.getPosition(ticker, s_p_r_ma)
# Third, run the strategy!
# Return a performance list (with dates?)
strategyObj = RunStrategy()
strategyResults = strategyObj.getResults(ticker, s_p_r_ma_pos)
# Fourth, determine the metrics.
metricsObj = StrategyMetrics()
metrics = metricsObj.getStrategyMetrics(ticker, strategyResults, s_p_r_ma_pos)
return metrics
def quelBateau(self,Position): # Si Position.aUnBateau() for PositionCur in self.positionsOcuppees: if (Position.getX() == PositionCur.getX() and Position.getY() == PositionCur.getY()): res = PositionCur.getBateau() return res
def __init__(self,poiId,longitude,latitude,visits=[]) :
self.id=poiId
Position.__init__(self,longitude,latitude)
self.visits=visits[:]
self.accumulatedStayTime=sum([visit.duration() for visit in self.visits])
def bateauEnVue(self,Position): res = False for Pos in self.positionsOcuppees: if (Position.getX() == Pos.getX() or Position.getY() == Pos.getY()): res = True return res
def move(self, color, movetext):
m = list(movetext)
logging.debug("starting move with len(m): " + str(len(m)))
# Nbxd2(+|#) -- kNight in column B takes piece in d2
destination = None
x = None
y = None
for i in range(len(m)-1, -1, -1):
logging.debug("i=" + str(i) + ", m[i]=" + m[i])
if m[i] == "x" or m[i] == "+" or m[i] == "#":
skip = True
else:
if destination is not None:
x = None
y = None
if m[i] not in ["K", "Q", "B", "N", "R"]:
if m[i].isdigit():
y = m[i]
else:
if m[i] == "a":
x = 1
elif m[i] == "b":
x = 2
elif m[i] == "c":
x = 3
elif m[i] == "d":
x = 4
elif m[i] == "e":
x = 5
elif m[i] == "f":
x = 6
elif m[i] == "g":
x = 7
elif m[i] == "h":
x = 8
if destination is None and x is not None and y is not None:
destination = int(y) * 8 - int(x)
else:
if x is not None and y is not None:
origin = int(y) * 8 - int(x)
else:
origin = m[i]
else:
if m[i] == "K" and color == "W":
piece = whiteking
elif m[i] == "Q" and color == "W":
piece = whitequeen
elif m[i] == "B" and color == "W":
piece = whitebishop
elif m[i] == "N" and color == "W":
piece = whiteknight
elif m[i] == "R" and color == "W":
piece = whiterook
elif color == "W":
piece = whitepawn
elif m[i] == "K" and color == "B":
piece = blackking
elif m[i] == "Q" and color == "B":
piece = blackqueen
elif m[i] == "B" and color == "B":
piece = blackbishop
elif m[i] == "N" and color == "B":
piece = blackknight
elif m[i] == "R" and color == "B":
piece = blackrook
else:
piece = blackpawn
if not origin.isdigit():
pos = Position(self.moves)
origin = pos.find_origin(piece, destination, origin)
# TODO: castling, king-side and queen-side
# if origin is non specific (None or just a column), determine origin square
# modify BitVector to move piece to new square
# use concat (+) with two splices to move bits around - bv1[6:9] = bv2[0:3]
return piece, destination, origin
class RobotController(object):
"""
This is the base class for all robot controllers. You must override next_move and initialize self.planner in
a sub-class.
"""
def __init__(self, maze_dim, dump_mazes=False):
self.location = Position(0, 0)
self.heading = Direction(0)
self.maze_map = MazeMap(maze_dim)
self.timestep = 0
self.run_number = 0
self.found_goal = False
self.dump_mazes = dump_mazes
self.planner = Planner(self.maze_map) # planner needs to be set by sub-class
def next_move(self, sensors):
"""
This is the main method to implement for a controller. Make sure that the move the controller returns is a valid
move (it doesn't try to go through walls). If it does, the location and heading class members will be incorrect.
:param sensors: The distance in squares to the next wall for the left, middle and right sensors.
:return: The sub-class should return the next move as a (int, int). The first is the rotation
(could be -90, 0 or 90), the second is the number of squares to move (from -3 to 3).
"""
raise NotImplemented("Implement by overriding in sub-class.")
def update(self, sensors):
"""
Convenience function for updating the maze, re-planning (if the maze was updated), and dumping the maze for
debugging.
:param sensors:
:return: True if maze was updated
"""
self.timestep += 1
maze_updated = self.maze_map.update(self.location, self.heading, sensors)
if maze_updated:
self.planner.replan(self.location, self.heading)
if self.dump_mazes:
self.maze_map.dump_to_file(os.path.join(os.curdir, "known_maze.txt"))
return maze_updated
def move(self, rotation, movement):
"""
Update the current location and heading for the class. This should be called in the sub-class after choosing
a move.
:type rotation: int
:type movement: int
:param rotation: The rotation to perform
:param movement: The number of squares to move
:return: None
"""
self.heading = self.heading.rotate(rotation)
direction_of_movement = self.heading if movement > 0 else self.heading.flip()
for i in range(abs(movement)):
self.location = self.location.add(direction_of_movement)
if self.maze_map.at_goal(self.location):
self.found_goal = True
def reset(self):
"""
Move the robot back to 0,0 and facing north. Also changes the run_number to 1. Call this when you are ready to
start the second run.
:return: Returns the reset string for convenience.
"""
self.location = Position(0, 0)
self.heading = Direction(0)
self.run_number = 1
print "Number of moves in first run: {}".format(self.timestep)
print "Exploration efficiency: {}".format(self.get_exploration_efficiency())
self.planner.replan(self.location, self.heading)
return "Reset", "Reset"
def show_current_policy_and_map(self):
"""
For visualization of the maze and policy when using the A* planner.
:return: None
"""
vis = Visualizer(self.maze_map.dim)
vis.draw_maze(Maze('known_maze.txt'))
vis.draw_policy(reversed(self.planner.policy), self.location, self.heading)
vis.show_window()
def get_exploration_efficiency(self):
return self.maze_map.get_num_known_walls() / float(self.timestep)
def __init__(self,time,longitude,latitude) :
self.time=time
Position.__init__(self,longitude,latitude)
def grab_position(keyword, gj='', xl='', yx='', gx='', st='', lc='', workAddress='', city='全国'):
reload(sys)
sys.setdefaultencoding('utf-8')
url = "http://www.lagou.com/jobs/list_" + keyword
params = {'spc': 1, 'pl': "", 'xl': xl, 'yx': yx, 'gx': gx, 'st': st, 'labelWords': '', 'city': city,
'requestId': ""}
list = requests.get(url, params=params)
parser = BeautifulSoup(list.content)
# print list.content
posistions = []
companys = []
pos_html = parser.find_all("div", class_="hot_pos_l")
cmp_html = parser.find_all("div", class_="hot_pos_r")
for i in range(len(pos_html)):
p2 = BeautifulSoup(repr(pos_html[i]))
cmp_parser = BeautifulSoup(repr(cmp_html[i]))
p = Position()
c = Company()
# 抓取职位信息
spans = p2.find_all('span')
p.salary = spans[1].text
p.experience = spans[2].text
p.edu = spans[3].text
p.candy = spans[4].text
p.name = pos_html[i].div.a.text
p.place = pos_html[i].div.span.text
p_url = pos_html[i].div.a['href']
p_detail = requests.get(p_url)
detail_parser = BeautifulSoup(p_detail.content)
p.detail = detail_parser.find_all("dd", class_="job_bt")[0].text
# 抓取公司信息
hot_pos_r = cmp_parser.find_all("span")
if len(hot_pos_r) == 4:
c.field = hot_pos_r[0].text
c.founder = hot_pos_r[1].text
c.funding = hot_pos_r[2].text
c.extent = hot_pos_r[3].text
elif len(hot_pos_r) == 3:
c.field = hot_pos_r[0].text
c.funding = hot_pos_r[1].text
c.extent = hot_pos_r[2].text
# 关联
tmp = cmp_parser.find_all("a")
c_id_a = tmp[1]
c.name = c_id_a.text
c_id = c_id_a['href']
c_id = re.findall('\d+', c_id)
cmp_page = requests.get(c_id_a['href'])
page_parser = BeautifulSoup(cmp_page.content)
intro = page_parser.find_all("div", class_="c_intro")
if len(intro) > 0:
c.mainPage = intro[0].text
else:
c.mainPage = '暂无简介'
p.cmp_id = c_id
c.id = c_id
write_to_db.add_pos(p, 'position')
write_to_db.add_pos(c, 'company')
print len(posistions)
def isThisRaidOrSneak(self, tempBoxState, rowIndex, columnIndex, firstPlayerValue, secondPlayerValue): raid = False positions = [] # Determine the position above if(rowIndex > 0): upPosition = Position(0, 0) upPosition.rowIndex = rowIndex - 1 upPosition.columnIndex = columnIndex if(tempBoxState[upPosition.rowIndex][upPosition.columnIndex].occupiedBy == firstPlayerValue): raid = True # Determine the position to the right if(columnIndex < (len(tempBoxState)-1)): rightPosition = Position(0, 0) rightPosition.rowIndex = rowIndex rightPosition.columnIndex = columnIndex + 1 if(tempBoxState[rightPosition.rowIndex][rightPosition.columnIndex].occupiedBy == firstPlayerValue): raid = True # Determine the position below if(rowIndex < len(tempBoxState)-1): bottomPosition = Position(0, 0) bottomPosition.rowIndex = rowIndex + 1 bottomPosition.columnIndex = columnIndex if(tempBoxState[bottomPosition.rowIndex][bottomPosition.columnIndex].occupiedBy == firstPlayerValue): raid = True # Determine the position to the left if(columnIndex > 0): leftPosition = Position(0, 0) leftPosition.rowIndex = rowIndex leftPosition.columnIndex = columnIndex - 1 if(tempBoxState[leftPosition.rowIndex][leftPosition.columnIndex].occupiedBy == firstPlayerValue): raid = True return raid
def enleverPosition(self,Position): for PositionCur in self.positionsOcuppees: if (Position.getX() == PositionCur.getX() and Position.getY() == PositionCur.getY()): PositionCur.set_Tire()
#!/usr/bin/python
from Servo import Servo
from Position import Position
servo0 = Servo(0)
servo1 = Servo(1)
p = Position()
while True:
(x_pos, y_pos, z_pos) = p.get_position()
print("X:{} Y:{} Z:{}".format(x_pos, y_pos, z_pos))
x_pos_target = int((1.0 + x_pos) * 50)
y_pos_target = int((1.0 + y_pos) * 50)
servo0.move_to_position(x_pos_target)
servo1.move_to_position(y_pos_target)
def getEnemyBoxPositionsAdjacentToTheBox(self, tempBoxState, rowIndex, columnIndex, firstPlayerValue, secondPlayerValue): raidOrSneak = True raidOrSneak = self.isThisRaidOrSneak(tempBoxState, rowIndex, columnIndex, firstPlayerValue, secondPlayerValue) positions = [] if(raidOrSneak == True): # Determine the position above if(rowIndex > 0): upPosition = Position(0, 0) upPosition.rowIndex = rowIndex - 1 upPosition.columnIndex = columnIndex if(tempBoxState[upPosition.rowIndex][upPosition.columnIndex].occupiedBy == secondPlayerValue): positions.append(upPosition) # print "up added" # Determine the position to the right if(columnIndex < (len(tempBoxState)-1)): rightPosition = Position(0, 0) rightPosition.rowIndex = rowIndex rightPosition.columnIndex = columnIndex + 1 if(tempBoxState[rightPosition.rowIndex][rightPosition.columnIndex].occupiedBy == secondPlayerValue): positions.append(rightPosition) # print "right added" # Determine the position below if(rowIndex < len(tempBoxState)-1): bottomPosition = Position(0, 0) bottomPosition.rowIndex = rowIndex + 1 bottomPosition.columnIndex = columnIndex if(tempBoxState[bottomPosition.rowIndex][bottomPosition.columnIndex].occupiedBy == secondPlayerValue): positions.append(bottomPosition) # print "bottom added" # Determine the position to the left if(columnIndex > 0): leftPosition = Position(0, 0) leftPosition.rowIndex = rowIndex leftPosition.columnIndex = columnIndex - 1 if(tempBoxState[leftPosition.rowIndex][leftPosition.columnIndex].occupiedBy == secondPlayerValue): positions.append(leftPosition) # print "left added" return positions
def coordonneValide(self,Position): # Return true si la position appartient à la grille return (Position.getX() <= self.largeur and Position.getX() >= 0 and Position.getY() <= self.hauteur and Position.getY() >= 0)
