class Network(): def __init__(self): self.node = Pyre("GAME_NODE") self.node.set_header("AUTHORITY", "FALSE") self.node.set_header("NAME", "") self.node.start() self.node.join("world:position") self.node.join("world:combat") self.node.join("ctf:teams") self.node.join("ctf:dropflag") self.node.join("ctf:gotflag") self.node.join("players:whois") self.node.join("player:name") self.node.join("ctf:scores") self.node.join("ctf:status") self.poller = zmq.Poller() self.poller.register(self.node.socket(), zmq.POLLIN) def poll(self): return dict(self.poller.poll(0)) def peers(self): return self.node.peers() def stop(self): self.node.stop() def get_events(self): changes = self.poll() if self.node.socket() in changes and changes[self.node.socket()] == zmq.POLLIN: events = self.node.recent_events() return events
class Network(): def __init__(self): self.node = Pyre("GAME_NODE") self.node.set_header("HELLO", "ABC") self.node.start() self.node.join("world:position") self.node.join("world:combat") self.poller = zmq.Poller() self.poller.register(self.node.socket(), zmq.POLLIN) def poll(self): return dict(self.poller.poll(0)) def peers(self): return self.node.peers() def stop(self): self.node.stop() def get_events(self): changes = self.poll() if self.node.socket() in changes and changes[ self.node.socket()] == zmq.POLLIN: events = self.node.recent_events() return events
class Authority(): def __init__(self): self.node = Pyre("GAME_AUTH") self.node.set_header("AUTHORITY", "TRUE") self.node.start() self.node.join("world:position") self.node.join("ctf:teams") self.node.join("ctf:dropflag") self.node.join("ctf:gotflag") self.poller = zmq.Poller() self.poller.register(self.node.socket(), zmq.POLLIN) self.players = AuthorityPlayerManager() self.teams = {"blue": [], "red": []} self.level = SaveLevel('./assets/maps/CAPFLAG MAP NAT') red_spawn_pos = self.level.get_place(Place.RED_SPAWN) blue_spawn_pos = self.level.get_place(Place.BLUE_SPAWN) self.flags = { "blue": { "x": blue_spawn_pos[0], "y": blue_spawn_pos[1], "owner": '', "timer": 0 }, "red": { "x": red_spawn_pos[0], "y": red_spawn_pos[1], "owner": '', "timer": 0 } } self.serve() def set_teams(self): blue_players = self.teams["blue"] red_players = self.teams["red"] # Check for removed players in RED for i, playerUUID in enumerate(red_players): if playerUUID not in self.players.players.keys(): red_players.pop(i) # Check for removed players in BLUE for i, playerUUID in enumerate(blue_players): if playerUUID not in self.players.players.keys(): blue_players.pop(i) # Add new players for playerUUID, player in self.players.players.items(): if not (playerUUID in blue_players or playerUUID in red_players): if len(blue_players) > len(red_players): red_players.append(playerUUID) else: blue_players.append(playerUUID) print("Teams: " + "RED: " + ','.join(red_players) + " | BLUE: " + ','.join(blue_players)) self.node.shout("ctf:teams", bson.dumps(self.teams)) def set_flags(self, flag_info): return def update_flags(self): self.node.shout("ctf:flags", bson.dumps(self.flags)) def get_team_from_uuid(self, uuid): place = None if str(uuid) in self.teams['red']: place = Place.RED_SPAWN elif str(uuid) in self.teams['blue']: place = Place.BLUE_SPAWN return place def serve(self): clock = Clock() while True: clock.tick(60) # check network events = self.get_events() if events: try: for event in events: # Update the teams on JOIN and EXIT if event.type == 'JOIN': if event.group == 'ctf:dropflag': for team, flag in self.flags.items(): if flag['owner'] == '': self.node.shout( 'ctf:dropflag', bson.dumps({ 'x': flag['x'], 'y': flag['y'], 'team': team })) elif event.group == 'ctf:gotflag': for team, flag in self.flags.items(): if flag['owner'] != '': self.node.shout( 'ctf:gotflag', bson.dumps({ 'uuid': flag['owner'], 'team': team })) elif event.group == 'ctf:teams': self.players.set(self.node.peers()) self.set_teams() place = self.get_team_from_uuid( event.peer_uuid) pos = self.level.get_place(place) self.node.whisper( event.peer_uuid, bson.dumps({ 'type': 'teleport', 'x': pos[0], 'y': pos[1] })) elif event.type == 'EXIT': for team, flag in self.flags.items(): if flag['owner'] == str(event.peer_uuid): # flag owner is leaving, drop player = self.players.get(event.peer_uuid) flag['x'] = player.x flag['y'] = player.y flag['owner'] = '' self.node.shout( 'ctf:dropflag', bson.dumps({ 'x': flag['x'], 'y': flag['y'], 'team': team })) self.players.set(self.node.peers()) self.set_teams() elif event.type == 'SHOUT': if event.group == "world:position": new_position = bson.loads(event.msg[0]) network_player = self.players.get( event.peer_uuid) network_player.set_position(new_position) # check if flag has been captured for team, flag in self.flags.items(): if flag['owner'] != str(event.peer_uuid): continue tile = self.level.get_tile( new_position['x'], new_position['y']) if tile == TileType.RED_BLOCK and team == 'blue': # TODO: blue's flag has been captured spawn = Place.BLUE_SPAWN elif tile == TileType.BLUE_BLOCK and team == 'red': # TODO: red's flag has been captured spawn = Place.RED_SPAWN else: continue position = self.level.get_place(spawn) flag['x'] = position[0] flag['y'] = position[1] flag['owner'] = '' self.node.shout( 'ctf:dropflag', bson.dumps({ 'x': flag['x'], 'y': flag['y'], 'team': team })) if event.group == 'ctf:gotflags': flag_info = bson.loads(event.msg[0]) self.set_flags(flag_info) elif event.type == 'WHISPER': msg = bson.loads(event.msg[0]) network_player = self.players.get(event.peer_uuid) if msg['type'] == 'death_report': player = self.players.get(event.peer_uuid) previously_owned_flag = None if self.flags['blue']['owner'] == str( event.peer_uuid): previously_owned_flag = 'blue' elif self.flags['red']['owner'] == str( event.peer_uuid): previously_owned_flag = 'red' if previously_owned_flag: flag = self.flags[previously_owned_flag] flag['owner'] = '' self.node.shout( 'ctf:dropflag', bson.dumps({ 'x': player.x, 'y': player.y, 'team': previously_owned_flag })) place = self.get_team_from_uuid( event.peer_uuid) pos = self.level.get_place(place) self.node.whisper( event.peer_uuid, bson.dumps({ 'type': 'teleport', 'x': pos[0], 'y': pos[1] })) player.x = pos[0] player.y = pos[1] except Exception as e: print(e) import traceback print(traceback.format_exc()) pass for team, flag in self.flags.items(): if flag["owner"] != '': continue for uuid, player in self.players.players.items(): if flag['x'] == player.x and flag['y'] == player.y: team_place = self.get_team_from_uuid(uuid) pos = self.level.get_place(team_place) if team == 'red' and team_place == Place.RED_SPAWN or team == 'blue' and team_place == Place.BLUE_SPAWN: if player.x == pos[0] and player.y == pos[1]: continue self.node.shout( 'ctf:dropflag', bson.dumps({ 'x': pos[0], 'y': pos[1], 'team': team })) else: flag["owner"] = uuid self.node.shout( 'ctf:gotflag', bson.dumps({ 'uuid': uuid, 'team': team })) break def poll(self): return dict(self.poller.poll(0)) def peers(self): return self.node.peers() def stop(self): self.node.stop() def get_events(self): changes = self.poll() if self.node.socket() in changes and changes[ self.node.socket()] == zmq.POLLIN: events = self.node.recent_events() return events
class Bridge(object): """docstring for Bridge""" def __init__(self, uvc_id): super(Bridge, self).__init__() self.data_seq = 0 self.note_seq = 0 # init capture self.cap = uvc.Capture(uvc_id) logger.info('Initialised uvc device {}'.format(self.cap.name)) # init pyre self.network = Pyre(socket.gethostname()+self.cap.name[-4:]) self.network.join(GROUP) self.network.start() logger.info('Bridging under "{}"'.format(self.network.name())) # init sensor sockets ctx = zmq.Context() generic_url = 'tcp://*:*' public_ep = self.network.endpoint() self.note, self.note_url = self.bind(ctx, zmq.PUB, generic_url, public_ep) self.data, self.data_url = self.bind(ctx, zmq.PUB, generic_url, public_ep, set_hwm=1) self.cmd, self.cmd_url = self.bind(ctx, zmq.PULL, generic_url, public_ep) def loop(self): logger.info('Entering bridging loop...') self.network.shout(GROUP, self.sensor_attach_json().encode()) try: while True: self.poll_network() self.poll_cmd_socket() self.publish_frame() except KeyboardInterrupt: pass except Exception: import traceback traceback.print_exc() finally: self.network.shout(GROUP, json.dumps({ 'subject': 'detach', 'sensor_uuid': self.network.uuid().hex }).encode()) logger.info('Leaving bridging loop...') def publish_frame(self): frame = self.cap.get_frame_robust() now = time.time() index = self.data_seq self.data_seq += 1 self.data_seq %= sequence_limit jpeg_buffer = frame.jpeg_buffer m = hashlib.md5(jpeg_buffer) lower_end = int(m.hexdigest(), 16) % 0x100000000 meta_data = struct.pack('<LLLLdLL', 0x10, frame.width, frame.height, index, now, jpeg_buffer.size, lower_end) self.data.send_multipart([self.network.uuid().hex.encode(), meta_data, jpeg_buffer]) def poll_network(self): for event in self.network.recent_events(): if event.type == 'JOIN' and event.group == GROUP: self.network.whisper(event.peer_uuid, self.sensor_attach_json().encode()) def poll_cmd_socket(self): while has_data(self.cmd): sensor, cmd_str = self.cmd.recv_multipart() try: cmd = json.loads(cmd_str.decode()) except Exception as e: logger.debug('Could not parse received cmd: {}'.format(cmd_str)) else: logger.debug('Received cmd: {}'.format(cmd)) if cmd.get('action') == 'refresh_controls': self.publish_controls() elif cmd.get('action') == 'set_control_value': val = cmd.get('value', 0) if cmd.get('control_id') == 'CAM_RATE': self.cap.frame_rate = self.cap.frame_rates[val] elif cmd.get('control_id') == 'CAM_RES': self.cap.frame_size = self.cap.frame_sizes[val] self.publish_controls() def __del__(self): self.note.close() self.data.close() self.cmd.close() self.network.stop() def publish_controls(self): self.note.send_multipart([ self.network.uuid().hex.encode(), self.frame_size_control_json().encode()]) self.note.send_multipart([ self.network.uuid().hex.encode(), self.frame_rate_control_json().encode()]) def sensor_attach_json(self): sensor = { "subject": "attach", "sensor_name": self.cap.name, "sensor_uuid": self.network.uuid().hex, "sensor_type": 'video', "notify_endpoint": self.note_url, "command_endpoint": self.cmd_url, "data_endpoint": self.data_url } return json.dumps(sensor) def frame_size_control_json(self): index = self.note_seq self.note_seq += 1 self.note_seq %= sequence_limit curr_fs = self.cap.frame_sizes.index(self.cap.frame_size) return json.dumps({ "subject": "update", "control_id": "CAM_RES", "seq": index, "changes": { "value": curr_fs, "dtype": 'intmapping', "min": None, "max": None, "res": None, "def": 0, "caption": 'Resolution', "readonly": False, "map": [{ 'value': idx, 'caption': '{:d}x{:d}'.format(*fs) } for idx, fs in enumerate(self.cap.frame_sizes)] } }) def frame_rate_control_json(self): index = self.note_seq self.note_seq += 1 self.note_seq %= sequence_limit curr_fr = self.cap.frame_rates.index(self.cap.frame_rate) return json.dumps({ "subject": "update", "control_id": "CAM_RATE", "seq": index, "changes": { "value": curr_fr, "dtype": 'intmapping', "min": None, "max": None, "res": None, "def": 0, "caption": 'Frame Rate', "readonly": False, "map": [{ 'value': idx, 'caption': '{:.1f} Hz'.format(fr) } for idx, fr in enumerate(self.cap.frame_rates)] } }) def bind(self, ctx, sock_type, url, public_ep, set_hwm=None): sock = ctx.socket(sock_type) if set_hwm: sock.set_hwm(set_hwm) sock.bind(url) ep = sock.last_endpoint.decode() port = ep.split(':')[-1] public_ep.split(':')[-1] public_addr = public_ep.split(':')[:-1] return sock, ':'.join(public_addr+[port])
class Bridge(object): """docstring for Bridge""" def __init__(self, uvc_id): super(Bridge, self).__init__() self.data_seq = 0 self.note_seq = 0 # init capture self.cap = uvc.Capture(uvc_id) logger.info('Initialised uvc device {}'.format(self.cap.name)) # init pyre self.network = Pyre(socket.gethostname() + self.cap.name[-4:]) self.network.join(GROUP) self.network.start() logger.info('Bridging under "{}"'.format(self.network.name())) # init sensor sockets ctx = zmq.Context() generic_url = 'tcp://*:*' public_ep = self.network.endpoint() self.note, self.note_url = self.bind(ctx, zmq.PUB, generic_url, public_ep) self.data, self.data_url = self.bind(ctx, zmq.PUB, generic_url, public_ep, set_hwm=1) self.cmd, self.cmd_url = self.bind(ctx, zmq.PULL, generic_url, public_ep) def loop(self): logger.info('Entering bridging loop...') self.network.shout(GROUP, self.sensor_attach_json().encode()) try: while True: self.poll_network() self.poll_cmd_socket() self.publish_frame() except KeyboardInterrupt: pass except Exception: import traceback traceback.print_exc() finally: self.network.shout( GROUP, json.dumps({ 'subject': 'detach', 'sensor_uuid': self.network.uuid().hex }).encode()) logger.info('Leaving bridging loop...') def publish_frame(self): frame = self.cap.get_frame_robust() now = time.time() index = self.data_seq self.data_seq += 1 self.data_seq %= sequence_limit jpeg_buffer = frame.jpeg_buffer m = hashlib.md5(jpeg_buffer) lower_end = int(m.hexdigest(), 16) % 0x100000000 meta_data = struct.pack('<LLLLdLL', 0x10, frame.width, frame.height, index, now, jpeg_buffer.size, lower_end) self.data.send_multipart( [self.network.uuid().hex.encode(), meta_data, jpeg_buffer]) def poll_network(self): for event in self.network.recent_events(): if event.type == 'JOIN' and event.group == GROUP: self.network.whisper(event.peer_uuid, self.sensor_attach_json().encode()) def poll_cmd_socket(self): while has_data(self.cmd): sensor, cmd_str = self.cmd.recv_multipart() try: cmd = json.loads(cmd_str.decode()) except Exception as e: logger.debug( 'Could not parse received cmd: {}'.format(cmd_str)) else: logger.debug('Received cmd: {}'.format(cmd)) if cmd.get('action') == 'refresh_controls': self.publish_controls() elif cmd.get('action') == 'set_control_value': val = cmd.get('value', 0) if cmd.get('control_id') == 'CAM_RATE': self.cap.frame_rate = self.cap.frame_rates[val] elif cmd.get('control_id') == 'CAM_RES': self.cap.frame_size = self.cap.frame_sizes[val] self.publish_controls() def __del__(self): self.note.close() self.data.close() self.cmd.close() self.network.stop() def publish_controls(self): self.note.send_multipart([ self.network.uuid().hex.encode(), self.frame_size_control_json().encode() ]) self.note.send_multipart([ self.network.uuid().hex.encode(), self.frame_rate_control_json().encode() ]) def sensor_attach_json(self): sensor = { "subject": "attach", "sensor_name": self.cap.name, "sensor_uuid": self.network.uuid().hex, "sensor_type": 'video', "notify_endpoint": self.note_url, "command_endpoint": self.cmd_url, "data_endpoint": self.data_url } return json.dumps(sensor) def frame_size_control_json(self): index = self.note_seq self.note_seq += 1 self.note_seq %= sequence_limit curr_fs = self.cap.frame_sizes.index(self.cap.frame_size) return json.dumps({ "subject": "update", "control_id": "CAM_RES", "seq": index, "changes": { "value": curr_fs, "dtype": 'intmapping', "min": None, "max": None, "res": None, "def": 0, "caption": 'Resolution', "readonly": False, "map": [{ 'value': idx, 'caption': '{:d}x{:d}'.format(*fs) } for idx, fs in enumerate(self.cap.frame_sizes)] } }) def frame_rate_control_json(self): index = self.note_seq self.note_seq += 1 self.note_seq %= sequence_limit curr_fr = self.cap.frame_rates.index(self.cap.frame_rate) return json.dumps({ "subject": "update", "control_id": "CAM_RATE", "seq": index, "changes": { "value": curr_fr, "dtype": 'intmapping', "min": None, "max": None, "res": None, "def": 0, "caption": 'Frame Rate', "readonly": False, "map": [{ 'value': idx, 'caption': '{:.1f} Hz'.format(fr) } for idx, fr in enumerate(self.cap.frame_rates)] } }) def bind(self, ctx, sock_type, url, public_ep, set_hwm=None): sock = ctx.socket(sock_type) if set_hwm: sock.set_hwm(set_hwm) sock.bind(url) ep = sock.last_endpoint.decode() port = ep.split(':')[-1] public_ep.split(':')[-1] public_addr = public_ep.split(':')[:-1] return sock, ':'.join(public_addr + [port])
class Network: hosting: bool = False def __init__(self): self.open() def get_all_groups(self) -> List[str]: """Get the names of groups that can be joined.""" groups = [] for peer in self.node.peers(): group = self.node.peer_header_value(peer, 'hosting') if group != None and len(group) > 0: groups.append(group) return groups def get_our_group(self) -> Union[str, None]: """What is the name of the group we're in or hosting?""" our_groups = self.node.own_groups() our_groups.remove('untangled2018') if len(our_groups) == 0: return None return our_groups[0] def is_in_group(self) -> bool: """Are we in or hosting a group?""" return self.get_our_group() != None def is_hosting(self) -> bool: """Are we hosting?""" return self.hosting def join_group(self, group: str) -> None: """Join a group of given name (assumes you are not in a group already).""" if group not in self.get_all_groups(): raise ValueError('Group named "%s" does not exist'.format(group)) if self.is_in_group(): raise ValueError( 'You must leave the previous group before you join another') self.node.join(group) def leave_group(self) -> None: """Leave any joined group or stop hosting.""" self.hosting = False if not self.is_in_group(): raise ValueError('You are not in a group') for group in self.node.own_groups(): self.node.leave(group) def host_group(self, name: str) -> None: """Host a group of given name.""" if name in self.get_all_groups(): raise ValueError('A group of the given name already exists') if self.is_in_group(): raise ValueError('Cannot host whilst in a group') self.node.set_header('hosting', name) self.hosting = True self.node.join(name) def open(self) -> None: """Create a new pyre instance and join untangled.""" self.node = Pyre() self.node.start() self.node.join('untangled2018') # used to get our messages self.poller = zmq.Poller() self.poller.register(self.node.socket(), zmq.POLLIN) def get_id(self) -> str: """Get our id, as a unique node on the network.""" return self.node.uuid() def is_me(self, player_id) -> bool: """See if a given id is ours.""" return self.get_id() == player_id def close(self) -> None: """Disconnect from everything""" self.node.stop() def get_messages(self): """See what has been sent to us: who has joined, what have people said, etc""" # what has changed changes = dict(self.poller.poll(0)) # are these the changes we subscribed for if self.node.socket() in changes and changes[ self.node.socket()] == zmq.POLLIN: msgs = self.node.recent_events() return msgs # nothing to return return [] def pull_game(self, game): """Update our game state based on what other people tell us.""" for msg in self.get_messages(): # is it relevant to us? if msg.group != self.get_our_group(): continue if msg.type == 'SHOUT': entities = bson.loads(msg.msg[0]) if 'ids' in entities: keys = entities['ids'] cur_keys = list(game.entities.keys()) diff = list(set(cur_keys) - set(keys)) for key in diff: del game.entities[key] entities = entities['components'] for key, changed_comps in entities.items(): key = uuid.UUID(key) if key not in game.entities: game.entities[key] = {} entity = game.entities[key] for compname, component in changed_comps.items(): try: clas = components.__dict__[compname] if clas in entity: entity[clas] = entity[clas].replace( **component) else: entity[clas] = clas(**component) entity[clas].observed_changes() except Exception: print( 'Error updating component, is everyone in the group on the same version?', file=sys.stdout) elif self.is_hosting(): if msg.type == 'JOIN': game.on_player_join(msg.peer_uuid) self.push_game(game, initial=True) elif msg.type == 'EXIT' or msg.type == "LEAVE": game.on_player_quit(msg.peer_uuid) def push_game(self, game, initial=False): """Tell others how we've changed the game state.""" if len(self.node.peers_by_group(self.get_our_group())) == 0: # Nobody else to talk to return entities = {'components': {}} if self.is_hosting(): entities = {'ids': [], 'components': {}} for key, entity in game.entities.items(): changed_comps = {} for component in entity.values(): if component.is_networked() and (initial or component.has_changed()): changed_comps[component.get_name()] = component.as_dict() component.observed_changes() if 'ids' in entities: entities['ids'].append(key) entities['components'][str(key)] = changed_comps self.node.shout(self.get_our_group(), bson.dumps(entities))