def spawn(self):
"""Sends the ``spawn`` command."""
yield from self.connected.wait()
rawnick = self.nick.encode('utf-8')
msg = struct.pack("<B" + ("H" * len(rawnick)),
0, *rawnick)
yield from self.ws.send(msg)
logger.debug("Spawn sent.")
def toggle_fullscreen(self):
if self.fullscreen:
logger.debug("Fullscreen OFF")
self.create_window()
sdl2.SDL_SetWindowSize(self.window.window,
self.window_w,
self.window_h)
self.fullscreen = False
else:
logger.debug("Fullscreen ON")
sdl2.SDL_SetWindowFullscreen(
self.window.window,
sdl2.SDL_WINDOW_FULLSCREEN)
self.fullscreen = True
def create_party(self):
"""Create a new party."""
logger.info("Creating a new party.")
region = b":".join((self.region.encode('ascii'), b"party"))
data = b"\n".join((region, INIT_TOKEN.encode('ascii')))
res = requests.post('https://m.agar.io/',
data=data,
headers={'Origin': 'http://agar.io',
'User-Agent': USER_AGENT,
'Referer': 'http://agar.io/'})
self.server, self.token, _ = res.text.split('\n')
logger.debug("Server: %s", self.server)
logger.info("Party Token: %s", self.token)
def connect(self):
"""Connects to the server."""
if self.server is None:
self.get_server()
logger.info("Connecting to server %s", self.server)
self.ws = yield from websockets.connect("ws://" + self.server,
origin='http://agar.io')
yield from self.ws.send(struct.pack("<BI", 254, PROTO_VERSION))
yield from self.ws.send(struct.pack("<BI", 255, int(INIT_TOKEN)))
# Send token
msg = struct.pack("B" + ("B" * len(self.token)),
80, *[ord(c) for c in self.token])
yield from self.ws.send(msg)
logger.debug("Connected!")
self.connected.set()
def get_capabilities(self):
asrt(sdl2.SDL_GetRendererInfo(self.renderer, self.renderer_info))
logger.debug("Renderer max texture size: %dx%d",
self.renderer_info.max_texture_width,
self.renderer_info.max_texture_height)
flags = "|".join(filter(None,
(('SDL_RENDERER_SOFTWARE'
if sdl2.SDL_RENDERER_SOFTWARE & self.renderer_info.flags
else ''),
('SDL_RENDERER_ACCELERATED'
if sdl2.SDL_RENDERER_ACCELERATED & self.renderer_info.flags
else ''),
('SDL_RENDERER_PRESENTVSYNC'
if sdl2.SDL_RENDERER_PRESENTVSYNC & self.renderer_info.flags
else ''),
('SDL_RENDERER_TARGETTEXTURE'
if sdl2.SDL_RENDERER_TARGETTEXTURE & self.renderer_info.flags
else ''))))
logger.debug("Renderer capabilities: %s", flags)
def get_server(self):
"""Requests a new server and token."""
if not self.party:
url = 'https://m.agar.io/'
data = b"\n".join((self.region.encode('ascii'),
INIT_TOKEN.encode('ascii')))
else:
url = 'https://m.agar.io/getToken'
data = self.party.encode("ascii")
res = requests.post(url,
data=data,
headers={'Origin': 'http://agar.io',
'User-Agent': USER_AGENT,
'Referer': 'http://agar.io/'})
if not self.party:
self.server, self.token, _ = res.text.split('\n')
else:
self.server = res.text.strip('\n')
self.token = self.party
logger.debug("Server: %s", self.server)
logger.debug("Token: %s", self.token)
def run(self):
"""Logs all everything."""
while True:
data = yield from self.messages.get()
logger.debug(data)
def run(self):
sdl2.ext.init()
sdlttf.TTF_Init()
self.get_screen_size()
for i in range(5, 10):
size = 2**i
self.font[size] = sdlttf.TTF_OpenFont(
FONT_PATH.encode('ascii'),
size)
self.last = time.monotonic()
self.create_window()
# Window creation, we wait for a ScreenAndCamera message.
while True:
data = yield from self.messages.get()
if isinstance(data, ScreenAndCamera):
self.gamescreen = data.screen
self.camera = Camera(data.camera.x, data.camera.y, 0.085)
break
# Play
while True:
try:
data = yield from asyncio.wait_for(self.messages.get(),
1 / self.ref_rate)
except asyncio.TimeoutError:
data = None
if isinstance(data, PlayerCell):
self.player_id = data.cell.id
elif isinstance(data, CameraPosition):
self.camera = data.camera
elif isinstance(data, Leaderboard):
self.update_leaderboard(data)
elif isinstance(data, Status):
for cell in data.cells:
self.players[cell.id] = cell
if cell.name:
self.names[cell.id] = cell.name
for cell in data.dissapears:
if cell.id in self.players:
del self.players[cell.id]
for eats in data.eat:
if eats.eatee == self.player_id:
self.player_id = None
if eats.eatee in self.players:
del self.players[eats.eatee]
# Read sdl events
for event in sdl2.ext.get_events():
if event.type == sdl2.SDL_QUIT:
logger.debug("QUIT event received.")
return
elif event.type == sdl2.SDL_WINDOWEVENT:
if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED:
self.window_w = event.window.data1
self.window_h = event.window.data2
logger.debug("Window resized %dx%d",
event.window.data1,
event.window.data2)
elif event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_f:
self.toggle_fullscreen()
elif event.key.keysym.sym == sdl2.SDLK_ESCAPE:
if self.fullscreen:
self.toggle_fullscreen()
else:
logger.debug("User pressed ESC, exiting.")
return
elif event.type == sdl2.SDL_MOUSEWHEEL:
self.user_zoom += event.wheel.y
if self.user_zoom > 50:
self.user_zoom = 50
elif self.user_zoom < -50:
self.user_zoom = -50
else:
logger.debug("UserZoom: %r", self.user_zoom)
if not self.view_only:
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_SPACE:
logger.debug("SPACE key pressed.")
asyncio.async(self.client.split())
elif event.key.keysym.sym == sdl2.SDLK_w:
logger.debug("W key pressed.")
asyncio.async(self.client.eject())
elif event.type == sdl2.SDL_MOUSEMOTION:
self.mouse_x = event.motion.x
self.mouse_y = event.motion.y
self.move = self.tr_win2game_coords(self.mouse_x,
self.mouse_y)
elif (event.type == sdl2.SDL_MOUSEBUTTONDOWN and
event.button.button == sdl2.SDL_BUTTON_LEFT):
logger.debug("Mouse button pressed.")
asyncio.async(self.client.spawn())
self.now = time.monotonic()
if self.move is not None:
if self.move != self.last_move:
asyncio.async(self.client.move(*self.move))
self.last_move = self.move
self.last_move_send = self.now
elif self.now - self.last_move_send > 0.05:
self.move = self.tr_win2game_coords(self.mouse_x,
self.mouse_y)
if self.move:
asyncio.async(self.client.move(*self.move))
self.last_move = self.move
self.last_move_send = self.now
delay = abs(self.last - self.now)
if self.messages.empty() and delay > 1 / self.ref_rate:
self.refresh()
self.last = self.now
def spectate(self):
"""Initiates the spectator mode."""
yield from self.connected.wait()
yield from asyncio.sleep(2)
yield from self.ws.send(struct.pack("B", 1))
logger.debug("Spectate sent.")
def move(self, x, y):
"""Sends the ``movement`` command."""
yield from self.connected.wait()
yield from self.ws.send(struct.pack("<BddI", 16, x, y, 0))
logger.debug("Move sent (x=%s, y=%s)", x, y)
def eject(self):
"""Sends the ``mass eject`` command."""
yield from self.connected.wait()
msg = struct.pack("<B", 21)
yield from self.ws.send(msg)
logger.debug("Eject sent.")
def split(self):
"""Sends the ``split cell`` command."""
yield from self.connected.wait()
msg = struct.pack("<B", 17)
yield from self.ws.send(msg)
logger.debug("Split sent.")
