def test_pubkey_fetch(self): sig = util.sign(self.consultant_privkey, False, "add_pubkey") self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey) #then fetch it #sig = util.sign(self.client_privkey, False, "fetch_pubkey", self.client_id, b64encode(self.tree_id)) sig = util.sign(self.client_privkey, False, "fetch_pubkey") expected = self.client_pubkey result = self.server.fetch_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id)) self.assertEqual(expected, result)
def test_pubkey_del(self): #first add the key sig = util.sign(self.consultant_privkey, False, "add_pubkey") self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey) #then remove it #sig = util.sign(self.consultant_privkey, False, "del_pubkey", self.client_id, b64encode(self.tree_id)) sig = util.sign(self.consultant_privkey, False, "del_pubkey") expected = "Removed key for client {id}".format(id=self.client_id) result = self.server.del_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id)) self.assertEqual(expected, result)
def check_expired(self, game_info: GameInformation) -> bool: # expired if ball is of wrong half or on direct trajectory toward goal # check if ball on defensive half ball_location = game_info.ball.location if util.sign(ball_location.y) != util.sign(game_info.me.team): self.expired = True # check direction of ball movement ball_direction = game_info.ball.velocity return self.expired
def test_clear_keys(self): # first add the key sig = util.sign(self.consultant_privkey, False, "add_pubkey") self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey) # then fetch it sig = util.sign(self.client_privkey, False, "fetch_pubkey") expected = self.client_pubkey result = self.server.fetch_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id)) self.assertEqual(expected, result) # then clear the keys sig = util.sign(self.consultant_privkey, False, "clear_keys") result = self.server.clear_keys(b64encode(sig)) self.assertTrue(result)
def execute(self, game_info: GameInformation): """Attempts to drive into the ball in a direction that hits the ball towards the goal. Overrides the State class's execute function. The ground controller is automatically used. The target location is on the outside of the ball on a line connecting the ball and the opponents goal. Attributes: game_info: information detailing the current status of various game objects """ team = util.sign(game_info.me.team) target_goal = util.GOAL_HOME * -team ball_to_goal = target_goal - game_info.ball.location # distance_to_goal = ball_to_goal.length() direction_to_goal = ball_to_goal.normalized() aim_location = game_info.ball.location - (direction_to_goal * util.BALL_RADIUS) local_target = relative_location(game_info.me.location, game_info.me.rotation, aim_location) self.debug['target'] = aim_location self.next_controller_state = ground_controller(game_info, local_target)
def check_expired(self, game_info: GameInformation): """If the ball is not reasonably close to being between the car and the goal, the state expires""" ball_direction = game_info.ball.local_location goal_location = relative_location( game_info.me.location, game_info.me.rotation, util.GOAL_HOME * -util.sign(game_info.me.team)) angle = ball_direction.ang_to(goal_location) if angle < (math.pi / 2): return False return True
def standing_on_platform(arbiter, space, data): enemy_body = arbiter.shapes[0].body position_x = arbiter.shapes[1].body.position.x enemy_body.max_walk_x = max(arbiter.shapes[1].get_vertices(), key=lambda k: k.x).x + position_x enemy_body.min_walk_x = min(arbiter.shapes[1].get_vertices(), key=lambda k: k.x).x + position_x enemy_body.current_max_velocity = arbiter.shapes[ 1].body.velocity.x + sign( enemy_body.velocity.x) * Enemy.max_relative_velocity enemy_body.touching_ground = arbiter.shapes[1].body return True
def standing_on_platform(arbiter, space, data): normal = Vec2d(0, -1) if Player.compare_velocity(arbiter.contact_point_set.normal, normal): player_body = arbiter.shapes[0].body player_body.still = Player.compare_velocity( arbiter.shapes[0].body.velocity, arbiter.shapes[1].body.velocity) player_body.current_max_velocity = arbiter.shapes[ 1].body.velocity.x + sign( player_body.velocity.x) * Player.running_velocity player_body.touching_ground = arbiter.shapes[1].body return True
def get_output(self, gamePacket: GameTickPacket) -> SimpleControllerState: """Calculates the next set of commands for the bot. This function should run 60 times a second, or once for every game tick. This function also calls a set of commands to draw debug information on screen. Args: gamePacket (GameTickPacket): set of current information about the game Returns: SimpleControllerState: the next set of commands for the bot """ self.preprocess(gamePacket) if self.state.expired == True: if AimShot().checkAvailable(self) == True: self.state = AimShot() self.stateMessage = "Aiming" #if Shoot().checkAvailable(self) == True: # self.state = Shoot() # self.stateMessage = "Shooting" elif Defend().checkAvailable(self) == True: self.state = Defend() self.stateMessage = "Defending" else: self.state = BallChase() self.stateMessage = "Chasing" controller_state = self.state.execute(self) team = sign(self.team) ball_side = sign(self.ball.location.y) my_car = gamePacket.game_cars[self.index] message = f"{self.stateMessage} | Team {team} | Ball {ball_side} " action_display = message ball_path = predict_ball_path(self) draw_debug(self.renderer, my_car, gamePacket.game_ball, action_display, ball_path) return controller_state
def setUp(self): self.server = ServerProxy("http://localhost:8000", allow_none=True) self.consultant_id = 0 self.consultant_privkey = "".join(open('./keys/consultant.pem').readlines()) self.consultant_pubkey = "".join(open('./keys/consultant.pub.pem').readlines()) self.client_privkey = "".join(open('./keys/client1.pem').readlines()) self.client_pubkey = "".join(open('./keys/client1.pub.pem').readlines()) self.client_id = 1 self.tree_id = util.digest(self.client_id) # add a pubkey to the serv sig = util.sign(self.consultant_privkey, False, "add_pubkey") #call the server self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey)
def execute(self, agent): self.checkExpired(agent) team = util.sign(agent.team) ball_path = predict_ball_path(agent) danger = False for loc in ball_path: if(math.fabs(loc.y) > math.fabs(util.FIELD_LENGTH / 2)): danger = True target_location = agent.ball.local_location if danger: #aim to hit ball to the side #detect of ball is east or west of bot east_multiplier = util.sign(agent.ball.location.x - agent.me.location.x) #aim for side of the ball aim_location = agent.ball.location + Vec3(east_multiplier * util.BALL_RADIUS, 0, 0) target_location = relative_location(agent.me.location, agent.me.rotation, aim_location) elif agent.ball.local_location.length() > 1500: #get in goal target_location = relative_location(agent.me.location, agent.me.rotation, util.GOAL_HOME * team) elif agent.ball.local_location.length() < 500: return shotController(agent, util.GOAL_HOME * -team) return groundController(agent, target_location)
def execute(self, game_info): # aim to hit ball to the side # detect of ball is east or west of bot east_multiplier = util.sign(game_info.me.location.x - game_info.ball.location.x) # aim for side of the ball aim_location = game_info.ball.location + Vec3( east_multiplier * util.BALL_RADIUS, 0, 0) target_location = relative_location(game_info.me.location, game_info.me.rotation, aim_location) self.debug['target'] = aim_location self.next_controller_state = ground_controller(game_info, target_location)
def execute(self, agent): """Attempts to hit the ball in a way that pushes it toward the goal""" self.checkExpire(agent) team = util.sign(agent.team) targetGoal = util.GOAL_HOME * -team ball_to_goal = targetGoal - agent.ball.location #distance_to_goal = ball_to_goal.length() direction_to_goal = ball_to_goal.normalized() aim_location = agent.ball.location - (direction_to_goal * util.BALL_RADIUS) local_target = relative_location(agent.me.location, agent.me.rotation, aim_location) return groundController(agent, local_target)
def check_expired(self, game_info: GameInformation) -> bool: if util.sign(game_info.ball.location.y) != util.sign( game_info.me.team): self.expired = True return self.expired
def execute(self, game_info): team = util.sign(game_info.me.team) self.next_controller_state = ground_controller( game_info, util.GOAL_HOME * team * -1)
def checkExpire(self, agent): """Determines if the state is no longer useful""" if util.sign(agent.ball.location.y) == util.sign(agent.team): self.expired = True
def checkAvailable(self, agent): """If the ball is between the car and the goal, it is possible to shoot""" ballDirection = agent.ball.local_location goal_location = relative_location(agent.me.location, agent.me.rotation, util.GOAL_HOME*-util.sign(agent.team)) angle = ballDirection.ang_to(goal_location) if angle < (math.pi / 2): return True return False
def checkAvailable(self, agent): """Available when the ball is on the friendly side of the field""" if util.sign(agent.ball.location.y) == util.sign(agent.team): return True return False
def test_pubkey_add_twice(self): sig = util.sign(self.consultant_privkey, False, "add_pubkey") expected = "Tried to add key for client {0} twice!".format(self.client_id) self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey) result = self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey) self.assertEqual(expected, result)
def checkExpired(self, agent): if util.sign(agent.ball.location.y) != util.sign(agent.team): self.expired = True
def get_output(self, game_packet: GameTickPacket) -> SimpleControllerState: """Calculates the next set of commands for the bot. This function should run 60 times a second, or once for every game tick. This function also calls a set of commands to draw debug information on screen. Args: game_packet (GameTickPacket): set of current information about the game Returns: SimpleControllerState: the next set of commands for the bot """ # debugging flags. debug mode tells whether to print messages to console, debug_change flags when a change # occurs that should trigger a debug message debug_mode = True debug_change = False # Keep our boost pad info updated with which pads are currently active # self.boost_pad_tracker.update_boost_status(game_packet) # clear active_sequence when kickoff is starting if self.kickoff_flag is False and game_packet.game_info.is_round_active and \ game_packet.game_info.is_kickoff_pause: self.active_sequence = None self.preprocess(game_packet) game_info = GameInformation(self.me, self.ball) # if there is an active sequence then that gets priority and no other state or controller calculations are done if self.active_sequence is not None and not self.active_sequence.done: self.controller_state = self.active_sequence.tick(game_packet) # if there is no active sequence we proceed with normal state calculations else: """ # kickoff state get priority if self.kickoff_flag: self.state = st.Kickoff() self.state_message = "Kickoff" # get new state if expired elif self.state.check_expired(game_info): debug_change = True if util.sign(self.ball.location.y) == util.sign(self.me.team): self.state = st.Defend() self.state_message = "Defend" elif util.sign(self.ball.location.y) != util.sign(self.me.team): self.state = st.Shoot() self.state_message = "Shoot" else: self.state = st.BallChase() self.state_message = "BallChase" """ self.state = st.BallChase() self.state_message = "BallChase" # execute the current state self.state.execute(game_info) if self.state.has_sequence(): self.active_sequence = self.state.get_sequence() self.controller_state = self.active_sequence.tick(game_packet) else: self.controller_state = self.state.get_next_controller_state() team = util.sign(self.team) ball_side = util.sign(self.ball.location.y) message = f"{self.state_message} | Team {team} | Ball {ball_side}" if debug_change and debug_mode: print(message) # action_display = message # ball_path = util.predict_ball_path(self) # turn_loops = get_turn_circle(self.me.velocity, self.me.location) self.draw_debug(message, self.state.get_debug()['target']) return self.controller_state
def execute(self, agent): team = util.sign(agent.team) self.expired = self.checkExpired(agent, team) return shotController(agent, util.GOAL_HOME*team*-1)
def check_expired(self, game_info: GameInformation) -> bool: """Determines if the state is no longer useful""" if util.sign(game_info.ball.location.y) == util.sign( game_info.me.team): self.expired = True return self.expired
def test_pubkey_add(self): sig = util.sign(self.consultant_privkey, False, "add_pubkey") #call the server expected = "Added key for client {0}".format(self.client_id) result = self.server.add_pubkey(b64encode(sig), self.client_id, b64encode(self.tree_id), self.client_pubkey) self.assertEqual(expected, result)
def checkAvailable(self, agent): """Determines if the state is an available option""" if util.sign(agent.ball.location.y) != util.sign(agent.team): return True else: return False