Rogue of Gems

// IEquippable.cspublic interface IEquippable
{
    string EquipmentName { get; }
    Sprite Icon { get; }
    void Use(Vector3 direction, Vector3 origin);
    bool CanUse();
}

// EquipmentManager.cspublic class EquipmentManager : MonoBehaviour
{
    private IEquippable leftHandEquipment;
    private IEquippable rightHandEquipment;
    private GameObject leftHandPrefab;  // Store for swap/drop
    private GameObject rightHandPrefab;
    
    public void EquipToSlot(GameObject equipmentPrefab, int slot)
    {
        GameObject equipmentObj = Instantiate(equipmentPrefab, firePoint);
        IEquippable equipment = equipmentObj.GetComponent<IEquippable>();
        
        if (slot == 0) {
            leftHandEquipment = equipment;
            leftHandPrefab = equipmentPrefab;
        } else {
            rightHandEquipment = equipment;
            rightHandPrefab = equipmentPrefab;
        }
    }
}

// EnhancementData.cs
[System.Serializable]
public class EnhancementData
{
    public float damageMultiplier = 1f;
    public int bonusBounces = 0;
    public float fireRateMultiplier = 1f;
    public int bulletsPerShotBonus = 0;
    public float slowMultiplierBonus = 0f;
    public float bulletSpeedMultiplier = 1f;
    public bool enableHoming = false;
    public bool enableExplosion = false;
}

// EnhancementManager.cspublic class EnhancementManager : MonoBehaviour
{
    private EnhancementData leftHandEnhancement;
    private EnhancementData rightHandEnhancement;
    
    public void AddWeaponEnhancement(int slot, string type, float value)
    {
        EnhancementData e = GetEnhancement(slot);
        
        switch (type)
        {
            case "Damage": e.damageMultiplier *= value; break;
            case "FireRate": e.fireRateMultiplier *= value; break;
            case "BulletsPerShot": e.bulletsPerShotBonus += (int)value; break;
            case "Bounce": e.bonusBounces += (int)value; break;
            case "SlowEffect": e.slowMultiplierBonus += value; break;
            case "BulletSpeed": e.bulletSpeedMultiplier *= value; break;
            case "Homing": e.enableHoming = true; break;
            case "Explosion": e.enableExplosion = true; break;
        }
    }
}

// Gun.cs - Apply enhancements at runtimepublic override void Use(Vector3 direction, Vector3 origin)
{
    EnhancementData e = EnhancementManager.Instance.GetEnhancement(slotIndex);
    
    float enhancedDamage = damage * e.damageMultiplier;
    int enhancedBullets = bulletsPerShot + e.bulletsPerShotBonus;
    float enhancedSpeed = bulletSpeed * e.bulletSpeedMultiplier;
    
    for (int i = 0; i < enhancedBullets; i++)
    {
        GameObject bullet = Instantiate(bulletPrefab);
        bullet.GetComponent<Bullet>().Initialize(direction, enhancedSpeed, enhancedDamage);
        ApplyEnhancementToBullet(bullet, e);
    }
}

void ApplyEnhancementToBullet(Bullet bullet, EnhancementData e)
{
    if (e.enableExplosion) 
        SetField(bullet, "isExplosive", true);
    
    if (e.bonusBounces > 0) {
        SetField(bullet, "isBouncy", true);
        int baseBounces = GetField<int>(bullet, "maxBounces");
        SetField(bullet, "maxBounces", baseBounces + e.bonusBounces);
    }
    
    if (e.enableHoming) 
        SetField(bullet, "isHoming", true);
    
    if (e.slowMultiplierBonus > 0) {
        SetField(bullet, "hasSlowEffect", true);
        float baseSlow = GetField<float>(bullet, "slowMultiplier");
        SetField(bullet, "slowMultiplier", baseSlow * (1f - e.slowMultiplierBonus));
    }
}

// RoomGenerator.cs - QuadTree spatial partitioningvoid BuildQuadTree(QuadTreeNode node, int depth)
{
    if (depth >= maxDepth || node.bounds.width < minRegionSize 
        || Random.value > splitChance)
    {
        node.isLeaf = true;
        node.isWalkable = Random.value > obstacleDensity;
        return;
    }
    
    node.children = new QuadTreeNode[4];
    float halfW = node.bounds.width / 2f;
    float halfH = node.bounds.height / 2f;
    
    node.children[0] = new QuadTreeNode(
        new Rect(node.bounds.x, node.bounds.y, halfW, halfH));
    // ... create other 3 quadrants
    
    foreach (var child in node.children)
        BuildQuadTree(child, depth + 1);
}

// A* pathfinding ensures reachabilityList<Vector2Int> FindPath(Vector2Int start, Vector2Int end)
{
    List<PathNode> openList = new List<PathNode>();
    HashSet<Vector2Int> closedSet = new HashSet<Vector2Int>();
    
    openList.Add(new PathNode { 
        position = start, 
        gCost = 0, 
        hCost = Vector2Int.Distance(start, end) 
    });
    
    while (openList.Count > 0)
    {
        PathNode current = openList.OrderBy(n => n.fCost).First();
        if (current.position == end) 
            return ReconstructPath(current);
        
        openList.Remove(current);
        closedSet.Add(current.position);
        
        foreach (Vector2Int neighbor in GetNeighbors(current.position))
        {
            if (closedSet.Contains(neighbor) || !IsWalkable(neighbor)) 
                continue;
            
            float tentativeG = current.gCost + 
                Vector2Int.Distance(current.position, neighbor);
            
            PathNode neighborNode = openList
                .FirstOrDefault(n => n.position == neighbor);
            
            if (neighborNode == null)
            {
                openList.Add(new PathNode {
                    position = neighbor,
                    gCost = tentativeG,
                    hCost = Vector2Int.Distance(neighbor, end),
                    parent = current
                });
            }
        }
    }
    return null;
}

// Guarantee all exits are reachablevoid EnsurePathsReachable()
{
    Vector2Int spawnGrid = WorldToGrid(playerSpawnPosition);
    
    foreach (var door in exitDoors)
    {
        Vector2Int doorGrid = WorldToGrid(door.position);
        List<Vector2Int> path = FindPath(spawnGrid, doorGrid);
        
        if (path == null || path.Count == 0)
            path = CreateForcedPath(spawnGrid, doorGrid);
        
        foreach (var tile in path)
            WidenPath(tile, pathWidth);
    }
}

// RoomMapSystem.csvoid GenerateMap()
{
    // Start: 1 room
    List<Room> startColumn = new List<Room> { 
        new Room(0, RoomType.Normal, 0, 0) 
    };
    roomColumns.Add(startColumn);
    
    // Expansion phase: 1→2→3→4 rooms
    for (int i = 1; i <= maxRoomHalf; i++)
    {
        int nextCount = previousColumn.Count + Random.Range(1, 3);
        List<Room> newColumn = GenerateRooms(i, nextCount);
        ConnectRoomsExpanding(previousColumn, newColumn);
        roomColumns.Add(newColumn);
    }
    
    // Convergence phase: 4→2→1 Boss
    while (previousColumn.Count > 3)
    {
        int nextCount = previousColumn.Count / 2;
        List<Room> newColumn = GenerateRooms(currentColumn, nextCount);
        ConnectRoomsConverging(previousColumn, newColumn);
        roomColumns.Add(newColumn);
    }
    
    // Final Boss room
    Room bossRoom = new Room(roomIdCounter++, RoomType.Boss, finalColumn, 0);
    foreach (Room room in previousColumn)
        room.connectedRooms.Add(bossRoom);
}