class TestCommandLine(unittest.TestCase): def setUp(self): time_step = 0.05 self.agents = [Agent(0, 0, time_step)] self.arena = Arena(10, 20) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.algorithm = AStar(self.arena, self.agents, self.biased_grid) self.cli = CommandLine(self.arena, self.agents) def test_help(self): command = 'help' retval = self.cli.parse_command(command) self.assertTrue(retval) def test_help_specific(self): command = 'help move_agent' retval = self.cli.parse_command(command) self.assertTrue(retval) def test_agent_move(self): command = 'move_agent 0 X 4' retval = self.cli.parse_command(command) self.assertTrue(retval) def test_blockage(self): command = 'blockage set 4 4' retval = self.cli.parse_command(command) self.assertTrue(retval) self.assertEqual(TileState.BLOCKED, self.arena.get_tile_state(4, 4))
def arena_panel(request): arena = Arena(request._char_id) response = ArenaPanelResponse() response.ret = 0 arena._fill_up_panel_msg(response.panel) return pack_msg(response)
def setUp(self): time_step = 0.05 self.agents = [Agent(0, 0, time_step)] self.arena = Arena(10, 20) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.algorithm = AStar(self.arena, self.agents, self.biased_grid) self.cli = CommandLine(self.arena, self.agents)
def setUp(self): time_step = 0.005 self.arena = Arena(10, 10) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.agents = [Agent(0, 0, time_step), Agent(1, 1, time_step)] self.algorithm = SingleAgentAlgorithmMock(self.arena, self.agents, self.biased_grid)
def arena_panel(request): arena = Arena(request._char_id) response = ArenaPanelResponse() response.ret = 0 arena.fill_up_panel_msg(response.panel) return pack_msg(response)
def arena_battle(request): char_id = request._char_id arena = Arena(char_id) msg = arena.battle() response = ArenaResponse() response.ret = 0 response.battle.MergeFrom(msg) return pack_msg(response)
def arena_battle(request): char_id = request._char_id arena = Arena(char_id) msg, drop = arena.battle() response = ArenaResponse() response.ret = 0 response.battle.MergeFrom(msg) response.drop.MergeFrom(standard_drop_to_attachment_protomsg(drop)) return pack_msg(response)
def get_honor_reward(request): server_id = request._game_session.server_id char_id = request._game_session.char_id honor = request._proto.honor a = Arena(server_id, char_id) resource_classified = a.get_honor_reward(honor) response = ArenaHonorGetRewardResponse() response.ret = 0 response.drop.MergeFrom(resource_classified.make_protomsg()) return ProtobufResponse(response)
def match_start(request): server_id = request._game_session.server_id char_id = request._game_session.char_id formation_slots = parse_protocol_sync_formation_slots(request._proto.slots) a = Arena(server_id, char_id) msg = a.match(formation_slots) response = ArenaMatchStartResponse() response.ret = 0 response.match.MergeFrom(msg) return ProtobufResponse(response)
def arena_battle(request): char_id = request._char_id arena = Arena(char_id) msg, adding_score = arena.battle() response = ArenaResponse() response.ret = 0 response.battle.MergeFrom(msg) drop = make_standard_drop_from_template() drop["stuffs"] = [(1001, adding_score)] response.drop.MergeFrom(standard_drop_to_attachment_protomsg(drop)) return pack_msg(response)
def check_exist(self, server_id, char_id): from core.club import Club from core.bag import Bag from core.staff import StaffManger, StaffRecruit from core.territory import Territory from core.arena import Arena from core.energy import Energy money_text = self.money_as_text_dict() if money_text: Club(server_id, char_id).check_money(**money_text) if self.bag: Bag(server_id, char_id).check_items(self.bag) if self.staff: StaffManger(server_id, char_id).check_original_staff_is_initial_state( self.staff) if self.territory_product: Territory(server_id, char_id).check_product(self.territory_product) if self.work_card: Territory(server_id, char_id).check_work_card(self.work_card) if self.arena_point: Arena(server_id, char_id).check_point(self.arena_point) if self.energy: Energy(server_id, char_id).check(self.energy) if self.staff_recruit_score: StaffRecruit(server_id, char_id).check_score(self.staff_recruit_score) if self.resource_data: _r = _Resource() _r.resource = dict(self.resource_data) _r.check_exists(server_id, char_id)
def send_rank_reward(*args): logger = Logger("arena_send_rank_reward") logger.write("Start") try: for sid in Server.duty_server_ids(): MongoArena.db(sid).update_many({}, {'$set': {'continue_win': 0}}) Arena.send_rank_reward(sid) logger.write("Server {0} Finish".format(sid)) except: logger.error(traceback.format_exc()) else: logger.write("Done") finally: logger.close()
def add(self, server_id, char_id, message=""): from core.club import Club from core.bag import Bag from core.staff import StaffManger, StaffRecruit from core.talent import TalentManager from core.territory import Territory from core.vip import VIP from core.arena import Arena from core.energy import Energy from core.plunder import Plunder club_property = self.money_as_text_dict() if self.club_exp: club_property['exp'] = self.club_exp if club_property: club_property['message'] = message Club(server_id, char_id).update(**club_property) if self.vip_exp: VIP(server_id, char_id).add_exp(self.vip_exp) if self.bag: bag = Bag(server_id, char_id) bag.batch_add(self.bag) sm = StaffManger(server_id, char_id) if self.staff: sm.batch_add(self.staff) if self.staff_exp_pool: sm.add_exp_pool(self.staff_exp_pool) if self.talent_point: TalentManager(server_id, char_id).add_talent_points(self.talent_point) if self.arena_point: Arena(server_id, char_id).add_point(self.arena_point) if self.territory_product: Territory(server_id, char_id).add_product(self.territory_product) if self.work_card: Territory(server_id, char_id).add_work_card(self.work_card) if self.energy: Energy(server_id, char_id).add(self.energy) if self.staff_recruit_score: StaffRecruit(server_id, char_id).add_score(self.staff_recruit_score) if self.station_exp: Plunder(server_id, char_id).add_station_exp(self.station_exp) if self.resource_data: _r = _Resource() _r.resource = dict(self.resource_data) _r.add(server_id, char_id)
def parse_arena(self) -> None: """ Creates the simulation arena :return: """ arena = self.config['arena_properties'] arena_size = arena['size'] sim_arena = Arena(arena_size[0], arena_size[1]) blockages = arena['blockages'] for blockage in blockages: sim_arena.set_blockage([blockage[0]], [blockage[1]]) self.arena = sim_arena self.biased_grid = BiasedGrid(self.arena.get_dimensions()) biased_squares = arena['biases'] self._event_squares = arena['event_squares'] for bias in biased_squares: self.biased_grid[bias[0], bias[1]] = bias[2]
def try_cast_login_notify(self): # 这个玩家登陆要广播的消息 from core.arena import Arena top = Arena.get_leader_board(self.server_id, amount=1) if top and top[0].id == self.char_id: template = ConfigBroadcastTemplate.get(4).template text = template.format(self.name) self.do_cast(text)
def refresh(request): server_id = request._game_session.server_id char_id = request._game_session.char_id Arena(server_id, char_id).refresh() response = ArenaRefreshResponse() response.ret = 0 return ProtobufResponse(response)
def buy_times(request): server_id = request._game_session.server_id char_id = request._game_session.char_id Arena(server_id, char_id).buy_times() response = ArenaBuyTimesResponse() response.ret = 0 return ProtobufResponse(response)
def match_report(request): server_id = request._game_session.server_id char_id = request._game_session.char_id key = request._proto.key win = request._proto.win a = Arena(server_id, char_id) resource_classified, score_changed, rank_changed, max_rank, my_rank, my_score = a.report(key, win) response = ArenaMatchReportResponse() response.ret = 0 response.drop.MergeFrom(resource_classified.make_protomsg()) response.score_changed = score_changed response.rank_changed = rank_changed response.max_rank = max_rank response.my_rank = my_rank response.my_score = my_score return ProtobufResponse(response)
def match_report(request): server_id = request._game_session.server_id char_id = request._game_session.char_id key = request._proto.key win = request._proto.win a = Arena(server_id, char_id) resource_classified, score_changed, rank_changed, max_rank, my_rank, my_score = a.report( key, win) response = ArenaMatchReportResponse() response.ret = 0 response.drop.MergeFrom(resource_classified.make_protomsg()) response.score_changed = score_changed response.rank_changed = rank_changed response.max_rank = max_rank response.my_rank = my_rank response.my_score = my_score return ProtobufResponse(response)
def __init__(self, arena: Arena, agents: list, routing_manager: MultiAgentAlgorithm, biased_grid: BiasedGrid, timestep: float, dpi_scaling: int = 40) -> None: """ Create a new canvas for rendering the simulation. The base canvas is based on an Arena object, which controls the domain of the simulation :param: arena: the arena object :param: agents: list of agents :param: routing_manager: routing manager object :param: biased_grid: biased grid for routing only in certain directions :param: timestep: the animation timestep in seconds :param: dpi_scaling: the dpi scaling to use for one grid square :return: """ # initialize pygame as a renderer pygame.init() pygame.font.init() # create the rendering canvas self.x_size, self.y_size = arena.get_dimensions() self.dpi = dpi_scaling self._display_x = self.x_size * self.dpi self._display_y = self.y_size * self.dpi self.screen = pygame.display.set_mode( (self._display_x, self._display_y)) self.clock = pygame.time.Clock() self.arena = arena self.agents = agents self.routing_manager = routing_manager self.biased_grid = biased_grid self.agent_selected = None self._render_directions = True self._event_tiles = None # dict of color keys self.colors_dict = { 'tile_free': (180, 180, 180), 'tile_blocked': (0, 0, 0), 'tile_reserved': (60, 60, 60), 'tile_target': (200, 135, 135), 'grid_lines': (255, 255, 255), 'agent': COLORS, 'agent_selected': (245, 100, 90), 'agent_border': (0, 0, 0), 'soft_bias': (225, 225, 225), 'hard_bias': (200, 80, 80), 'event_tile': (255, 255, 200) } self.total_elements = len(self.colors_dict)
def send_rank_reward(*args): logger = Logger("arena_send_rank_reward") logger.write("Start") try: for sid in Server.duty_server_ids(): MongoArena.db(sid).update_many( {}, {'$set': { 'continue_win': 0 }} ) Arena.send_rank_reward(sid) logger.write("Server {0} Finish".format(sid)) except: logger.error(traceback.format_exc()) else: logger.write("Done") finally: logger.close()
def login_notify(char_id): hero_objs = char_heros_obj(char_id) Char(char_id).send_notify() hero_notify(char_id, hero_objs) Item(char_id).send_notify() f = Formation(char_id) f.send_socket_notify() f.send_formation_notify() hang = Hang(char_id) hang.send_notify() Plunder(char_id).send_notify() p = Prison(char_id) p.send_prisoners_notify() Arena(char_id).send_notify() f = Friend(char_id) f.send_friends_notify() f.send_friends_amount_notify() m = Mail(char_id) m.send_mail_notify() CheckIn(char_id).send_notify() stage = Stage(char_id) stage.send_already_stage_notify() stage.send_new_stage_notify() stage_elite = EliteStage(char_id) stage_elite.send_notify() stage_elite.send_remained_times_notify() stage_activity = ActivityStage(char_id) stage_activity.send_notify() stage_activity.send_remained_times_notify() HeroPanel(char_id).send_notify() Task(char_id).send_notify() Achievement(char_id).send_notify() HeroSoul(char_id).send_notify() FunctionOpen(char_id).send_notify() Levy(char_id).send_notify() Attachment(char_id).send_notify()
def leader_board(request): server_id = request._game_session.server_id clubs = Arena.get_leader_board(server_id) response = ArenaLeaderBoardResponse() response.ret = 0 for index, club in enumerate(clubs): response_rival = response.rival.add() response_rival.id = str(club.id) response_rival.name = club.name response_rival.club_flag = club.flag response_rival.level = club.level response_rival.power = club.power response_rival.rank = index + 1 response_rival.score = ArenaScore(server_id, club.id).score return ProtobufResponse(response)
def _func_opened(char_id, func_ids, **kwargs): need_task_notify = False task_related_func_ids = [t.func for t in TASKS.values() if t.func] for _id in func_ids: if _id in task_related_func_ids: need_task_notify = True break if need_task_notify: Task(char_id).send_notify() # dirty fix... # 比武功能没开放的时候,没有初始化 # 所以在这里要初始化以便自动进入竞技场 from core.arena import Arena for _id in func_ids: if _id == Arena.FUNC_ID: Arena(char_id).send_notify()
def leader_board(request): server_id = request._game_session.server_id clubs = Arena.get_leader_board(server_id) response = ArenaLeaderBoardResponse() response.ret = 0 for index, club in enumerate(clubs): response_rival = response.rival.add() response_rival.id = str(club.id) response_rival.name = club.name response_rival.club_flag = club.flag response_rival.level = club.level response_rival.power = club.power response_rival.rank = index+1 response_rival.score = ArenaScore(server_id, club.id).score return ProtobufResponse(response)
def remove(self, server_id, char_id, message=""): from core.club import Club from core.bag import Bag from core.staff import StaffManger, StaffRecruit from core.territory import Territory from core.arena import Arena from core.energy import Energy money_text = self.money_as_text_dict() if money_text: money_text = {k: -v for k, v in money_text.iteritems()} money_text['message'] = message Club(server_id, char_id).update(**money_text) if self.bag: bag = Bag(server_id, char_id) for _id, _amount in self.bag: bag.remove_by_item_id(_id, _amount) if self.staff: StaffManger(server_id, char_id).internal_remove_by_oid(self.staff) if self.territory_product: Territory(server_id, char_id).remove_product(self.territory_product) if self.work_card: Territory(server_id, char_id).remove_work_card(self.work_card) if self.arena_point: Arena(server_id, char_id).remove_point(self.arena_point) if self.energy: Energy(server_id, char_id).remove(self.energy) if self.staff_recruit_score: StaffRecruit(server_id, char_id).remove_score(self.staff_recruit_score) if self.resource_data: _r = _Resource() _r.resource = dict(self.resource_data) _r.remove(server_id, char_id)
def arena_info(request): servers_select = get_servers_select_context() context = { 'current': 'arena', 'servers_select': servers_select, 'clubs': [] } sid = request.GET.get('sid', 0) if not sid: return render_to_response( 'dianjing_statistics_arena.html', context=context ) try: sid = int(sid) except: raise Http404() clubs = Arena.get_leader_board(sid) data = [] for _index, c in enumerate(clubs): data.append({ 'rank': _index + 1, 'id': c.id, 'name': c.name, 'level': c.level, 'power': c.power, 'score': ArenaScore(sid, c.id).score, 'is_npc': is_npc_club(str(c.id)), }) context['clubs'] = data return render_to_response( 'dianjing_statistics_arena.html', context=context )
def game_start_handler(server_id, char_id, **kwargs): MessagePipe(char_id).clean() msg = UTCNotify() msg.timestamp = arrow.utcnow().timestamp MessagePipe(char_id).put(msg=msg) msg = SocketServerNotify() ss = random.choice(settings.SOCKET_SERVERS) msg.ip = ss['host'] msg.port = ss['tcp'] MessagePipe(char_id).put(msg=msg) _Resource.send_notify(server_id, char_id) UnitManager(server_id, char_id).send_notify() Bag(server_id, char_id).send_notify() StaffManger(server_id, char_id).send_notify() StaffRecruit(server_id, char_id).send_notify() f = Formation(server_id, char_id) f.send_formation_notify() f.send_slot_notify() club = Club(server_id, char_id) club.set_login() club.send_notify() msg = CreateDaysNotify() msg.days = days_passed(club.create_at) msg.create_at = club.create_at MessagePipe(char_id).put(msg=msg) chall = Challenge(server_id, char_id) chall.send_chapter_notify() chall.send_challenge_notify() FriendManager(server_id, char_id).send_notify() MailManager(server_id, char_id).send_notify() TaskMain(server_id, char_id).send_notify() TaskDaily(server_id, char_id).send_notify() Chat(server_id, char_id).send_notify() Notification(server_id, char_id).send_notify() FinanceStatistics(server_id, char_id).send_notify() TalentManager(server_id, char_id).send_notify() Dungeon(server_id, char_id).send_notify() a = Arena(server_id, char_id) a.send_notify() a.send_honor_notify() t = Tower(server_id, char_id) t.send_notify() t.send_goods_notify() Territory(server_id, char_id).send_notify() TerritoryStore(server_id, char_id).send_notify() TerritoryFriend(server_id, char_id).send_remained_times_notify() Store(server_id, char_id).send_notify() VIP(server_id, char_id).send_notify() Collection(server_id, char_id).send_notify() Energy(server_id, char_id).send_notify() w = Welfare(server_id, char_id) w.send_signin_notify() w.send_new_player_notify() w.send_level_reward_notify() w.send_energy_reward_notify() Union(server_id, char_id).send_all_notify() Purchase(server_id, char_id).send_notify() ac = ActivityNewPlayer(server_id, char_id) ac.send_notify() ac.send_daily_buy_notify() ActivityOnlineTime(server_id, char_id).send_notify() ActivityChallenge(server_id, char_id).send_notify() ActivityPurchaseDaily(server_id, char_id).send_notify() ActivityPurchaseContinues(server_id, char_id).send_notify() ActivityLevelGrowing(server_id, char_id).send_notify() p = Plunder(server_id, char_id) p.send_search_notify() p.send_result_notify() p.send_revenge_notify() p.send_station_notify() p.send_formation_notify() p.send_plunder_times_notify() p.send_plunder_daily_reward_notify() SpecialEquipmentGenerator(server_id, char_id).send_notify() Party(server_id, char_id).send_notify() ins = Inspire(server_id, char_id) ins.try_open_slots(send_notify=False) ins.send_notify() cs = Championship(server_id, char_id) cs.try_initialize(send_notify=False) cs.send_notify() WinningPlunder(server_id, char_id).send_notify() WinningArena(server_id, char_id).send_notify() WinningChampionship(server_id, char_id).send_notify() Worship(server_id, char_id).send_notify() CommonArenaWinningChat(server_id, char_id).send_notify() CommonPlunderWinningChat(server_id, char_id).send_notify() CommonChampionshipChat(server_id, char_id).send_notify() send_system_notify(server_id, char_id) BroadCast(server_id, char_id).try_cast_login_notify()
def get_current_value(self, char_id): from core.arena import Arena return Arena(char_id).rank
from core.agent import * from core.arena import Arena BASE_TIME_STEP = 0.05 BASE_DPI = 40 # CLI thread def cli_thread_func(arena: Arena, agents: list) -> None: cli = CommandLine(arena, agents) while True: cli.get_input() # setup an arena sim_arena = Arena(40, 40) # create some agents and add them to the agents list sim_agent = Agent(0, 0, BASE_TIME_STEP) sim_agent_1 = Agent(5, 5, BASE_TIME_STEP) sim_agent_1.set_kinematic_parameters(4, 4, 4) sim_agent.set_kinematic_parameters(6, 6, 6) sim_agents = list() sim_agents.append(sim_agent) sim_agents.append(sim_agent_1) # setup the routing algorithm algorithm = AStar(sim_arena, sim_agents) algorithm.turn_factor = 2 # create the pathing algorithm
def setUp(self): time_step = 0.005 self.arena = Arena(10, 10) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.agents = [Agent(0, 0, time_step), Agent(1, 1, time_step)] self.a_star = AStar(self.arena, self.agents, self.biased_grid)
class TestAStar(unittest.TestCase): def setUp(self): time_step = 0.005 self.arena = Arena(10, 10) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.agents = [Agent(0, 0, time_step), Agent(1, 1, time_step)] self.a_star = AStar(self.arena, self.agents, self.biased_grid) def test_a_star_init(self): self.assertEqual(self.arena, self.a_star.arena) self.assertEqual(self.agents, self.a_star.agents) self.assertEqual([], self.a_star.path) def test_check_blocked_square_fails(self): self.arena.set_blockage([0], [1]) status = self.a_star.check_target_location(0, 1) self.assertEqual(RoutingStatus.TARGET_BLOCKED, status) def test_check_reserved_square_fails(self): self.arena.set_reserved([0], [1]) status = self.a_star.check_target_location(0, 1) self.assertEqual(RoutingStatus.TARGET_RESERVED, status) def test_route_to_blocked_square_fails(self): self.arena.set_blockage([0], [1]) status = self.a_star.route(self.agents[0], (0, 1)) self.assertEqual(RoutingStatus.TARGET_BLOCKED, status) def test_route_to_reserved_square_fails(self): self.arena.set_reserved([0], [1]) status = self.a_star.route(self.agents[0], (0, 1)) self.assertEqual(RoutingStatus.TARGET_RESERVED, status) def test_initialize_nodes(self): start = (0, 0) target = (0, 4) start_node = AStarNode(start) end_node = AStarNode(target) self.a_star.initialize_nodes(self.agents[0], target) start_eq = start_node == self.a_star.start end_eq = end_node == self.a_star.target self.assertTrue(start_eq) self.assertTrue(end_eq) def test_get_new_nodes_in_empty_area(self): # initialize the search, and then get neighbouring tiles start = (1, 1) expected_neighbours = [(2, 1), (1, 2), (0, 1), (1, 0)] parent_node = AStarNode(start) new_nodes = self.a_star.generate_new_nodes(parent_node) self.assertEqual(len(expected_neighbours), len(new_nodes)) # make sure all of the correct nodes are returned for node_location in expected_neighbours: test_node = AStarNode(node_location) node_exists = test_node in new_nodes self.assertTrue(node_exists) def test_get_new_nodes_in_corner(self): # initialize the search in a corner, and then get neighbouring tiles start = (0, 0) expected_neighbours = [(0, 1), (1, 0)] parent_node = AStarNode(start) new_nodes = self.a_star.generate_new_nodes(parent_node) self.assertEqual(len(expected_neighbours), len(new_nodes)) # make sure all of the correct nodes are returned for node_location in expected_neighbours: test_node = AStarNode(node_location) node_exists = test_node in new_nodes self.assertTrue(node_exists) def test_get_new_nodes_with_blockage(self): # initialize the search, set some blockages, and then make sure only the free tiles are returned start = (1, 1) self.arena.set_blockage([2], [0, 1, 2, 3]) expected_neighbours = [(1, 2), (0, 1), (1, 0)] parent_node = AStarNode(start) new_nodes = self.a_star.generate_new_nodes(parent_node) self.assertEqual(len(expected_neighbours), len(new_nodes)) # make sure all of the correct nodes are returned for node_location in expected_neighbours: test_node = AStarNode(node_location) node_exists = test_node in new_nodes self.assertTrue(node_exists) def test_calculate_heuristic(self): start = (1, 1) target = (4, 4) start_node = AStarNode(start) target_node = AStarNode(target) heuristic = self.a_star.calculate_heuristic_cost( start_node, target_node) self.assertEqual(6, heuristic) @unittest.skip('debug') def test_routing_simple_path(self): target = (4, 4) status = self.a_star.route(self.agents[0], target) self.assertEqual(RoutingStatus.SUCCESS, status) # make sure the final nodes are correct self.assertTupleEqual((4, 4), self.a_star.node_path[-1].location) def test_route_to_tile_with_other_agent_fails(self): status = self.a_star.check_target_location(1, 1) self.assertEqual(RoutingStatus.TARGET_RESERVED, status) def test_calculate_turn_cost_no_factor(self): start_node = AStarNode((0, 0)) node_1 = AStarNode((1, 0), parent=start_node) node_2 = AStarNode((2, 0), parent=node_1) node_3 = AStarNode((2, 1), parent=node_2) node_4 = AStarNode((2, 2), parent=node_3) node_5 = AStarNode((3, 2), parent=node_4) turn_cost = self.a_star.calculate_turn_cost(node_5) self.assertEqual(0, turn_cost) def test_calculate_turn_cost_with_weight(self): start_node = AStarNode((0, 0)) self.a_star.turn_factor = 1 node_1 = AStarNode((1, 0), parent=start_node) node_2 = AStarNode((2, 0), parent=node_1) node_3 = AStarNode((2, 1), parent=node_2) node_4 = AStarNode((2, 2), parent=node_3) node_5 = AStarNode((3, 2), parent=node_4) turn_cost = self.a_star.calculate_turn_cost(node_5) self.assertEqual(2, turn_cost) def test_calculate_inline_cost(self): self.a_star.inline_factor = 10 self.arena.set_agent_target(3, 3) node = AStarNode((1, 3)) score = self.a_star.calculate_inline_cost(node) self.assertEqual(10, score) def test_is_direction_valid(self): parents = [(1, 1), (1, 1), (1, 1), (1, 1)] children = [(2, 1), (0, 1), (1, 2), (1, 0)] main_biases = [ BiasedDirection.ONLY_X_POSITIVE, BiasedDirection.ONLY_X_NEGATIVE, BiasedDirection.ONLY_Y_POSITIVE, BiasedDirection.ONLY_Y_NEGATIVE ] secondary_biases = [ BiasedDirection.ONLY_Y_POSITIVE, BiasedDirection.ONLY_Y_NEGATIVE, BiasedDirection.ONLY_X_POSITIVE, BiasedDirection.ONLY_X_NEGATIVE ] for idx in range(len(parents)): parent = parents[idx] child = children[idx] bias = main_biases[idx] self.biased_grid[child] = bias self.biased_grid[parent] = bias self.assertTrue(self.a_star.is_direction_valid(parent, child)) self.assertFalse(self.a_star.is_direction_valid(child, parent)) bias = secondary_biases[idx] self.biased_grid[child] = bias self.biased_grid[parent] = bias self.assertFalse(self.a_star.is_direction_valid(parent, child))
class TestSingleAgentAlgorithm(unittest.TestCase): def setUp(self): time_step = 0.005 self.arena = Arena(10, 10) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.agents = [Agent(0, 0, time_step), Agent(1, 1, time_step)] self.algorithm = SingleAgentAlgorithmMock(self.arena, self.agents, self.biased_grid) def tearDown(self): pass def test_reconstruct_empty_path_is_invalid(self): self.algorithm.node_path = list() status = self.algorithm.create_path() self.assertEqual(RoutingStatus.INVALID_PATH, status) def test_diagonal_path_is_invalid(self): self.algorithm.node_path = [NodeMock((0, 0)), NodeMock((1, 1))] status = self.algorithm.create_path() self.assertEqual(RoutingStatus.INVALID_PATH, status) def test_reconstruct_path(self): # force a list of nodes to be the node path self.algorithm.node_path = [ NodeMock((0, 0)), NodeMock((0, 1)), NodeMock((0, 2)), NodeMock((1, 2)), NodeMock((2, 2)) ] status = self.algorithm.create_path() self.assertEqual(RoutingStatus.SUCCESS, status) # The order of the tasks should be: Move X 2, Move Y 2 task_direction = [AgentCoordinates.Y, AgentCoordinates.X] task_distance = [2, 2] for idx, task in enumerate(self.algorithm.path): self.assertEqual(task_direction[idx], task.args[0]) self.assertEqual(task_distance[idx], task.args[1]) def test_reconstruct_path_zig_zag(self): # force a list of nodes to be the node path self.algorithm.node_path = [ NodeMock((0, 0)), NodeMock((1, 0)), NodeMock((1, 1)), NodeMock((2, 1)), NodeMock((2, 2)), NodeMock((3, 2)), NodeMock((3, 3)), NodeMock((4, 3)), NodeMock((4, 4)) ] status = self.algorithm.create_path() self.assertEqual(RoutingStatus.SUCCESS, status) # this path should contain 8 tasks self.assertEqual(8, len(self.algorithm.path)) # The order of the tasks should be: Move X 1, Move Y 1, Move X 1, Move Y 1 task_direction = [ AgentCoordinates.X, AgentCoordinates.Y, AgentCoordinates.X, AgentCoordinates.Y, AgentCoordinates.X, AgentCoordinates.Y, AgentCoordinates.X, AgentCoordinates.Y ] task_distance = [1, 1, 1, 1, 1, 1, 1, 1] for idx, task in enumerate(self.algorithm.path): self.assertEqual(task_direction[idx], task.args[0]) self.assertEqual(task_distance[idx], task.args[1])
def login_notify(char_id): message_clean(char_id) function_open = FunctionOpen(char_id) function_open.send_notify() hero_objs = char_heros_obj(char_id) Char(char_id).send_notify() VIP(char_id).send_notify() hero_notify(char_id, hero_objs) Item(char_id).send_notify() f = Formation(char_id) f.send_socket_notify() f.send_formation_notify() Plunder(char_id).send_notify() p = Prison(char_id) p.send_prisoners_notify() a = Arena(char_id) a.send_notify() a.login_process() f = Friend(char_id) f.send_friends_notify() f.send_friends_amount_notify() CheckIn(char_id).send_notify() stage = Stage(char_id) stage.send_already_stage_notify() stage.send_new_stage_notify() stage_elite = EliteStage(char_id) stage_elite.send_notify() stage_elite.send_times_notify() stage_activity = ActivityStage(char_id) stage_activity.check(send_notify=False) stage_activity.send_notify() stage_activity.send_remained_times_notify() HeroPanel(char_id).send_notify() Task(char_id).send_notify() Achievement(char_id).send_notify() HeroSoul(char_id).send_notify() Levy(char_id).send_notify() Attachment(char_id).send_notify() BasePurchaseAction(char_id).send_notify() SystemBroadcast(char_id).send_global_broadcast() ChatMessagePublish(char_id).send_notify() affairs = Affairs(char_id) affairs.send_city_notify() affairs.send_hang_notify() HorseFreeTimesManager(char_id).send_notify() Horse(char_id).send_notify() union.send_notify(char_id) ae = ActivityEntry(char_id, 50006) if ae and ae.is_valid(): ae.enable(ae.get_current_value(char_id)) ActivityStatic(char_id).send_notify() # mail notify 要放在最后,因为 其他功能初始化时可能会产生登录邮件 Mail(char_id).send_notify()
class TestMultiAgentAlgorithm(unittest.TestCase): def setUp(self): time_step = 0.005 self.arena = Arena(10, 10) self.biased_grid = BiasedGrid(self.arena.get_dimensions()) self.agents = [Agent(0, 0, time_step), Agent(5, 5, time_step)] self.algorithm = SingleAgentAlgorithmMock(self.arena, self.agents, self.biased_grid) self.routing_manager = MultiAgentAlgorithmMock(self.arena, self.agents, self.algorithm) def tearDown(self): pass def test_is_simulation_completed_passes_if_final_goal_reached(self): self.routing_manager.add_agent_goal(0, (0, 0)) self.routing_manager.add_agent_goal(1, (5, 5)) self.assertTrue(self.routing_manager.is_simulation_complete()) def test_simulation_not_completed_if_final_goal_not_reached(self): # add the current location as a segment, but also add a second location for each agent self.routing_manager.add_agent_goal(0, (0, 0)) self.routing_manager.add_agent_goal(1, (5, 5)) self.routing_manager.add_agent_goal(0, (1, 1)) self.routing_manager.add_agent_goal(1, (4, 4)) self.assertFalse(self.routing_manager.is_simulation_complete()) def test_update_agent_goal(self): self.routing_manager.add_agent_goal(0, (0, 0)) self.routing_manager.add_agent_goal(0, (1, 1)) self.assertTrue(self.routing_manager.is_agent_at_goal(0)) self.routing_manager.update_agent_goal(0) self.assertTupleEqual((1, 1), self.routing_manager.agent_goals[0][0]) self.assertFalse(self.routing_manager.is_agent_at_goal(0)) self.assertFalse(self.routing_manager.is_simulation_complete()) def test_routing_blockages(self): move_x_task = AgentTask(AgentTasks.MOVE, [AgentCoordinates.X, 3]) move_y_task = AgentTask(AgentTasks.MOVE, [AgentCoordinates.Y, 3]) self.routing_manager.add_agent_task(0, move_x_task) for i in range(1, 3): self.assertEqual(TileState.RESERVED, self.arena.get_tile_state(i, 0)) self.assertEqual(TileState.AGENT_TARGET, self.arena.get_tile_state(3, 0)) self.routing_manager.add_agent_task(0, move_y_task) for i in range(1, 3): self.assertEqual(TileState.RESERVED, self.arena.get_tile_state(3, i)) self.assertEqual(TileState.AGENT_TARGET, self.arena.get_tile_state(3, 3)) def test_adding_and_completing_task_clears_blockage(self): move_x_task = AgentTask(AgentTasks.MOVE, [AgentCoordinates.X, 3]) self.routing_manager.add_agent_task(0, move_x_task) for i in range(1, 3): self.assertEqual(TileState.RESERVED, self.arena.get_tile_state(i, 0)) self.assertEqual(TileState.AGENT_TARGET, self.arena.get_tile_state(3, 0)) self.routing_manager.signal_agent_event(0, AgentEvent.TASK_COMPLETED) for i in range(1, 4): self.assertEqual(TileState.FREE, self.arena.get_tile_state(i, 0)) def test_completing_task_clears_agent_active(self): move_x_task = AgentTask(AgentTasks.MOVE, [AgentCoordinates.X, 3]) self.routing_manager.add_agent_task(0, move_x_task) self.routing_manager.signal_agent_event(0, AgentEvent.TASK_COMPLETED) self.assertFalse(self.routing_manager.active_agents[0]) def test_initialize_algorithm(self): self.routing_manager.initialize() self.assertTrue(self.routing_manager.initialized) def test_is_agent_at_goal(self): self.routing_manager.add_agent_goal(0, (0, 0)) self.assertTrue(self.routing_manager.is_agent_at_goal(0)) def test_start_new_task(self): move_x_task = AgentTask(AgentTasks.MOVE, [AgentCoordinates.X, 3]) self.routing_manager.add_agent_task(0, move_x_task) self.routing_manager.start_new_task(0) self.assertTrue(self.routing_manager.active_agents[0])
def buy(self, tp, goods_id): if tp not in ALL_TYPES: raise GameException( ConfigErrorMessage.get_error_id("INVALID_OPERATE")) config = ConfigStore.get(goods_id) if not config: raise GameException( ConfigErrorMessage.get_error_id("STORE_GOODS_NOT_EXIST")) try: data = self.doc['tp'][str(tp)]['goods'][str(goods_id)] except KeyError: raise GameException( ConfigErrorMessage.get_error_id("INVALID_OPERATE")) if data['times'] >= config.times_limit: raise GameException( ConfigErrorMessage.get_error_id("STORE_GOODS_NO_TIMES")) if config.condition_id == 1: # VIP 等级 VIP(self.server_id, self.char_id).check(config.condition_value) elif config.condition_id == 2: # 爬塔历史最高星 Tower(self.server_id, self.char_id).check_history_max_star(config.condition_value) elif config.condition_id == 3: # 竞技场当前排名 Arena(self.server_id, self.char_id).check_current_rank(config.condition_value) elif config.condition_id == 4: # 当前公会等级 Union(self.server_id, self.char_id).check_level(config.condition_value) item_id, item_amount, need_id, need_amount = config.content[ data['index']] resource_classify = ResourceClassification.classify([(need_id, need_amount)]) resource_classify.check_exist(self.server_id, self.char_id) resource_classify.remove(self.server_id, self.char_id, message="Store.buy:{0}".format(goods_id)) resource_classify = ResourceClassification.classify([(item_id, item_amount)]) resource_classify.add(self.server_id, self.char_id, message="Store.buy:{0}".format(goods_id)) data['times'] += 1 MongoStore.db(self.server_id).update_one({'_id': self.char_id}, { '$set': { 'tp.{0}.goods.{1}.times'.format(tp, goods_id): data['times'] } }) self.send_notify(tp=tp) return resource_classify