示例#1
0
 def __init__(self,
              host=None,
              port=None,
              commander_name=None,
              bot_name=None):
     self.server_host = host
     self.server_port = port
     self.config = config
     self.eventregister = EventRegister(self)
     self.eventregister.setup()
     self.commander = Commander(commander_name)
     self.chat = Chat(self)
     self.stats = Statistics()
     self.bot = BotEntity(self, bot_name)
     self.game_ticks = 0
     self.connected = False
     self.logged_in = False
     self.protocol = None
     self.factory = None
     self.entities = None
     self.inventories = inventory.InvetoryContainer(self)
     self.grid = None
     self.sign_waypoints = None
     self.dimension = None
     self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
     self.spawn_position = None
     self.game_mode = None
     self.difficulty = None
     self.players = defaultdict(int)
     self.last_tick_time = datetime.now()
     self.period_time_estimation = config.TIME_STEP
     utils.do_later(config.TIME_STEP, self.tick)
示例#2
0
 def __init__(self, host=None, port=None, commander_name=None, bot_name=None, to_bot_q=None, to_gui_q=None):
     self._to_bot = DummyQueue() if to_bot_q is None else to_bot_q
     self._to_gui = DummyQueue() if to_gui_q is None else to_gui_q
     self.to_gui("name", bot_name)
     self.server_host = host
     self.server_port = port
     self.commander = Commander(commander_name)
     # Users who can give the bot non-administrative commands
     self.managers = set(config.MANAGERS)  # names as given from server
     self.chat = Chat(self)
     self.bot = BotEntity(self, bot_name)
     self.inventories = inventory.Inventories(self.bot)
     self.stats = Statistics()
     self.game_ticks = 0
     self.connected = False
     self.logged_in = False
     self.protocol = None
     self.factory = None
     self.entities = None
     self.grid = None
     self.sign_waypoints = None
     self.dimension = None
     self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
     self.spawn_position = None
     self.game_mode = None
     self.difficulty = None
     self.players = defaultdict(int)
     self.last_tick_time = datetime.now()
     self.period_time_estimation = config.TIME_STEP
     utils.do_later(config.TIME_STEP, self.tick)
     self.shutdown_reason = ""
示例#3
0
 def __init__(self, host=None, port=None, commander_name=None, bot_name=None):
     self.server_host = host
     self.server_port = port
     self.config = config
     self.eventregister = EventRegister(self)
     self.eventregister.setup()
     self.commander = Commander(commander_name)
     self.chat = Chat(self)
     self.stats = Statistics()
     self.bot = BotEntity(self, bot_name)
     self.game_ticks = 0
     self.connected = False
     self.logged_in = False
     self.protocol = None
     self.factory = None
     self.entities = None
     self.inventories = inventory.InvetoryContainer(self)
     self.grid = None
     self.sign_waypoints = None
     self.dimension = None
     self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
     self.spawn_position = None
     self.game_mode = None
     self.difficulty = None
     self.players = defaultdict(int)
     self.last_tick_time = datetime.now()
     self.period_time_estimation = config.TIME_STEP
     utils.do_later(config.TIME_STEP, self.tick)
示例#4
0
 def __init__(self, host=None, port=None, commander_name=None, bot_name=None):
     self.server_host = host
     self.server_port = port
     self.commander = Commander(commander_name)
     self.status_diff = StatusDiff(self)
     self.bot = BotEntity(self, bot_name)
     self.chat = Chat(self)
     self.stats = Statistics()
     self.game_state = GameState()
     self.game_ticks = 0
     self.connected = False
     self.logged_in = False
     self.protocol = None
     self.entities = None
     self.grid = None
     self.navgrid = None
     self.spawn_position = None
     self.dim_entities = [None, None, None]
     self.dim_grid = [None, None, None]
     self.dim_navgrid = [None, None, None]
     self.players = defaultdict(int)
     tools.do_later(config.TIME_STEP, self.tick)
示例#5
0
class World(object):
    def __init__(self, host=None, port=None, commander_name=None, bot_name=None, to_bot_q=None, to_gui_q=None):
        self._to_bot = DummyQueue() if to_bot_q is None else to_bot_q
        self._to_gui = DummyQueue() if to_gui_q is None else to_gui_q
        self.to_gui("name", bot_name)
        self.server_host = host
        self.server_port = port
        self.commander = Commander(commander_name)
        # Users who can give the bot non-administrative commands
        self.managers = set(config.MANAGERS)  # names as given from server
        self.chat = Chat(self)
        self.bot = BotEntity(self, bot_name)
        self.inventories = inventory.Inventories(self.bot)
        self.stats = Statistics()
        self.game_ticks = 0
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.factory = None
        self.entities = None
        self.grid = None
        self.sign_waypoints = None
        self.dimension = None
        self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
        self.spawn_position = None
        self.game_mode = None
        self.difficulty = None
        self.players = defaultdict(int)
        self.last_tick_time = datetime.now()
        self.period_time_estimation = config.TIME_STEP
        utils.do_later(config.TIME_STEP, self.tick)
        self.shutdown_reason = ""

    def predict_next_ticktime(self, tick_start):
        tick_end = datetime.now()
        # time this step took
        d_run = (tick_end - tick_start).total_seconds()
        # decreased by computation in tick
        t = config.TIME_STEP - d_run
        # real tick period
        d_iter = (tick_start - self.last_tick_time).total_seconds()
        # diff from scheduled by
        r_over = d_iter - self.period_time_estimation
        t -= r_over
        t = max(0, t)  # cannot delay into past
        self.period_time_estimation = t + d_run
        self.last_tick_time = tick_start
        return t

    def tick(self):
        tick_start = datetime.now()
        if self.logged_in:
            self.bot.tick()
            self.chat.tick()
            self.every_n_ticks()
        utils.do_later(self.predict_next_ticktime(tick_start), self.tick)

    def every_n_ticks(self, n=100):
        self.game_ticks += 1

    def on_connection_lost(self):
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.bot.on_connection_lost()

    def connection_made(self):
        self.connected = True

    def on_shutdown(self):
        reason = self.shutdown_reason
        reason = reason if reason else "(no reason given)"
        log.msg("Shutting Down: " + reason)
        if self.protocol._transactions and len(self.protocol._transactions) > 5:
            log.msg("Possible memory leak: %s" % self.factory._transactions)
        self.to_gui("shutting down", reason)
        self._to_gui.close()
        self._to_bot.close()
        self.factory.log_connection_lost = False

    def send_packet(self, name, *payload, **kwpayload):
        if payload and not kwpayload:
            kwpayload = payload[0]
        elif kwpayload and payload:
            raise ValueError("Received both payload and kwpayload.")
        if self.protocol is not None:
            self.protocol.send_packet(name, kwpayload)
        else:
            log.msg("Trying to send %s while disconnected" % name)

    def dimension_change(self, dimension):
        dim = dimension + 1  # to index from 0
        d = self.dimensions[dim]
        self.dimension = d
        self.entities, self.grid = d.entities, d.grid
        self.sign_waypoints = d.sign_waypoints
        if self.bot.eid not in self.entities:
            # no etype given as EntityBot has no server-side corollary
            new_bot = entities.EntityBot(eid=self.bot.eid, x=0, y=0, z=0)
            self.entities[new_bot.eid] = new_bot

    def on_entity_equipment(self, slot, slotdata, eid):
        entity = self.entities.get(eid, None)
        if entity is None:
            msg = "Equipment for unkown entity %s, slot %s:  %s"
            log.msg((msg % eid, slot, Item(slotdata)))
            return
        entity.equipment[slot] = Item.from_slotdata(slotdata)

    def on_login(self, bot_eid=None, game_mode=None, dimension=None, difficulty=None):
        self.bot.eid = bot_eid
        self.logged_in = True
        self.dimension_change(dimension)
        self.game_mode = game_mode
        self.difficulty = difficulty

    def on_spawn_position(self, x, y, z):
        self.spawn_position = (x, y, z)
        self.bot.spawn_point_received = True

    def on_respawn(self, game_mode=None, dimension=None, difficulty=None):
        self.dimension_change(dimension)
        self.game_mode = game_mode
        self.difficulty = difficulty
        self.bot.location_received = False
        self.bot.spawn_point_received = False
        self.bot.i_am_dead = False

    def on_time_update(self, age_of_world=None, daytime=None):
        self.age_of_world = age_of_world
        self.daytime = daytime

    def to_bot(self):
        """Convenience method for getting data from the _to_bot queue.
        Returns data if there is data, else returns None
        :rtype: Message
        """
        return None if self._to_bot.empty() else self._to_bot.get()

    def to_gui(self, name, data):
        """world.to_gui('foo', 'stuff') -> send Message 'foo' w/data to gui.
        This is just a convenience method to turn:
            world._to_gui.put(Message('foo', data))
            into:
            world.to_gui('foo', data)
        :rtype: Message
        """
        self._to_gui.put(utils.Message(name, data))

    def update_gui_inventory(self):
        inventory = self.bot.interface.inventory
        items = [item for item in inventory.general if item]
        items = items + [item for item in inventory.ready if item]
        self.to_gui("update items", items)
示例#6
0
class World(object):
    def __init__(self, host=None, port=None, commander_name=None, bot_name=None):
        self.server_host = host
        self.server_port = port
        self.config = config
        self.eventregister = EventRegister(self)
        self.eventregister.setup()
        self.commander = Commander(commander_name)
        self.chat = Chat(self)
        self.stats = Statistics()
        self.bot = BotEntity(self, bot_name)
        self.game_ticks = 0
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.factory = None
        self.entities = None
        self.inventories = inventory.InvetoryContainer(self)
        self.grid = None
        self.sign_waypoints = None
        self.dimension = None
        self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
        self.spawn_position = None
        self.game_mode = None
        self.difficulty = None
        self.players = defaultdict(int)
        self.last_tick_time = datetime.now()
        self.period_time_estimation = config.TIME_STEP
        utils.do_later(config.TIME_STEP, self.tick)

    def predict_next_ticktime(self, tick_start):
        tick_end = datetime.now()
        d_run = (tick_end - tick_start).total_seconds()  # time this step took
        t = config.TIME_STEP - d_run  # decreased by computation in tick
        d_iter = (tick_start - self.last_tick_time).total_seconds()  # real tick period
        r_over = d_iter - self.period_time_estimation  # diff from scheduled by
        t -= r_over
        t = max(0, t)  # cannot delay into past
        self.period_time_estimation = t + d_run
        self.last_tick_time = tick_start
        return t

    def tick(self):
        tick_start = datetime.now()
        if self.logged_in:
            self.bot.tick()
            self.chat.tick()
            self.every_n_ticks()
            self.game_ticks += 1
        utils.do_later(self.predict_next_ticktime(tick_start), self.tick)

    def every_n_ticks(self, n=100):
        pass

    def on_shutdown(self):
        log.msg("Shutdown")
        self.factory.log_connection_lost = False

    def send_packet(self, name, payload):
        if self.protocol is not None:
            self.protocol.send_packet(name, payload)
        else:
            log.err("Trying to send %s while disconnected" % name)

    def dimension_change(self, dimension):
        dim = dimension + 1  # to index from 0
        d = self.dimensions[dim]
        self.dimension = d
        self.entities, self.grid, self.sign_waypoints = d.entities, d.grid, d.sign_waypoints
        if not self.entities.has_entity_eid(self.bot.eid):
            self.entities.new_bot(self.bot.eid)
        log.msg("NEW DIMENSION %d" % dim)

    @property
    def server_lag(self):
        return self.players[config.USERNAME]
示例#7
0
class World(object):

    def __init__(self, host=None, port=None, commander_name=None, bot_name=None):
        self.server_host = host
        self.server_port = port
        self.commander = Commander(commander_name)
        self.status_diff = StatusDiff(self)
        self.bot = BotEntity(self, bot_name)
        self.chat = Chat(self)
        self.stats = Statistics()
        self.game_state = GameState()
        self.game_ticks = 0
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.entities = None
        self.grid = None
        self.navgrid = None
        self.spawn_position = None
        self.dim_entities = [None, None, None]
        self.dim_grid = [None, None, None]
        self.dim_navgrid = [None, None, None]
        self.players = defaultdict(int)
        tools.do_later(config.TIME_STEP, self.tick)

    def tick(self):
        t = config.TIME_STEP
        if self.logged_in:
            t = self.bot.tick()
            self.every_n_ticks()
        tools.do_later(t, self.tick)

    def every_n_ticks(self, n=100):
        self.game_ticks += 1
        if self.game_ticks % n == 0:
            self.status_diff.log()

    def on_connection_lost(self):
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.bot.on_connection_lost()

    def connection_made(self):
        self.connected = True

    def on_shutdown(self):
        pass

    def send_packet(self, name, payload):
        if self.protocol is not None:
            self.protocol.send_packet(name, payload)
        else:
            log.msg("Trying to send %s while disconnected" % name)

    def dimension_change(self, dimension):
        dim = dimension + 1  # to index from 0
        if self.dim_entities[dim] is None:
            es = Entities(self)
            self.dim_entities[dim] = es
            self.entities = es
        if self.dim_grid[dim] is None:
            gd = Grid(self)
            self.dim_grid[dim] = gd
            self.grid = gd
        if self.dim_navgrid[dim] is None:
            ng = NavigationGrid(self)
            self.dim_navgrid[dim] = ng
            self.navgrid = ng
        if not self.entities.has_entity(self.bot.eid):
            self.entities.new_bot(self.bot.eid)

    def login_data(self, bot_eid=None, game_mode=None, dimension=None, difficulty=None):
        self.bot.eid = bot_eid
        self.logged_in = True
        self.dimension_change(dimension)
        self.game_state.update_settings(game_mode=game_mode, dimension=dimension, difficulty=difficulty)

    def respawn_data(self, **kwargs):
        self.login_data(**kwargs)
示例#8
0
class World(object):
    def __init__(self, host=None, port=None, commander_name=None, bot_name=None):
        self.server_host = host
        self.server_port = port
        self.commander = Commander(commander_name)
        self.chat = Chat(self)
        self.bot = BotEntity(self, bot_name)
        self.stats = Statistics()
        self.game_ticks = 0
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.factory = None
        self.entities = None
        self.grid = None
        self.sign_waypoints = None
        self.dimension = None
        self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
        self.spawn_position = None
        self.game_mode = None
        self.difficulty = None
        self.players = defaultdict(int)
        self.last_tick_time = datetime.now()
        self.period_time_estimation = config.TIME_STEP
        utils.do_later(config.TIME_STEP, self.tick)

    def predict_next_ticktime(self, tick_start):
        tick_end = datetime.now()
        d_run = (tick_end - tick_start).total_seconds()  # time this step took
        t = config.TIME_STEP - d_run  # decreased by computation in tick
        d_iter = (tick_start - self.last_tick_time).total_seconds()  # real tick period
        r_over = d_iter - self.period_time_estimation  # diff from scheduled by
        t -= r_over
        t = max(0, t)  # cannot delay into past
        self.period_time_estimation = t + d_run
        self.last_tick_time = tick_start
        return t

    def tick(self):
        tick_start = datetime.now()
        if self.logged_in:
            self.bot.tick()
            self.chat.tick()
            self.every_n_ticks()
        utils.do_later(self.predict_next_ticktime(tick_start), self.tick)

    def every_n_ticks(self, n=100):
        self.game_ticks += 1

    def on_connection_lost(self):
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.bot.on_connection_lost()

    def connection_made(self):
        self.connected = True

    def on_shutdown(self):
        log.msg("Shutdown")
        self.factory.log_connection_lost = False

    def send_packet(self, name, payload):
        if self.protocol is not None:
            self.protocol.send_packet(name, payload)
        else:
            log.msg("Trying to send %s while disconnected" % name)

    def dimension_change(self, dimension):
        dim = dimension + 1  # to index from 0
        d = self.dimensions[dim]
        self.dimension = d
        self.entities, self.grid, self.sign_waypoints = d.entities, d.grid, d.sign_waypoints
        if not self.entities.has_entity(self.bot.eid):
            self.entities.new_bot(self.bot.eid)

    def on_login(self, bot_eid=None, game_mode=None, dimension=None, difficulty=None):
        self.bot.eid = bot_eid
        self.logged_in = True
        self.dimension_change(dimension)
        self.game_mode = game_mode
        self.difficulty = difficulty

    def on_spawn_position(self, x, y, z):
        self.spawn_position = (x, y, z)
        self.bot.spawn_point_received = True

    def on_respawn(self, game_mode=None, dimension=None, difficulty=None):
        self.dimension_change(dimension)
        self.game_mode = game_mode
        self.difficulty = difficulty
        self.bot.location_received = False
        self.bot.spawn_point_received = False
        self.bot.i_am_dead = False

    def on_time_update(self, timestamp=None, daytime=None):
        self.timestamp = timestamp
        self.daytime = daytime
示例#9
0
class World(object):
    def __init__(self,
                 host=None,
                 port=None,
                 commander_name=None,
                 bot_name=None):
        self.server_host = host
        self.server_port = port
        self.config = config
        self.eventregister = EventRegister(self)
        self.eventregister.setup()
        self.commander = Commander(commander_name)
        self.chat = Chat(self)
        self.stats = Statistics()
        self.bot = BotEntity(self, bot_name)
        self.game_ticks = 0
        self.connected = False
        self.logged_in = False
        self.protocol = None
        self.factory = None
        self.entities = None
        self.inventories = inventory.InvetoryContainer(self)
        self.grid = None
        self.sign_waypoints = None
        self.dimension = None
        self.dimensions = [Dimension(self), Dimension(self), Dimension(self)]
        self.spawn_position = None
        self.game_mode = None
        self.difficulty = None
        self.players = defaultdict(int)
        self.last_tick_time = datetime.now()
        self.period_time_estimation = config.TIME_STEP
        utils.do_later(config.TIME_STEP, self.tick)

    def predict_next_ticktime(self, tick_start):
        tick_end = datetime.now()
        d_run = (tick_end - tick_start).total_seconds()  # time this step took
        t = config.TIME_STEP - d_run  # decreased by computation in tick
        d_iter = (tick_start -
                  self.last_tick_time).total_seconds()  # real tick period
        r_over = d_iter - self.period_time_estimation  # diff from scheduled by
        t -= r_over
        t = max(0, t)  # cannot delay into past
        self.period_time_estimation = t + d_run
        self.last_tick_time = tick_start
        return t

    def tick(self):
        tick_start = datetime.now()
        if self.logged_in:
            self.bot.tick()
            self.chat.tick()
            self.every_n_ticks()
            self.game_ticks += 1
        utils.do_later(self.predict_next_ticktime(tick_start), self.tick)

    def every_n_ticks(self, n=100):
        pass

    def on_shutdown(self):
        log.msg("Shutdown")
        self.factory.log_connection_lost = False

    def send_packet(self, name, payload):
        if self.protocol is not None:
            self.protocol.send_packet(name, payload)
        else:
            log.err("Trying to send %s while disconnected" % name)

    def dimension_change(self, dimension):
        dim = dimension + 1  # to index from 0
        d = self.dimensions[dim]
        self.dimension = d
        self.entities, self.grid, self.sign_waypoints = d.entities, d.grid, d.sign_waypoints
        if not self.entities.has_entity_eid(self.bot.eid):
            self.entities.new_bot(self.bot.eid)
        log.msg("NEW DIMENSION %d" % dim)

    @property
    def server_lag(self):
        return self.players[config.USERNAME]