def refresh(self):
"""
Draw the current status of the game in ``window``.
The overall process is:
1. The server send information about the board size and status.
1.1. We keep the information about the board in ``gamescreen``.
2. We draw the game in the texture ``stage``. This texture can
be smaller than ``gamescreen``.
3. The rectangle ``camera`` (in game coordinates) is copied from
``stage`` to ``window``.
"""
main = self.players.get(self.player_id)
if main:
self.camera = Camera(main.x, main.y, 0.085)
camera = self.camera_rect
# Set background
sdl2.SDL_SetRenderTarget(self.renderer,
self.stage)
sdl2.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255)
sdl2.SDL_RenderClear(self.renderer)
# Draw the cells (Viruses last)
cells = sorted(self.players.values(),
key=lambda c: (int(c.is_virus), c.size))
for cell in cells:
if cell.id == self.player_id:
if self.client is not None:
label = self.client.nick
else:
label = "PLAYER"
else:
label = self.names.get(cell.id)
x, y = self.tr_game2stage_coords(cell.x, cell.y)
size = self.tr_game2stage_size(cell.size)
# Cell border
fill_color = int('ff' + cell.color, base=16)
r = int(cell.color[:2], base=16)
g = int(cell.color[2:4], base=16)
b = int(cell.color[4:], base=16)
border_color = int('ff%0.2x%0.2x%0.2x' %
(r - 0x10 if r > 0x10 else 0,
g - 0x10 if g > 0x10 else 0,
b - 0x10 if b > 0x10 else 0),
base=16)
if cell.is_virus:
border_size = int(size / 5)
else:
border_size = int(size / 25)
# Cell border
sdlgfx.filledCircleColor(self.renderer, x, y,
size,
border_color)
# Cell fill
sdlgfx.filledCircleColor(self.renderer, x, y,
size - border_size,
fill_color)
if label:
try:
text = asrt(sdlttf.TTF_RenderUTF8_Blended(
self.get_font(size),
label.encode('utf-8', errors='ignore'),
sdl2.SDL_Color(255, 255, 255, 255),
))
text_texture = asrt(sdl2.SDL_CreateTextureFromSurface(
self.renderer,
text))
asrt(sdl2.SDL_FreeSurface(text.contents))
asrt(sdl2.SDL_RenderCopy(
self.renderer,
text_texture,
None,
sdl2.SDL_Rect(int(x-size*0.75),
int(y-size*0.50),
int(size*1.5),
int(size))))
asrt(sdl2.SDL_DestroyTexture(text_texture))
except SDLError:
logger.exception("Error labeling cell.")
# Set background in window
sdl2.SDL_SetRenderTarget(self.renderer, None)
sdl2.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255)
sdl2.SDL_RenderClear(self.renderer)
# Copy the stage
sdl2.SDL_RenderCopy(self.renderer,
self.stage,
camera,
sdl2.SDL_Rect(0, 0, self.window_w, self.window_h))
if self.leaderboard is not None:
sdl2.SDL_RenderCopy(
self.renderer,
self.leaderboard,
None,
sdl2.SDL_Rect(
int(self.window_w * 5 / 6),
0,
int(self.window_w / 6),
int(self.window_h * 2 / 3)))
# Refresh
sdl2.SDL_RenderPresent(self.renderer)
def pyagar(argv=None):
"""pyagar cli interface."""
from pyagar.client import Client
from pyagar.log import logger
from pyagar.utils import hub, GameplaySaver, GameReplay
from pyagar.visual import Visualizer
args = pyagar_parser().parse_args(argv)
if args.command is None:
logger.error("No subcommand present. To play execute: 'pyagar play'")
sys.exit(1)
coros = []
dsts = []
if args.debug is not None:
logger.setLevel(logging.DEBUG)
if args.debug > 1:
from pyagar.utils import Output
output = Output()
coros.append(output.run())
dsts.append(output)
else:
logger.setLevel(logging.INFO)
logger.info("Starting pyagar!")
if VERSION:
logger.info("Version %s", VERSION)
if args.command == "replay":
visualizer = Visualizer(
None,
view_only=True,
hardware=not args.disable_hw)
dsts.append(visualizer)
replayer = GameReplay(args.gameplay_file[0])
coros.append(replayer.run())
coros.append(visualizer.run())
coros.append(hub(replayer, *dsts))
else:
party = args.create_party or args.join_party or False
client = Client(args.nick, region=args.region, party=party)
coros.append(client.read())
visualizer = Visualizer(
client,
view_only=args.command != "play",
hardware=not args.disable_hw)
coros.append(visualizer.run())
dsts.append(visualizer)
if args.command == "list-regions":
from pyagar.utils import print_regions
print_regions(client.get_regions())
sys.exit(0)
elif args.command == "bot":
if args.list_types:
print("Available bot types:\n")
from pyagar.control import Controller
for cls in Controller.__subclasses__():
doc = cls.__doc__ if cls.__doc__ else '**Not documented**'
dedented_text = textwrap.dedent(doc).strip()
name = ' * %s: ' % cls.__name__
msg = textwrap.fill(
dedented_text,
initial_indent=name,
subsequent_indent=' ')
print(msg)
sys.exit(0)
elif args.type:
from pyagar import control
if not hasattr(control, args.type):
print("Unknown bot type")
sys.exit(1)
else:
bot = getattr(control, args.type)
if (not issubclass(bot, control.Controller) or
bot is control.Controller):
print("Invalid bot type.")
sys.exit(1)
else:
controller = bot(client)
coros.append(controller.run())
dsts.append(controller)
elif args.from_file:
from pyagar.control import Controller
module = imp.load_source('botmodule', args.from_file)
if (not hasattr(module, 'UserBot') or
not issubclass(module.UserBot, Controller)):
print("Invalid bot.")
else:
controller = module.UserBot(client)
coros.append(controller.run())
dsts.append(controller)
if args.save is not None:
saver = GameplaySaver(args.save)
coros.append(saver.run())
dsts.append(saver)
coros.append(hub(client, *dsts))
LOOP.run_until_complete(client.connect())
if args.command == "spectate":
LOOP.run_until_complete(client.spectate())
game = asyncio.wait(coros, return_when=asyncio.FIRST_COMPLETED)
done, _ = LOOP.run_until_complete(game)
for coro in done:
try:
coro.result()
except:
logger.exception("Exception running coroutine.")
logger.info("Bye!")
