def test_compute_player_motion_mount_and_active_floor():
    elevator = Movable(
        type=EntityDBEntry(id=EntityType.ACTIVEFLOOR_ELEVATOR),
        position_x=0.5,
        position_y=0.7,
        velocity_x=-0.1,
        velocity_y=-0.3,
    )
    poly_elevator = PolyPointer(101, elevator, MemContext())
    # Turkey on an elevator
    mount = Mount(
        type=EntityDBEntry(id=EntityType.MOUNT_TURKEY),
        position_x=18,
        position_y=13,
        velocity_x=-2,
        velocity_y=-7,
        overlay=poly_elevator,
    )
    poly_mount = PolyPointer(102, mount, MemContext())
    player = Player(position_x=5,
                    position_y=7,
                    velocity_x=-1,
                    velocity_y=-3,
                    overlay=poly_mount)
    expected_motion = PlayerMotion(position_x=18.5,
                                   position_y=13.7,
                                   velocity_x=-2.1,
                                   velocity_y=-7.3)
    run_state = RunState()
    assert run_state.compute_player_motion(player) == expected_motion
Beispiel #2
0
    def __post_init__(self):
        if self.meta.mask < 1:
            raise ValueError(f"invalid mask value {self.meta.mask}")

        empty_poly = PolyPointer.make_empty(self.mem_ctx)

        object.__setattr__(self, "empty_poly", empty_poly)
def test_could_tp_mount(mount_type, expected_could_tp):
    mount = Mount(type=EntityDBEntry(id=mount_type))
    poly_mount = PolyPointer(101, mount, MemContext())
    player = Player(overlay=poly_mount)

    run_state = RunState()
    assert run_state.could_tp(player, set(), set()) == expected_could_tp
Beispiel #4
0
    def add_entity(self, entity: Entity) -> int:
        poly_entity = PolyPointer(
            addr=self.FAKE_ADDR, value=entity, mem_ctx=self.mem_ctx
        )

        item_uid = self.next_uid
        self.next_uid += 1
        self.entity_map[item_uid] = poly_entity
        return item_uid
def test_has_mounted_tame(chain_status, theme, mount_type, mount_tamed,
                          expected_low):
    mount = Mount(type=EntityDBEntry(id=mount_type), is_tamed=mount_tamed)
    poly_mount = PolyPointer(101, mount, MemContext())

    run_state = RunState()
    run_state.sunken_chain_status = chain_status
    run_state.update_has_mounted_tame(theme, poly_mount)

    is_low = Label.LOW in run_state.run_label._set
    assert is_low == expected_low
Beispiel #6
0
def test_state():
    state_mt = DataclassStruct(FieldPath(), State)
    state_bytes = b"\x05\xff\x00\x01\x01\x63\x2a\xff\x08\x01\xff\x02\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00"  # pylint: disable=line-too-long
    mem_ctx = MemContext(BytesReader(b"\x00\x00\x03\x01\x0f\x08"))
    expected = State(
        5,
        (False, True, True),
        frozenset([Player(99, 42), Player(8, 1)]),
        259,
        PolyPointer(4, Player(15, 8), mem_ctx),
    )
    assert state_mt.from_bytes(state_bytes, mem_ctx) == expected
Beispiel #7
0
    def get(self, uid: int) -> PolyPointer[Entity]:
        if self.meta.table_ptr == 0:
            return self.empty_poly

        addr = self._get_addr(uid)
        if addr == 0:
            return self.empty_poly

        entity = self.mem_ctx.type_at_addr(Entity, addr)
        if entity is None:
            return self.empty_poly

        return PolyPointer(addr, entity, self.mem_ctx)
Beispiel #8
0
    def get(self, uid: int) -> PolyPointer[Entity]:
        if self.meta.table_ptr == 0:
            return self.empty_poly

        addr = self._get_addr(uid)
        if addr == 0:
            return self.empty_poly

        entity: Optional[Entity] = self.mem_ctx.type_at_addr(Entity, addr)
        if entity is None:
            return self.empty_poly
        if entity.uid != uid:
            logger.warning(
                "Entity lookup failed with ID mismatch. Expected %d, got %d",
                uid,
                entity.uid,
            )

        return PolyPointer(addr, entity, self.mem_ctx)
def test_compute_player_motion_mount():
    mount = Mount(
        type=EntityDBEntry(id=EntityType.MOUNT_TURKEY),
        position_x=18,
        position_y=13,
        velocity_x=-2,
        velocity_y=-7,
    )
    poly_mount = PolyPointer(101, mount, MemContext())
    player = Player(position_x=5,
                    position_y=7,
                    velocity_x=-1,
                    velocity_y=-3,
                    overlay=poly_mount)
    expected_motion = PlayerMotion(position_x=18,
                                   position_y=13,
                                   velocity_x=-2,
                                   velocity_y=-7)
    run_state = RunState()
    assert run_state.compute_player_motion(player) == expected_motion
Beispiel #10
0
def test_compute_player_motion_active_floor():
    elevator = Movable(
        type=EntityDBEntry(id=EntityType.ACTIVEFLOOR_ELEVATOR),
        position_x=0.5,
        position_y=0.7,
        velocity_x=-0.1,
        velocity_y=-0.3,
    )
    poly_elevator = PolyPointer(101, elevator, MemContext())
    player = Player(position_x=5,
                    position_y=7,
                    velocity_x=-1,
                    velocity_y=-3,
                    overlay=poly_elevator)
    expected_motion = PlayerMotion(position_x=5.5,
                                   position_y=7.7,
                                   velocity_x=-1.1,
                                   velocity_y=-3.3)
    run_state = RunState()
    assert run_state.compute_player_motion(player) == expected_motion
Beispiel #11
0
def poly_pointer_no_mem(value):
    return PolyPointer(addr=0xBAD, mem_ctx=MemContext(), value=value)