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)
 {
 GetGame().RegisterNetworkStaticObject(this);
 Land_Underground_EntranceBase.Cast(door).Manipulate();
 GetGame().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;
 }
 }
 
}