land_underground_panel.c

Go to the documentation of this file.

enum ELEDState
{
    OFF,
    BLINKING,
    ON,
}
 
enum ELEDColors
{
    RED,
    GREEN,
}
 
class Land_Underground_Panel: House
{
    static ref set<Land_Underground_EntranceBase>       m_Entrances;
    static ref set<Land_Underground_Panel>              m_Panels;
    
    Land_Underground_EntranceBase m_LinkedDoor;
    
    const string COLOR_LED_OFF      = "#(argb,8,8,3)color(0,0,0,1.0,co)";
    const string COLOR_LED_GREEN    = "#(argb,8,8,3)color(0,1,0,1.0,co)";
    const string COLOR_LED_RED      = "#(argb,8,8,3)color(1,0,0,1.0,co)";
    
    const string SELECTION_NAME_LED_RED     = "LED_Red";
    const string SELECTION_NAME_LED_GREEN   = "LED_Green";
    
    bool m_PanelWasUsed
    bool m_PanelWasUsedPrev;
    bool m_BlinkingFlipFlop;
    ref Timer m_FlipFlopTimer;
    
    EffectSound         m_ActivationSound;
    
    ELEDState m_LedStateRed;
    ELEDState m_LedStateGreen;
    
    void Land_Underground_Panel()
    {
        RegisterNetSyncVariableBool("m_PanelWasUsed");
        RegisterPanel(this);
        SetLEDState(ELEDColors.RED, ELEDState.ON);
        SetLEDState(ELEDColors.GREEN, ELEDState.OFF);
    }
    
    void ~Land_Underground_Panel()
    {
        UnregisterPanel(this);
    }
    
    bool CanInteract()
    {
        Land_Underground_EntranceBase door = GetLinkedDoor();
        if (door)
        {
            return Land_Underground_EntranceBase.Cast(door).CanManipulate();
        }
        return false;
    }
    
    void Interact()
    {
        Land_Underground_EntranceBase door = GetLinkedDoor();
        if (door)
        {
            g_Game.RegisterNetworkStaticObject(this);
            Land_Underground_EntranceBase.Cast(door).Manipulate();
            g_Game.GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( ResetPanelUsed, 500);
            m_PanelWasUsed = true;
            SetSynchDirty();
        }
        else
        {
            ErrorEx("Can't find the instance of entrance the panel is linkined to");
        }
    }
    
    static void RegisterEntrance(Land_Underground_EntranceBase entrance)
    {
        if (!m_Entrances)
        {
            m_Entrances = new set<Land_Underground_EntranceBase>();
        }
        m_Entrances.Insert(entrance);
    }
    
    static void UnregisterEntrance(Land_Underground_EntranceBase entrance)
    {
        if (m_Entrances)
        {
            int index = m_Entrances.Find(entrance);
            if (index != -1)
            {
                m_Entrances.Remove(index);
            }
            else
            {
                ErrorEx("Attempted to unregistered non-registered entrance");
            }
        }
    }
    
    static void RegisterPanel(Land_Underground_Panel panel)
    {
        if (!m_Panels)
        {
            m_Panels = new set<Land_Underground_Panel>;
        }
        m_Panels.Insert(panel);
    }
    
    static void UnregisterPanel(Land_Underground_Panel panel)
    {
        if (m_Panels)
        {
            int index = m_Panels.Find(panel);
            if (index != -1)
            {
                m_Panels.Remove(index);
            }
            else
            {
                ErrorEx("Attempted to unregistered non-registered panel");
            }
        }
    }
 
    EUndegroundDoorType GetLinkedDoorType()
    {
        return GetLinkedDoor().m_DoorType;
    }
    
    Land_Underground_EntranceBase GetLinkedDoor()
    {
        if (!m_LinkedDoor)
            m_LinkedDoor = GetClosestDoor();
        return m_LinkedDoor;
    }
    
    Land_Underground_EntranceBase GetClosestDoor()
    {
        if (!m_Entrances)
        {
            return null;
        }
        
        float closestDst = float.MAX;
        Land_Underground_EntranceBase closestObj;
        vector thisPos = GetPosition();
        
        foreach (Land_Underground_EntranceBase obj: m_Entrances)
        {
            float dist = vector.DistanceSq(thisPos, obj.GetPosition());
            if (dist < closestDst)
            {
                closestDst = dist;
                closestObj = obj;
            }
        }
        
        return closestObj;
    }
    
    void SetLEDState(ELEDColors color, ELEDState state)
    {
        #ifndef SERVER
        if (color == ELEDColors.RED)
        {
            if (m_LedStateRed != state)
            {
                m_LedStateRed = state;
                OnLEDStateChanged();
            }
        }
        else
        {
            if (m_LedStateGreen != state)
            {
                m_LedStateGreen = state;
                OnLEDStateChanged();
            }
        }
        #endif
    }
    
    void SetBlinkingTimer(bool enable)
    {
        if (enable)
        {
            if (!m_FlipFlopTimer)
            {
                m_FlipFlopTimer = new Timer();
                m_FlipFlopTimer.Run(0.1, this, "ToggleFlipFlop", NULL, true);
            }
        }
        else
        {
            if (m_FlipFlopTimer)
            {
                m_FlipFlopTimer = null;
            }
        }
    }
    
    void OnLEDStateChanged()
    {
        /*
        Print("OnLEDStateChanged()");
        Print("m_LedStateRed: " + m_LedStateRed);
        Print("m_LedStateGreen: " + m_LedStateGreen);
        */
        if (m_LedStateRed == ELEDState.BLINKING || m_LedStateGreen == ELEDState.BLINKING)
        {
            SetBlinkingTimer(true);
        }
        else
        {
            SetBlinkingTimer(false);
        }
        //red
        if (m_LedStateRed == ELEDState.ON)
        {
            UpdateLED(SELECTION_NAME_LED_RED, COLOR_LED_RED);
        }
        else if (m_LedStateRed == ELEDState.OFF)
        {
            UpdateLED(SELECTION_NAME_LED_RED, COLOR_LED_OFF);
        }
        else if (m_LedStateRed == ELEDState.BLINKING)
        {
            if (m_BlinkingFlipFlop)
            {
                UpdateLED(SELECTION_NAME_LED_RED, COLOR_LED_RED);
            }
            else
            {
                UpdateLED(SELECTION_NAME_LED_RED, COLOR_LED_OFF);
            }
            
        //green
        }
        if (m_LedStateGreen == ELEDState.ON)
        {
            UpdateLED(SELECTION_NAME_LED_GREEN, COLOR_LED_GREEN);
        }
        else if (m_LedStateGreen == ELEDState.OFF)
        {
            UpdateLED(SELECTION_NAME_LED_GREEN, COLOR_LED_OFF);
        }
        else if (m_LedStateGreen == ELEDState.BLINKING)
        {
            if(m_BlinkingFlipFlop)
            {
                UpdateLED(SELECTION_NAME_LED_GREEN, COLOR_LED_GREEN);
            }
            else
            {
                UpdateLED(SELECTION_NAME_LED_GREEN, COLOR_LED_OFF);
            }
            
        }
    }
    
    void ResetPanelUsed()
    {
        m_PanelWasUsed = false;
        SetSynchDirty();
    }
    
    void OnDoorStateChangedClient(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
    {
        switch (GetLinkedDoorType())
        {
            case EUndegroundDoorType.MAIN:
            {
                if (newState >= EUndegroundEntranceState.CLOSED && newState < EUndegroundEntranceState.OPENING_G)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.ON);
                }
                else if (newState == EUndegroundEntranceState.OPENING_G)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.OFF);
                }
                else if (newState >= EUndegroundEntranceState.CLOSING_A)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.BLINKING);
                }
                
                if (newState == EUndegroundEntranceState.CLOSED)
                {
                    SetLEDState(ELEDColors.GREEN, ELEDState.OFF);
                }
                else if (newState >= EUndegroundEntranceState.OPENING_A && newState < EUndegroundEntranceState.OPENING_G)
                {
                    SetLEDState(ELEDColors.GREEN, ELEDState.BLINKING);
                }
                else if (newState >= EUndegroundEntranceState.OPENING_G)
                {
                    SetLEDState(ELEDColors.GREEN, ELEDState.ON);
                }
            }
            break;
            case EUndegroundDoorType.SMALL:
            {
                if (newState == EUndegroundEntranceState.OPENING_A)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.ON);
                    SetLEDState(ELEDColors.GREEN, ELEDState.BLINKING);
                }
                else if (newState == EUndegroundEntranceState.OPENING_B)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.OFF);
                    SetLEDState(ELEDColors.GREEN, ELEDState.ON);
                }
                else if (newState == EUndegroundEntranceState.CLOSING_A)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.BLINKING);
                    SetLEDState(ELEDColors.GREEN, ELEDState.ON);
                }
                if (newState == EUndegroundEntranceState.CLOSING_B || newState == EUndegroundEntranceState.CLOSED)
                {
                    SetLEDState(ELEDColors.RED, ELEDState.ON);
                    SetLEDState(ELEDColors.GREEN, ELEDState.OFF);
                }
            }
            break;
        }
    }
    
    
    protected void UpdateLED(string selection, string color)
    {
        int selectionIdx = GetHiddenSelectionIndex(selection);
        SetObjectTexture(selectionIdx, color);
        //Print("selection: " +selection + ", color: " + color +", selectionIdx: "+ selectionIdx);
    }
    
    void ToggleFlipFlop()
    {
        m_BlinkingFlipFlop = !m_BlinkingFlipFlop;
        OnLEDStateChanged();
    }
    
    void OnPanelUsedSynchronized()
    {
        PlaySoundSet( m_ActivationSound, "UndergroundDoor_PanelActivation_SoundSet", 0, 0 );
    }
    
    override void OnVariablesSynchronized()
    {
        if (m_PanelWasUsed != m_PanelWasUsedPrev)
        {
            if (m_PanelWasUsed)
            {
                OnPanelUsedSynchronized();
            }
            m_PanelWasUsedPrev = m_PanelWasUsed;
        }
    }
    
}