Top

sc2.controller module

from s2clientprotocol import sc2api_pb2 as sc_pb
from .protocol import Protocol
from .player import Computer

import logging
logger = logging.getLogger(__name__)

class Controller(Protocol):
    def __init__(self, ws, process):
        super().__init__(ws)
        self.__process = process

    @property
    def running(self):
        return self.__process._process is not None

    async def create_game(self, game_map, players, realtime, random_seed=None):
        assert isinstance(realtime, bool)
        req = sc_pb.RequestCreateGame(
            local_map=sc_pb.LocalMap(
                map_path=str(game_map.relative_path)
            ),
            realtime=realtime
        )
        if random_seed is not None:
            req.random_seed = random_seed

        for player in players:
            p = req.player_setup.add()
            p.type = player.type.value
            if isinstance(player, Computer):
                p.race = player.race.value
                p.difficulty = player.difficulty.value

        logger.info("Creating new game")
        logger.info(f"Map:     {game_map.name}")
        logger.info(f"Players: {', '.join(str(p) for p in players)}")
        result = await self._execute(create_game=req)
        return result

Module variables

var logger

Classes

class Controller

class Controller(Protocol):
    def __init__(self, ws, process):
        super().__init__(ws)
        self.__process = process

    @property
    def running(self):
        return self.__process._process is not None

    async def create_game(self, game_map, players, realtime, random_seed=None):
        assert isinstance(realtime, bool)
        req = sc_pb.RequestCreateGame(
            local_map=sc_pb.LocalMap(
                map_path=str(game_map.relative_path)
            ),
            realtime=realtime
        )
        if random_seed is not None:
            req.random_seed = random_seed

        for player in players:
            p = req.player_setup.add()
            p.type = player.type.value
            if isinstance(player, Computer):
                p.race = player.race.value
                p.difficulty = player.difficulty.value

        logger.info("Creating new game")
        logger.info(f"Map:     {game_map.name}")
        logger.info(f"Players: {', '.join(str(p) for p in players)}")
        result = await self._execute(create_game=req)
        return result

Ancestors (in MRO)

  • Controller
  • sc2.protocol.Protocol
  • builtins.object

Static methods

def __init__(

self, ws, process)

Initialize self. See help(type(self)) for accurate signature.

def __init__(self, ws, process):
    super().__init__(ws)
    self.__process = process

def create_game(

self, game_map, players, realtime, random_seed=None)

async def create_game(self, game_map, players, realtime, random_seed=None):
    assert isinstance(realtime, bool)
    req = sc_pb.RequestCreateGame(
        local_map=sc_pb.LocalMap(
            map_path=str(game_map.relative_path)
        ),
        realtime=realtime
    )
    if random_seed is not None:
        req.random_seed = random_seed
    for player in players:
        p = req.player_setup.add()
        p.type = player.type.value
        if isinstance(player, Computer):
            p.race = player.race.value
            p.difficulty = player.difficulty.value
    logger.info("Creating new game")
    logger.info(f"Map:     {game_map.name}")
    logger.info(f"Players: {', '.join(str(p) for p in players)}")
    result = await self._execute(create_game=req)
    return result

def ping(

self)

async def ping(self):
    result = await self._execute(ping=sc_pb.RequestPing())
    return result

def quit(

self)

async def quit(self):
    await self._execute(quit=sc_pb.RequestQuit())

Instance variables

var running