Bunker.c

См. документацию.

class Bunker : House
{
    protected const float DOOR_AUTOCLOSE_TIME = 12;
    private bool m_IsActive;
 
    protected ref map<int, ref Timer> m_AutoCloseTimers;
 
    protected DigitalCodeLock_Bunker m_CodeLock;
    
    void Bunker()
    {
        RegisterNetSyncVariableBool("m_IsActive");
    }
 
    // --------------------------------------------------------------------------------
    
    CodeLockComponent GetCodeLockComponent()
    {
        return m_CodeLock.GetCodeLockComponent();
    }
    
    // --------------------------------------------------------------------------------
    
    bool HasCodeLock()
    {
        return m_CodeLock != null;
    }
    
    // --------------------------------------------------------------------------------
    
    DigitalCodeLock_Bunker GetCodeLock()
    {
        return m_CodeLock;
    }
 
    // --------------------------------------------------------------------------------
    
    override void DeferredInit()
    {
        super.DeferredInit();
        
        g_Game.RegisterNetworkStaticObject(this);
    }
 
    // --------------------------------------------------------------------------------
 
    override bool CanDoorBeOpened(notnull DoorManipulationParams params)
    {
        if (IsMainDoor(params.m_DoorIndex))
        {
            AdditionalDoorInfo doorInfo = GetDoorInfo(params.m_DoorIndex);
            string memPointStartName = string.Format("%1_action", doorInfo.m_DoorType);
            string memPointEndName = string.Format("%1_inside", doorInfo.m_DoorType);
            
            bool insideAndInactive = MiscGameplayFunctions.MemPointDirectionalCheck(PlayerBase.Cast(params.m_Caller), this, memPointStartName, memPointEndName) && super.CanDoorBeOpened(params);
            bool outside = m_IsActive && !GetCodeLock().IsLocked() && super.CanDoorBeOpened(params);
 
            return insideAndInactive || outside;
        }
        
        return super.CanDoorBeOpened(params);
    }
    
    // --------------------------------------------------------------------------------
    
    override bool CanDoorBeLocked(int doorIndex)
    {
        return false;
    }
    
    // --------------------------------------------------------------------------------
    
    override void OnDoorOpenStart(DoorStartParams params)
    {
        if (!IsMainDoor(params.param1))
            return;
 
        if (!m_AutoCloseTimers)
            m_AutoCloseTimers = new map<int, ref Timer>();
        
        Timer doorTimer = new Timer();
        doorTimer.Run(DOOR_AUTOCLOSE_TIME, this, "AutoCloseDoor", new Param1<int>(params.param1));
        m_AutoCloseTimers.Set(params.param1, doorTimer);
    }
    
    override void OnDoorCloseStart(DoorStartParams params)
    {
        if (HasCodeLock())
            GetCodeLock().SetLockState(true);
    }
    
    // --------------------------------------------------------------------------------
 
    void SetActive(bool isActive)
    {
        m_IsActive = isActive;
        SetSynchDirty();
    }
    
    // --------------------------------------------------------------------------------
    
    int GetMainDoorIndex()
    {
        return 0;
    }
    
    // --------------------------------------------------------------------------------
    
    protected bool IsMainDoor(int doorIndex)
    {
        return (doorIndex == GetMainDoorIndex());
    }
 
    // --------------------------------------------------------------------------------
    
    protected void AutoCloseDoor(int doorIndex)
    {
        CloseDoor(doorIndex);
        RemoveDoorTimer(doorIndex);
    }
 
    // --------------------------------------------------------------------------------
    
    protected void RemoveDoorTimer(int doorIndex)
    {
        if (m_AutoCloseTimers)
            m_AutoCloseTimers.Remove(doorIndex);
    }
 
    // --------------------------------------------------------------------------------
    
    void OnBunkerActivated(bool loadedAsActive, string codeLockCode)
    {
        DigitalCodeLock_Bunker codeLock = GetCodeLock();
        codeLock.SetLockCode(codeLockCode);
        codeLock.SetLockState(true);
        SetActive(true);
    }
 
    // --------------------------------------------------------------------------------
    
    void OnBunkerDeactivated()
    {
        DigitalCodeLock_Bunker codeLock = GetCodeLock();
        codeLock.SetLockState(false);
        codeLock.Disable();
        SetActive(false);
    }
 
    // --------------------------------------------------------------------------------
    
    #ifdef DIAG_DEVELOPER
    override string GetDebugText()
    {
        string text = super.GetDebugText();
        
        if (m_CodeLock)
        {
            text += string.Format("Code: %1\n", m_CodeLock.GetLockPIN());
            text += string.Format("Active: %1\n", m_IsActive.ToString());
        }
 
        return text;
    }
    #endif
 
}
 
class BroadcastedBunker : Bunker
{
    protected static const int RESOLVE_CODELOCK_RETRY_DELAY = 200;  
 
    protected const string CODE_LOCK_ATTACHMENT_NAME       = "att_codelock";
    protected const string CRATE_SPAWN_POSITION_MEM_NAME   = "storagecratepos";
    protected const string STORAGE_BOX_CLASSNAME           = "StorageBox_Wooden";
 
    private EntityAI m_StorageBox;
 
    // --------------------------------------------------------------------------------
 
 
    override void DeferredInit()
    {
        super.DeferredInit();
 
        ResolveCodeLock();
    }
 
    // --------------------------------------------------------------------------------
 
    protected void ResolveCodeLock()
    {
        int slotId = InventorySlots.GetSlotIdFromString(CODE_LOCK_ATTACHMENT_NAME);
        EntityAI attachment = GetInventory().FindAttachment(slotId);
        if (attachment)
        {
            m_CodeLock = DigitalCodeLock_Bunker.Cast(attachment);
            return;
        }
 
        if (g_Game.IsServer())
        {
            m_CodeLock = DigitalCodeLock_Bunker.Cast(GetInventory().CreateAttachmentEx("DigitalCodeLock_Bunker", slotId));
            m_CodeLock.SetAnimationPhase(CodeLockVisualManager.CODELOCK_ANIMATED_ZIP, 1.0);
            return;
        }

        g_Game.GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(ResolveCodeLock, RESOLVE_CODELOCK_RETRY_DELAY, false);
    }
 
    // --------------------------------------------------------------------------------
    
    override DigitalCodeLock_Bunker GetCodeLock()
    {
        if (!m_CodeLock)
        {
            int slotId = InventorySlots.GetSlotIdFromString(CODE_LOCK_ATTACHMENT_NAME);
            m_CodeLock = DigitalCodeLock_Bunker.Cast(GetInventory().FindAttachment(slotId));
        }
 
        return m_CodeLock;
    }
    
    // --------------------------------------------------------------------------------
    
    override protected void OnBunkerActivated(bool loadedAsActive, string codeLockCode)
    {
        bool wasInitialized = IsInitialized();
 
        if (!wasInitialized)
            return;
 
        super.OnBunkerActivated(loadedAsActive, codeLockCode);
 
        if (!m_StorageBox)
            m_StorageBox = FindOrSpawnStorageBox(loadedAsActive);
    }
 
    // --------------------------------------------------------------------------------
    
    override protected void OnBunkerDeactivated()
    {
        super.OnBunkerDeactivated();
 
        if (m_StorageBox)
        {
            #ifndef SERVER
            m_StorageBox.DeleteSafe();
            #else
            m_StorageBox.SetLifetime(5.0);
            #endif
        }
    }
 
    // --------------------------------------------------------------------------------
 
    private EntityAI FindOrSpawnStorageBox(bool preferExisting)
    {
        if (preferExisting)
        {
            EntityAI existing = FindExistingStorageBox();
            if (existing)
                return existing;
        }
 
        return SpawnStorageBox();
    }
 
    // --------------------------------------------------------------------------------
 
    private EntityAI FindExistingStorageBox()
    {
        if (!MemoryPointExists(CRATE_SPAWN_POSITION_MEM_NAME))
            return null;
 
        vector spawnPosWorld = ModelToWorld(GetMemoryPointPos(CRATE_SPAWN_POSITION_MEM_NAME));
 
        array<Object> objects = new array<Object>();
        array<CargoBase> proxyCargos = new array<CargoBase>();
        g_Game.GetObjectsAtPosition3D(spawnPosWorld, 1.5, objects, proxyCargos);
 
        float bestDist  = 999999;
        EntityAI bestBox = null;
 
        foreach (Object obj : objects)
        {
            if (StorageBox_Colorbase.Cast(obj))
            {
                float dist = vector.Distance(spawnPosWorld, obj.GetWorldPosition());
                if (dist < bestDist)
                {
                    bestDist = dist;
                    bestBox     = EntityAI.Cast(obj);
                }
            }
        }
 
        return bestBox;
    }
 
    // --------------------------------------------------------------------------------
 
    private EntityAI SpawnStorageBox()
    {
        if (!MemoryPointExists(CRATE_SPAWN_POSITION_MEM_NAME))
            return null;
 
        vector positionModel = GetMemoryPointPos(CRATE_SPAWN_POSITION_MEM_NAME);
        vector positionWorld = ModelToWorld(positionModel);
 
        EntityAI storageBox = EntityAI.Cast(g_Game.CreateObjectEx(STORAGE_BOX_CLASSNAME, positionWorld, ECE_CREATEPHYSICS|ECE_UPDATEPATHGRAPH|ECE_KEEPHEIGHT|ECE_EQUIP_CARGO));
        if (storageBox)
        {
            vector directionModel = GetMemoryPointPos("storagecratedir");
            vector directionWorld = ModelToWorld(directionModel);
        
            vector forward    = vector.Direction(positionWorld, directionWorld); // normalized vector      
            
            float yaw = Math.Atan2(forward[0], forward[2]) * Math.RAD2DEG;
            vector orientation = Vector(yaw, 0.0, 0.0);
 
            storageBox.SetOrientation(orientation);
        }
 
        return storageBox;
    }
}
 
class Land_Bunker_Basement_Civilian : BroadcastedBunker {}
class Land_Bunker_Basement_Storage : BroadcastedBunker {}
class Land_Bunker_Basement_Medical : BroadcastedBunker {}
class Land_Bunker_Shelter_Office : BroadcastedBunker {}
class Land_Bunker_Shelter_Storage : BroadcastedBunker {}
class Land_Bunker_Shelter_Medical : BroadcastedBunker {}