def setUp(self):
self.client = enet.Host(None, 1, 0, 0, 0)
self.server = enet.Host(enet.Address("localhost", 54301), 1, 0, 0, 0)
self.peer = self.client.connect(enet.Address("localhost", 54301), 1)
self.assertEquals(self.peer.state, enet.PEER_STATE_CONNECTING)
self.assertTrue(self.peer == self.peer)
self.assertFalse(self.peer != self.peer)
def main():
host = enet.Host(None, 1, 0, 0)
peer = host.connect(enet.Address(sys.argv[1], 13000), 1)
data = hashlib.md5(sys.argv[1] + 'R0Ot14').hexdigest()
tries = 0
while True:
evt = host.service(100)
if evt.type == enet.EVENT_TYPE_NONE:
tries += 1
if tries > 10:
send_hint(sys.argv[1])
done(STATUS_NOT_OK, "Timeout", "Timeout")
elif evt.type == enet.EVENT_TYPE_CONNECT:
peer.send(0, enet.Packet(data))
elif evt.type == enet.EVENT_TYPE_RECEIVE:
r_data = evt.packet.data
peer.disconnect()
if r_data == data:
done(STATUS_OK)
fail("received '%s' but '%s' expected" % (r_data, data))
else:
fail("invalid event type: '%s'" % evt.type)
def __init__(self, address="127.0.0.1", port=51441, realtime=True):
""" Constructor for this object """
self._host = enet.Host(None, 1, 0, 0)
self._peer = None
self.buf = bytearray()
self.realtime = realtime
self.address = address
self.port = port
def main():
host = enet.Host(enet.Address(b'0.0.0.0', 13000), 100, 0, 0)
while True:
evt = host.service(0)
if evt.type == enet.EVENT_TYPE_RECEIVE:
data = evt.packet.data
print "%s -> '%r'" % (evt.peer.address, data)
if evt.peer.send(0, enet.Packet(data)) < 0:
print >> sys.stderr, "send error"
def __init__(self, port, max_connections):
self.address = enet.Address(enet.HOST_ANY, port)
self.maxConnections = max_connections
self.host = enet.Host(self.address, max_connections, 0, 0)
if not self.host:
raise "Host could not be created"
#connections stored in a dictionary, with the keys being
#(host_string, port_number) tuple.
self.connections = {}
def __init__(self,
address="localhost",
port=28785,
name="Bot",
playermodel=0):
self.sock = enet.Host(None, 1, 2)
self.address = address
self.port = port
self.name = name
self.playermodel = playermodel
def __init__(self, port=None, interface=b'*', update_interval=1 / 60.0):
if port is not None and interface is not None:
address = enet.Address(interface, port)
else:
address = None
self.host = enet.Host(address, self.max_connections, 1)
self.host.compress_with_range_coder()
self.update_loop = LoopingCall(self.update)
self.update_loop.start(update_interval, False)
self.connections = {}
self.clients = {}
def __init__(self,
host='',
port=0,
conn_limit=4,
handler=None,
message_factory=None,
*args,
**kwargs):
super(Server, self).__init__(host, port, conn_limit, handler,
message_factory, *args, **kwargs)
host = enet.Address(host, port)
self.host = enet.Host(host, conn_limit, *args, **kwargs)
def __init__(self, address="127.0.0.1", port=51441, realtime=True):
""" Constructor for this object """
self._host = enet.Host(None, 1, 0, 0)
self._peer = None
self.buf = bytearray()
self.realtime = realtime
self.address = address
self.port = port
# Not yet supported
self.playedOn = "dolphin"
self.timestamp = ""
self.consoleNick = ""
self.players = {}
def listen(self, factory):
self._factory = factory
self._address = enet.Address(self._interface, self._port)
enet_host = enet.Host(self._address, self._maxclients, self._channels,
self._maxdown, self._maxup)
self._enet_host = ENetHost(enet_host, factory)
self._enet_host.duplicate_peers = self._max_duplicate_peers
log.msg("%s starting on %s" % (self._getLogPrefix(), self._port))
self._reactor.addReader(self._enet_host)
def __init__(self, port=None, interface=b'*', update_interval=1 / 60.0):
if port is not None and interface is not None:
address = enet.Address(interface, port)
else:
address = None
try:
self.host = enet.Host(address, self.max_connections, 1)
except MemoryError:
# pyenet raises memoryerror when the enet host could not be created
raise IOError("Failed to Create Enet Host. Is the Port in use?")
self.host.compress_with_range_coder()
self.update_loop = asyncio.ensure_future(self.update())
self.connections = {}
self.clients = {}
def create(self, args):
ap = getParam('address')
if ap == '':
ipAddress = '127.0.0.1'
else:
ipAddress = ap
pp = getParam('port')
if pp == '':
port = 667
else:
port = pp
self.host = enet.Host(enet.Address(ipAddress, port), 16, 0, 0, 0)
print "Game server started ..."
self.server = VideoServer(ipAddress)
def create(self, args):
ap = getParam('address')
if ap == '':
ipAddress = '127.0.0.1'
else:
ipAddress = ap
pp = getParam('port')
if pp == '':
port = 667
else:
port = pp
print self.clientConnected
self.host = enet.Host(None, 32, 2, 0, 0)
self.peer = self.host.connect(enet.Address(ipAddress, port), 1)
print "Game client connecting to " + ipAddress + ":" + str(port)
self.client = VideoClient(ipAddress)
def __init__(me, port, ip=None, serv=True):
me.ok = True
me.errs = []
me.connected = False
addr = enet.Address("", port) if serv else None
print addr
try:
me.host = enet.Host(addr, 1, 0, 0)
except:
me.log(exc_info, "Unable to create host", addr)
me.peer = None
if serv:
me.wait_for_connection()
else:
me.connect(enet.Address(ip, port))
me.unread = deque()
def __init__(self, host, port):
# Connect
self.host = enet.Host(None, 1, 0, 0, 0)
self.peer = self.host.connect(enet.Address(host.encode("utf-8"), port),
1)
# Wait up to 5 seconds for connection to succeed
event = self.host.service(5000)
if event.type == enet.EVENT_TYPE_CONNECT:
print("Successfully connected to server.")
else:
raise Exception("Failed to connect to server")
# Receive client ID from server
event = self.host.service(1000)
if event.type == enet.EVENT_TYPE_RECEIVE:
self.client_id = pickle.loads(event.packet.data)
print("Client ID is " + str(self.client_id))
else:
raise Exception("Failed to receive client ID from server.")
# Other stuff
self.handlers = []
# --
AW_cmd_type_none = 0
AW_cmd_type_unit_order = 1
AW_cmd_type_spawn_unit = 2
AW_cmd_type_build_unit = 3
AW_cmd_type_generic = 4
AW_cmd_type_end_of_turn = 5
AW_cmd_type_join_game = 6
AW_cmd_type_seed_game = 7
AW_cmd_type_leech_game = 8
AW_cmd_type_ping = 9
# --
free_ports = range(MASTER_SERVER_PORT + 1,
MASTER_SERVER_PORT + MASTER_SERVER_PORT_COUNT)
master_host = enet.Host(enet.Address(None, MASTER_SERVER_PORT), 32, 1, 0, 0)
games = dict()
run = True
logging.info("Running, waiting for connection...")
# --
def game_ready(game_name):
player_count = games[game_name]['player_count']
team_count = games[game_name]['team_count']
if len(games[game_name]['game_instances']) == team_count * (player_count -
1):
logger = logging.getLogger(game_name)
logger.info("Game Ready.")
for i, pl in enumerate(games[game_name]['game_instances']):
pl.send(
self.playerinfo = [[0,0] for _ in range(32)]
self.playerid = None
def get_next_packet(self):
fmt = "fH"
fmtlen = struct.calcsize(fmt)
meta = self.fh.read(fmtlen)
if len(meta) < fmtlen:
raise EOFError("replay file finished")
self.timedelta, size = struct.unpack(fmt, meta)
self.data = self.fh.read(size)
if self.data[0] == 15: # state data
self.playerid = self.data[1]
import enet
from time import time
host = enet.Host(enet.Address(bytes('0.0.0.0', 'utf-8'), args.port), 128, 1)
host.compress_with_range_coder()
clients = {}
client_id = 0
while True:
for cl in list(clients.values()):
if cl.pause_time > 0:
continue
if cl.spam_time is not None and cl.spam_time <= time():
pkt = struct.pack("bbb", 17, 35, 2) + str(cl.timedelta).encode('cp437', 'replace') #chat message
cl.peer.send(0, enet.Packet(pkt, enet.PACKET_FLAG_RELIABLE))
cl.spam_time = time() + 1
while cl.start_time + cl.timedelta <= time():
if cl.data[0] == 3: #input data
player, data = struct.unpack("xbb", cl.data)
cl.playerinfo[player][0] = data
def __init__(self, gameclient, host="127.0.0.1", port=1919):
super(client_adapter, self).__init__(gameclient, host, port)
self.enet = enet.Host(None, 1, 0, 0, 0)
self.server = self.enet.connect(enet.Address(self.host, self.port), 1)
self.connect_to_server()
def __init__(self, host='', port=0, con_limit=4, *args, **kwargs):
super(Server, self).__init__(host, port, con_limit, *args, **kwargs)
host = enet.Address(host, port)
self.host = enet.Host(host, con_limit, *args, **kwargs)
self._peer_cnt = 0
def __init__(self, addr, port, channels=2):
self.enetHost = enet.Host(None, 1, 0, 0)
if self.enetHost is None: raise "Could not create host"
self.connection = None
self.state = "connecting"
self.enetHost.connect(enet.Address(addr, port), channels)
def start(self):
self.host = enet.Host(enet.Address(self.host, self.port), 1000, 0, 0,
0)
def __init__(self, conn_limit=1, *args, **kwargs):
super(Client, self).__init__(*args, **kwargs)
self.host = enet.Host(None, conn_limit)
def __init__(self, port):
self.host = enet.Host(enet.Address(None, port), 10, 0, 0, 0)
self.peers = {} # Map client IDs to peers
self.handlers = []
self.next_client_id = 1
import sys
sys.exit()
args.ip = ip[:-1]
#TODO: fix race condition
import os
if os.path.exists(args.file):
i = 1
while os.path.exists(args.file + "-" + str(i)):
i += 1
args.file += "-" + str(i)
import struct
import enet
from time import time
con = enet.Host(None, 1, 1)
con.compress_with_range_coder()
print('Trying to connect to: ' + args.ip)
peer = con.connect(enet.Address(bytes(args.ip, 'utf-8'), args.port), 1,
args.version)
with open(args.file, "wb") as fh:
fh.write(struct.pack('BB', FILE_VERSION, args.version))
while True:
try:
event = con.service(1000)
except IOError:
continue
if event is None:
continue
elif event.type == enet.EVENT_TYPE_CONNECT:
print('connected to server')
import enet
SHUTDOWN_MSG = "SHUTDOWN"
host = enet.Host(enet.Address(b"localhost", 54301), 10, 0, 0, 0)
connect_count = 0
run = True
shutdown_recv = False
while run:
# Wait 1 second for an event
event = host.service(1000)
if event.type == enet.EVENT_TYPE_CONNECT:
print("%s: CONNECT" % event.peer.address)
connect_count += 1
elif event.type == enet.EVENT_TYPE_DISCONNECT:
print("%s: DISCONNECT" % event.peer.address)
connect_count -= 1
if connect_count <= 0 and shutdown_recv:
run = False
elif event.type == enet.EVENT_TYPE_RECEIVE:
print("%s: IN: %r" % (event.peer.address, event.packet.data))
msg = event.packet.data
if event.peer.send(0, enet.Packet(msg)) < 0:
print("%s: Error sending echo packet!" % event.peer.address)
else:
print("%s: OUT: %r" % (event.peer.address, msg))
if event.packet.data == "SHUTDOWN":
shutdown_recv = True
import enet
host = enet.Host(None, 1, 0, 0)
peer = host.connect(enet.Address("localhost", 33333), 1)
