Files
bionickatana f3114b076a
Build / Build source distribution (push) Failing after 8s
Build / Execute unit tests (push) Failing after 6s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
Added 'damage taken' section to the UI
2026-10-10 23:38:32 -06:00

602 lines
20 KiB
Python

import struct
import pytest
from src.decode import photon
from src.decode import party_memory
from src.decode import translate
from src.decode.photon import PhotonDecoder, decode_message18
from src.decode.translate import into_game_message
from src.decode.world import IdCache, World
from src.net.capture import _extract_udp_payload
from src.utils import platform_utils
# --- Protocol18 value builders -------------------------------------------------
def p18_short(value):
return bytes([photon.P18['Short']]) + struct.pack('<h', value)
def p18_string(value):
data = value.encode('utf-8')
return bytes([photon.P18['String']]) + bytes([len(data)]) + data
def p18_compressed_int(value):
zz = (value << 1) if value >= 0 else ((-value << 1) - 1)
out = bytes([photon.P18['CompressedInt']])
while True:
b = zz & 0x7F
zz >>= 7
if zz:
out += bytes([b | 0x80])
else:
return out + bytes([b])
def params_table(entries):
out = bytes([len(entries)])
for key, encoded in entries:
out += bytes([key]) + encoded
return out
def event_payload(opcode, entries):
table = params_table([(252, p18_short(opcode))] + list(entries))
return bytes([0xF3, 0x04, 0x01]) + table
def flagged_event_payload(opcode, entries):
table = params_table([(252, p18_short(opcode))] + list(entries))
return bytes([0xF3, 0x84, 0x01]) + table
def response_payload(opcode, entries):
table = params_table([(253, p18_short(opcode))] + list(entries))
debug = bytes([photon.P18['Null']])
return bytes([0xF3, 0x03, 0x01]) + struct.pack('<h', 0) + debug + table
def enet_packet(command, msg_bytes):
length = 12 + len(msg_bytes)
header = struct.pack('>HBBI', 0, 0, 1, 0) + struct.pack('>I', 0)
command_header = struct.pack('>BBBB', command, 0, 0, 0)
command_header += struct.pack('>I', length) + struct.pack('>I', 0)
return header + command_header + msg_bytes
def enet_unreliable_packet(command, msg_bytes):
unreliable_seq = struct.pack('>I', 17)
length = 12 + len(unreliable_seq) + len(msg_bytes)
header = struct.pack('>HBBI', 0, 0, 1, 0) + struct.pack('>I', 0)
command_header = struct.pack('>BBBB', command, 0, 0, 0)
command_header += struct.pack('>I', length) + struct.pack('>I', 0)
return header + command_header + unreliable_seq + msg_bytes
# --- Protocol18 primitives ------------------------------------------------------
def test_varint_roundtrip():
assert photon.rd_varint(bytes([0x00]), 0) == (0, 1)
assert photon.rd_varint(bytes([0x80, 0x01]), 0) == (128, 2)
assert photon.rd_varint(bytes([0xAC, 0x02]), 0) == (300, 2)
def test_zigzag():
assert photon.zigzag(0) == 0
assert photon.zigzag(1) == -1
assert photon.zigzag(2) == 1
assert photon.zigzag(3) == -2
def test_decode_params_and_compressed_int():
table = params_table([(0, p18_compressed_int(280962)),
(2, p18_string('bionicKatana')),
(3, p18_compressed_int(4))])
params, pos = photon.decode_params18(table, 0)
assert params[0] == 280962
assert params[2] == 'bionicKatana'
assert params[3] == 4
assert pos == len(table)
def test_decode_message18_event():
payload = event_payload(1, [(0, p18_compressed_int(277536))])
message, pos = decode_message18(payload, 0)
assert message.kind == 'Event'
assert message.code == 1
assert message.params[252] == 1
assert message.params[0] == 277536
assert pos == len(payload)
def test_decode_message18_flagged_event():
payload = flagged_event_payload(1, [(0, p18_compressed_int(277536))])
message, pos = decode_message18(payload, 0)
assert message.kind == 'Event'
assert message.params[252] == 1
assert message.params[0] == 277536
assert pos == len(payload)
# --- eNet envelope + fragments --------------------------------------------------
def test_decode_packet_reliable():
decoder = PhotonDecoder()
packet = enet_packet(
photon.CMD_SEND_RELIABLE, event_payload(90, [(0, p18_short(7))]))
messages = decoder.decode_packet(packet)
assert len(messages) == 1
assert messages[0].params[252] == 90
def test_decode_packet_observed_unreliable_fragment_command():
decoder = PhotonDecoder()
packet = enet_unreliable_packet(
photon.CMD_SEND_UNRELIABLE_FRAGMENT,
flagged_event_payload(1, [(0, p18_short(7))]))
messages = decoder.decode_packet(packet)
assert len(messages) == 1
assert messages[0].params[252] == 1
assert messages[0].params[0] == 7
def test_fragment_reassembly():
decoder = PhotonDecoder()
full = event_payload(29, [(0, p18_short(1234))])
split = 5
parts = [full[i:i + split] for i in range(0, len(full), split)]
messages = []
for i, part in enumerate(parts):
start_seq, count = 5, len(parts)
length = 12 + photon.FRAG_HEADER_LEN + len(part)
header = struct.pack('>HBBI', 0, 0, 1, 0) + struct.pack('>I', 0)
cmd = struct.pack('>BBBB', photon.CMD_SEND_FRAGMENT, 0, 0, 0)
cmd += struct.pack('>I', length) + struct.pack('>I', 0)
cmd += struct.pack('>IIIII', start_seq, count, i, len(full), i * split)
messages.extend(decoder.decode_packet(header + cmd + part))
assert len(messages) == 1
assert messages[0].params[252] == 29
assert messages[0].params[0] == 1234
# --- translate ------------------------------------------------------------------
@pytest.mark.parametrize('opcode,name', [
(1, 'Leave'),
(6, 'HealthUpdate'),
(29, 'NewCharacter'),
(32, 'ItemGained'),
(62, 'TakeSilver'),
(82, 'UpdateFame'),
(90, 'CharacterEquipmentChanged'),
(91, 'RegenerationHealthChanged'),
(166, 'KnockedDown'),
(231, 'PartyJoined'),
(233, 'PartyPlayerJoined'),
(235, 'PartyPlayerLeft'),
])
def test_event_opcode_translation(opcode, name):
message, _ = decode_message18(event_payload(opcode, []), 0)
game = into_game_message(message)
assert game is not None
assert game.name == name
def test_operation_translation():
message, _ = decode_message18(response_payload(2, [(0, p18_short(63))]), 0)
game = into_game_message(message)
assert game is not None
assert game.name == 'Join'
def test_unknown_opcode_ignored():
message, _ = decode_message18(event_payload(9999, []), 0)
assert into_game_message(message) is None
def test_party_roster_without_opcode_translates():
message = photon.PhotonMessage('Event', 1, {
0: 123,
9: ['bionicKatana', 'Sweetpea23042'],
}, None, None)
game = into_game_message(message)
assert game is not None
assert game.name == 'PartyRoster'
assert translate.msg_party_roster_names(game) == [
'bionicKatana', 'Sweetpea23042']
def test_unlock_response_string_lists_are_not_party_rosters():
message = photon.PhotonMessage('Response', 1, {
9: ['UNLOCKED_CLAIMABLE', 'UNLOCKED_CLAIMABLE'],
}, None, None)
assert into_game_message(message) is None
# --- world ----------------------------------------------------------------------
def game(name, params=None):
return translate.GameMessage(name, 0, params or {})
def test_id_cache_reuses_id_for_name():
cache = IdCache()
cache.save(100, 'Alice')
assert cache.get_static_id(100) == 0
cache.save(200, 'Alice')
assert cache.get_static_id(200) == 0
assert cache.get_static_id(100) is None
assert cache.get_static_id(300) is None
def test_world_new_character_player_appeared():
world = World()
events = world.transform(game('NewCharacter', {0: 1234, 1: 'Alice'}))
names = [e['name'] for e in events]
assert 'PlayerAppeared' in names
appeared = next(e for e in events if e['name'] == 'PlayerAppeared')
assert appeared['value'] == {'id': 0, 'name': 'Alice'}
def test_world_join_emits_zone_change_and_main_player():
world = World()
events = world.transform(game('Join', {0: 63, 2: 'Alice'}))
assert events[0] == {'name': 'ZoneChange'}
assert events[1]['name'] == 'MainPlayerAppeared'
assert world.main_player_id == 0
second = world.transform(game('Join', {0: 77, 2: 'Alice'}))
assert {'name': 'ZoneChange'} not in second
def test_world_main_player_leave_emits_zone_change():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
events = world.transform(game('Leave', {0: 63}))
assert events == [{'name': 'ZoneChange'}]
def test_world_health_update_damage_and_heal():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
world.transform(game('NewCharacter', {0: 20, 1: 'Attacker'}))
damage = world.transform(game('HealthUpdate', {0: 10, 6: 20, 2: -80.0}))
assert damage[0]['name'] == 'DamageDone'
assert damage[0]['value']['source'] == 1 # attacker
assert damage[0]['value']['target'] == 0 # victim
assert damage[0]['value']['value'] == 80.0
assert damage[1]['name'] == 'DamageTaken'
assert damage[1]['value']['source'] == 0 # victim
assert damage[1]['value']['value'] == 80.0
heal = world.transform(game('HealthUpdate', {0: 10, 6: 20, 2: 40.0}))
assert heal[0]['name'] == 'HealthReceived'
assert heal[0]['value']['source'] == 1
assert heal[0]['value']['value'] == 40.0
assert len(heal) == 1 # healing is not damage taken
def test_world_health_update_unknown_actor_emits_damage_taken():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Victim'}))
events = world.transform(game('HealthUpdate', {0: 10, 6: 999, 2: -50.0}))
assert len(events) == 1
assert events[0]['name'] == 'DamageTaken'
assert events[0]['value']['source'] == 0
assert events[0]['value']['value'] == 50.0
def test_world_health_update_unknown_victim_and_actor_dropped():
world = World()
# neither the attacker nor the victim has a known static id
assert world.transform(game('HealthUpdate', {0: 999, 6: 888, 2: -50.0})) == []
def test_world_health_update_known_actor_unknown_target_emits_damage_done():
world = World()
world.transform(game('NewCharacter', {0: 20, 1: 'Attacker'}))
events = world.transform(game('HealthUpdate', {0: 999, 6: 20, 2: -50.0}))
assert len(events) == 1
assert events[0]['name'] == 'DamageDone'
assert events[0]['value']['source'] == 0
assert events[0]['value']['target'] is None
def test_world_regeneration_combat_states():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
enter = world.transform(game('RegenerationHealthChanged', {0: 10}))
assert enter[0]['name'] == 'EnterCombat'
leave = world.transform(game('RegenerationHealthChanged', {0: 10, 4: 5.0}))
assert leave[0]['name'] == 'LeaveCombat'
def test_world_knocked_down_leaves_combat():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
events = world.transform(game('KnockedDown', {0: 10}))
assert events[0]['name'] == 'LeaveCombat'
def test_world_update_fame_uses_gained():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
events = world.transform(game('UpdateFame', {0: 10, 1: 5000000, 2: 30000}))
assert events[0]['name'] == 'UpdateFame'
assert events[0]['value']['value'] == pytest.approx(3.0)
def test_world_update_fame_delta_from_total():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
assert world.transform(game('UpdateFame', {0: 10, 1: 2000000})) == []
events = world.transform(game('UpdateFame', {0: 10, 1: 2001000}))
assert events[0]['value']['value'] == pytest.approx(0.1)
def test_world_update_fame_applies_bonus_factor():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
events = world.transform(
game('UpdateFame', {0: 10, 1: 5000000, 2: 30000, 17: 0.25}))
assert events[0]['value']['value'] == pytest.approx(3.75)
def test_world_update_fame_applies_premium_and_satchel():
world = World()
world.transform(game('NewCharacter', {0: 10, 1: 'Alice'}))
events = world.transform(
game('UpdateFame', {0: 10, 1: 5000000, 2: 30000, 5: True, 10: 10000}))
assert events[0]['value']['value'] == pytest.approx(5.5)
def test_world_item_gained_emits_collected_item():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
events = world.transform(game('ItemGained', {1: 522, 2: 3, 4: 10000000}))
assert events == [{
'name': 'ItemCollected',
'value': {
'item_id': 522,
'item_name': 'T4_MEAL_SALAD_FISH@3',
'quantity': 3,
'estimated_value': 10000000,
},
}]
def test_world_item_gained_waits_for_main_player_join():
world = World()
assert world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) == []
world.transform(game('NewCharacter', {0: 10, 1: 'SomeoneElse'}))
assert world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1})) == []
def test_world_item_gained_uses_display_name_and_deduplicates():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
first = world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1}))
duplicate = world.transform(game('ItemGained', {0: 293153, 1: 11898, 2: 1}))
assert first == [{
'name': 'ItemCollected',
'value': {
'item_id': 11898,
'item_name': 'Keeper Memory - Shameless or Daring',
'quantity': 1,
},
}]
assert duplicate == []
def test_world_take_silver_tracks_main_player():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
events = world.transform(game('TakeSilver', {0: 63, 3: 648351}))
assert events[0]['name'] == 'SilverGained'
assert events[0]['value']['silver_type'] == 'looted'
assert events[0]['value']['value'] == pytest.approx(64.8351)
def test_world_take_silver_subtracts_taxes():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
events = world.transform(
game('TakeSilver', {0: 63, 3: 500000, 4: 20000, 5: 10000, 6: 5000}))
assert events[0]['value']['value'] == pytest.approx(46.5)
def test_world_take_silver_ignores_other_players():
world = World()
world.transform(game('Join', {0: 63, 2: 'Alice'}))
world.transform(game('NewCharacter', {0: 70, 1: 'Bob'}))
assert world.transform(game('TakeSilver', {0: 70, 3: 450000})) == []
def test_world_take_silver_waits_for_main_player_join():
world = World()
assert world.transform(game('TakeSilver', {0: 63, 3: 450000})) == []
def test_world_unconsumed_equipment_replayed_on_new_character():
world = World()
# equipment arrives before the player is named -> buffered
assert world.transform(
game('CharacterEquipmentChanged', {0: 55, 2: [0, 1]})) == []
events = world.transform(game('NewCharacter', {0: 55, 1: 'Alice'}))
names = [e['name'] for e in events]
assert 'PlayerAppeared' in names
assert 'UpdateItems' in names
def test_party_events_from_structures():
world = World()
world.party.set_main_player_name('Alice')
world.cache.save(1, 'Alice')
joined = world.transform(
game('PartyJoined', {4: [[1, 0], [2, 0]], 5: ['Alice', 'Bob']}))
assert joined[0]['name'] == 'UpdateParty'
assert joined[0]['value']['player_names'] == ['Alice', 'Bob']
left = world.transform(game('PartyPlayerLeft', {1: [2, 0]}))
assert left[0]['value']['player_names'] == ['Alice']
def test_party_roster_event_updates_party():
world = World()
events = world.transform(game('PartyRoster', {
9: ['bionicKatana', 'Sweetpea23042'],
}))
assert events == [{
'name': 'UpdateParty',
'value': {'player_names': ['bionicKatana', 'Sweetpea23042']},
}]
def test_remembered_party_reemits_on_join(monkeypatch, tmp_path):
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
party_memory.save_last_party([
'bionicKatana', 'fatbrick', 'Froedrick712', 'rainbowShade'])
world = World(remember_last_party=True)
events = world.transform(game('Join', {0: 98, 2: 'bionicKatana'}))
assert events[-1] == {
'name': 'UpdateParty',
'value': {'player_names': [
'bionicKatana', 'fatbrick', 'Froedrick712', 'rainbowShade']},
}
def test_party_inference_grows_during_zone_load(monkeypatch, tmp_path):
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
world = World(remember_last_party=True)
world.transform(game('NewCharacter', {0: 97, 1: 'rainbowShade'}))
join = world.transform(game('Join', {0: 98, 2: 'bionicKatana'}))
fatbrick = world.transform(game('NewCharacter', {0: 161, 1: 'fatbrick'}))
froedrick = world.transform(game('NewCharacter', {0: 211, 1: 'Froedrick712'}))
assert _last_party_names(join) == [
'rainbowShade', 'bionicKatana']
assert _last_party_names(fatbrick) == [
'rainbowShade', 'bionicKatana', 'fatbrick']
assert _last_party_names(froedrick) == [
'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712']
assert party_memory.load_last_party() == [
'rainbowShade', 'bionicKatana', 'fatbrick', 'Froedrick712']
def test_party_roster_saves_even_when_autoload_disabled(monkeypatch, tmp_path):
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
world = World(remember_last_party=False)
world.transform(game('PartyRoster', {
9: ['bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712'],
}))
assert party_memory.load_last_party() == [
'bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712']
restarted = World(remember_last_party=True)
events = restarted.transform(game('Join', {0: 98, 2: 'bionicKatana'}))
assert events[-1]['value']['player_names'] == [
'bionicKatana', 'rainbowShade', 'fatbrick', 'Froedrick712']
def test_party_disband_preserves_remembered_party(monkeypatch, tmp_path):
monkeypatch.setattr(platform_utils, 'config_dir', lambda: str(tmp_path))
world = World(remember_last_party=True)
world.transform(game('PartyRoster', {
9: ['bionicKatana', 'fatbrick'],
}))
assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick']
world.transform(game('PartyDisbanded'))
assert party_memory.load_last_party() == ['bionicKatana', 'fatbrick']
assert world.party.last_names == []
def _last_party_names(events):
party_events = [e for e in events if e['name'] == 'UpdateParty']
return party_events[-1]['value']['player_names']
def test_party_main_player_left_disbands():
world = World()
world.party.set_main_player_name('Alice')
world.transform(game('PartyJoined', {4: [[1, 0], [2, 0]],
5: ['Alice', 'Bob']}))
events = world.transform(game('PartyPlayerLeft', {1: [1, 0]}))
assert events[0]['value']['player_names'] == []
# --- capture frame extraction ---------------------------------------------------
def build_ethernet_ipv4_udp(src_port, dst_port, payload):
udp = struct.pack('>HHHH', src_port, dst_port, 8 + len(payload), 0) + payload
ip = bytearray(20)
ip[0] = 0x45
ip[2:4] = struct.pack('>H', 20 + len(udp))
ip[9] = 17
ip[12:16] = bytes([10, 0, 0, 1])
ip[16:20] = bytes([10, 0, 0, 2])
ethernet = bytes(12) + struct.pack('>H', 0x0800)
return ethernet + bytes(ip) + udp
def test_extract_udp_payload_game_port():
frame = build_ethernet_ipv4_udp(12345, 5056, b'hello')
assert _extract_udp_payload(frame) == b'hello'
def test_extract_udp_payload_other_port_ignored():
frame = build_ethernet_ipv4_udp(12345, 1234, b'hello')
assert _extract_udp_payload(frame) is None
def test_extract_udp_payload_with_vlan():
inner = build_ethernet_ipv4_udp(5056, 12345, b'world')
header = inner[:12]
tagged = header + struct.pack('>H', 0x8100) + struct.pack('>H', 42) + inner[12:]
assert _extract_udp_payload(tagged) == b'world'
def build_ethernet_ipv6_udp(src_port, dst_port, payload):
udp = struct.pack('>HHHH', src_port, dst_port, 8 + len(payload), 0) + payload
ip = bytearray(40)
ip[0] = 0x60
ip[6] = 17
ip[8:24] = bytes.fromhex('fe800000000000000000000000000001')
ip[24:40] = bytes.fromhex('fe800000000000000000000000000002')
ethernet = bytes(12) + struct.pack('>H', 0x86DD)
return ethernet + bytes(ip) + udp
def test_extract_udp_payload_ipv6():
frame = build_ethernet_ipv6_udp(5056, 12345, b'v6')
assert _extract_udp_payload(frame) == b'v6'
def test_interface_names_excludes_loopback():
from src.net.capture import CaptureEngine
names = CaptureEngine.interface_names()
assert isinstance(names, list)
assert 'lo' not in names