Upload packets.py with huggingface_hub

packets.py

@@ -0,0 +1,319 @@
+"""
+League of Legends Replay Packet Definitions
+"""
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+from enum import Enum
+
+@dataclass
+class Position:
+    """2D position on the game map"""
+    x: float
+    z: float
+
+class AIType(Enum):
+    """Type of AI entity"""
+    UNKNOWN = "Unknown"
+    HERO = "Hero" 
+    MINION = "Minion"
+    TURRET = "Turret"
+    NEUTRAL = "Neutral"
+
+class ReplicationInternalData:
+    """Internal replication data that can be int or float"""
+    def __init__(self, value: Union[int, float]):
+        self.value = value
+        self.is_int = isinstance(value, int)
+        self.is_float = isinstance(value, float)
+
+@dataclass
+class CreateHero:
+    """Packet for hero/champion creation"""
+    time: float
+    net_id: int
+    name: str
+    champion: str
+
+@dataclass 
+class WaypointGroup:
+    """Packet containing movement waypoints for entities"""
+    time: float
+    waypoints: Dict[int, List[Position]]
+
+@dataclass
+class WaypointGroupWithSpeed:
+    """Packet containing movement waypoints with speed data"""
+    time: float
+    waypoints: Dict[int, List[Position]]
+
+@dataclass
+class EnterFog:
+    """Packet for entity entering fog of war"""
+    time: float
+    net_id: int
+
+@dataclass
+class LeaveFog:
+    """Packet for entity leaving fog of war"""
+    time: float
+    net_id: int
+
+@dataclass
+class UnitApplyDamage:
+    """Packet for damage application between units"""
+    time: float
+    source_net_id: int
+    target_net_id: int
+    damage: float
+
+@dataclass
+class DoSetCooldown:
+    """Packet for ability cooldown updates"""
+    time: float
+    net_id: int
+    slot: int
+    cooldown: float
+    display_cooldown: float
+
+@dataclass
+class BasicAttackPos:
+    """Packet for basic attack with positional data"""
+    time: float
+    source_net_id: int
+    target_net_id: int
+    source_position: Position
+    target_position: Position
+    slot: int
+    caster_net_id: int
+    spell_chain_owner_net_id: int
+    spell_hash: int
+    spell_name: str
+    level: int
+    target_end_position: Position
+    target_net_ids: List[int]
+    windup_time: float
+    cooldown: float
+    mana_cost: float
+
+@dataclass
+class CastSpellAns:
+    """Packet for spell casting"""
+    time: float
+    caster_net_id: int
+    spell_chain_owner_net_id: int
+    spell_hash: int
+    spell_name: str
+    level: int
+    source_position: Position
+    target_position: Position
+    target_end_position: Position
+    target_net_ids: List[int]
+    windup_time: float
+    cooldown: float
+    mana_cost: float
+    slot: int
+
+@dataclass
+class BarrackSpawnUnit:
+    """Packet for minion spawning from barracks"""
+    time: float
+    barrack_net_id: int
+    minion_net_id: int
+    wave_count: int
+    minion_type: int  # 0xc0 = cannon, 0x60 = ranged, 0 = melee
+    minion_level: int
+
+@dataclass
+class ReplicationData:
+    """Replication data for game state synchronization"""
+    primary_index: int
+    secondary_index: int
+    name: str
+    data: ReplicationInternalData
+
+@dataclass
+class Replication:
+    """Packet containing replication data for multiple entities"""
+    time: float
+    net_id_to_replication_datas: Dict[int, ReplicationData]
+
+@dataclass
+class SpawnMinion:
+    """Packet for minion spawning"""
+    time: float
+    net_id: int
+    position1: Position
+    position2: Position
+    name: str
+    skin_name: str
+    level: int
+    targetable_on_client: int
+    targetable_to_team_flags_on_client: int
+    bot: bool
+
+@dataclass
+class CreateNeutral:
+    """Packet for neutral monster creation"""
+    time: float
+    net_id: int
+    position1: Position
+    position2: Position
+    name: str
+    skin_name: str
+    level: int
+    direction: Position
+    camp_id: int
+    neutral_type: int
+
+@dataclass
+class CreateTurret:
+    """Packet for turret creation"""
+    time: float
+    net_id: int
+    owner_net_id: int
+    name: str
+
+@dataclass
+class NPCDieMapView:
+    """Packet for NPC death (map view)"""
+    time: float
+    killer_net_id: int
+    killed_net_id: int
+
+@dataclass
+class NPCDieMapViewBroadcast:
+    """Packet for NPC death broadcast"""
+    time: float
+    killer_net_id: int
+    killed_net_id: int
+
+@dataclass
+class HeroDie:
+    """Packet for hero/champion death"""
+    time: float
+    net_id: int
+
+@dataclass
+class BuyItem:
+    """Packet for item purchase"""
+    time: float
+    net_id: int
+    slot: int
+    item_id: int
+    item_name: str
+    items_in_slot: int
+    spell_charges: int
+    item_gold: float
+    entity_gold_after_change: float
+
+@dataclass
+class RemoveItem:
+    """Packet for item removal"""
+    time: float
+    net_id: int
+    slot: int
+    items_in_slot: int
+    entity_gold_after_change: float
+
+@dataclass
+class SwapItem:
+    """Packet for item slot swapping"""
+    time: float
+    net_id: int
+    source_slot: int
+    target_slot: int
+
+@dataclass
+class UseItem:
+    """Packet for item usage"""
+    time: float
+    net_id: int
+    slot: int
+    items_in_slot: int
+    spell_charges: int
+
+# Union type for all possible packets
+PacketType = Union[
+    CreateHero,
+    WaypointGroup, 
+    WaypointGroupWithSpeed,
+    EnterFog,
+    LeaveFog,
+    UnitApplyDamage,
+    DoSetCooldown,
+    BasicAttackPos,
+    CastSpellAns,
+    BarrackSpawnUnit,
+    Replication,
+    SpawnMinion,
+    CreateNeutral,
+    CreateTurret,
+    NPCDieMapView,
+    NPCDieMapViewBroadcast,
+    HeroDie,
+    BuyItem,
+    RemoveItem,
+    SwapItem,
+    UseItem
+]
+
+def parse_packet_from_dict(packet_dict: dict) -> PacketType:
+    """
+    Parse a packet dictionary into the appropriate packet dataclass.
+    
+    Args:
+        packet_dict: Dictionary containing packet data with 'packet_type' field
+        
+    Returns:
+        Appropriate packet dataclass instance
+        
+    Raises:
+        ValueError: If packet_type is unknown
+    """
+    packet_type = packet_dict.get('packet_type')
+    
+    # Remove packet_type from dict for dataclass creation
+    data = {k: v for k, v in packet_dict.items() if k != 'packet_type'}
+    
+    # Convert position dictionaries to Position objects
+    def convert_positions(obj):
+        if isinstance(obj, dict):
+            if 'x' in obj and 'z' in obj and len(obj) == 2:
+                return Position(x=obj['x'], z=obj['z'])
+            return {k: convert_positions(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [convert_positions(item) for item in obj]
+        return obj
+    
+    data = convert_positions(data)
+    
+    # Map packet types to dataclasses
+    packet_classes = {
+        'CreateHero': CreateHero,
+        'WaypointGroup': WaypointGroup,
+        'WaypointGroupWithSpeed': WaypointGroupWithSpeed,
+        'EnterFog': EnterFog,
+        'LeaveFog': LeaveFog,
+        'UnitApplyDamage': UnitApplyDamage,
+        'DoSetCooldown': DoSetCooldown,
+        'BasicAttackPos': BasicAttackPos,
+        'CastSpellAns': CastSpellAns,
+        'BarrackSpawnUnit': BarrackSpawnUnit,
+        'Replication': Replication,
+        'SpawnMinion': SpawnMinion,
+        'CreateNeutral': CreateNeutral,
+        'CreateTurret': CreateTurret,
+        'NPCDieMapView': NPCDieMapView,
+        'NPCDieMapViewBroadcast': NPCDieMapViewBroadcast,
+        'HeroDie': HeroDie,
+        'BuyItem': BuyItem,
+        'RemoveItem': RemoveItem,
+        'SwapItem': SwapItem,
+        'UseItem': UseItem
+    }
+    
+    if packet_type not in packet_classes:
+        raise ValueError(f"Unknown packet type: {packet_type}")
+    
+    return packet_classes[packet_type](**data)