Dayz Explorer  1.24.157551 (v105080)
Dayz Code Explorer by Zeroy
land_underground_entrance.c
Go to the documentation of this file.
2 {
4  CLOSED,//fully closed
5  //opening
10  OPENING_E,//fully open
12  OPENING_G,
13  //closing
19  CLOSING_F,
21 }
22 
23 enum EUndegroundDoorType
24 {
25  MAIN,
26  SMALL,
27 }
28 
29 class AlarmLight : SpotlightLight
30 {
31  void AlarmLight()
32  {
33  SetVisibleDuringDaylight(true);
34  SetRadiusTo(15);
35  SetBrightnessTo(10);
36  SetFlareVisible(false);
37  SetAmbientColor(1.0, 0.0, 0.0);
38  SetDiffuseColor(1.0, 0.0, 0.0);
39  SetLifetime(1000);
40  SetDisableShadowsWithinRadius(-1);
41  SetFadeOutTime(1);
42  SetCastShadow(false);
43  m_FadeInTime = 0.25;
44  }
45 }
46 
47 //---------------------------------------------------------------------------------------------------------
48 //------------------------------------ Land_Underground_EntranceBase --------------------------------------
49 //---------------------------------------------------------------------------------------------------------
50 
52 {
54  EUndegroundEntranceState m_DoorStatePrev = EUndegroundEntranceState.UNINITIALIZED;
55  float m_AnimPhase;
56  ref AnimationTimer m_AnimTimerDoorServer;
57  ref Timer m_NavmeshTimer;
58  ref array<Land_Underground_Panel> m_ConnectedPanels;
59  EUndegroundDoorType m_DoorType;
60 
61  EntranceLight m_InteriorLight1;
62  EntranceLight m_InteriorLight2;
63  EntranceLight m_InteriorLight3;
64 
66  {
67  m_DoorType = EUndegroundDoorType.MAIN;
68  Land_Underground_Panel.RegisterEntrance(this);
69  RegisterNetSyncVariableFloat("m_AnimPhase", 0,1,5);
70  RegisterNetSyncVariableInt("m_DoorState", 0, EnumTools.GetLastEnumValue(EUndegroundEntranceState));
71 
72  #ifndef SERVER
73  GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( CreateLights, 250);
74  #endif
75  }
76 
77  void CreateLights();
78 
80  {
81  Land_Underground_Panel.UnregisterEntrance(this);
82  #ifndef SERVER
83  CleanUpOnDeleteClient();
84  #endif
85  }
86  //---------------------
87 
88 
89  void CleanUpOnDeleteClient()
90  {
91  //anything we might have started playing when the door was activated
92  CleanUpOnClosedClient();
93  }
94 
95 
96  void CleanUpOnClosedClient();
97 
98  bool CanManipulate(Param param = null)
99  {
100  return m_DoorState == EUndegroundEntranceState.CLOSED;
101  }
102 
103  void Manipulate(Param param = null)
104  {
105  OpenServer();
106  }
107 
108  void NavmeshUpdate()
109  {
110  }
111 
112  void OnUpdateClient(float timeSlice);
113 
114  override void EOnPostSimulate(IEntity other, float timeSlice)
115  {
116  #ifndef SERVER
117  OnUpdateClient(timeSlice);
118  #endif
119  }
120 
121  void OnUpdateServer()
122  {
123  m_AnimPhase = m_AnimTimerDoorServer.GetValue() / AdjustTime(GetOpeningTime());// make 0..1
124  SetAnimationPhaseNow("EntranceDoor",m_AnimPhase);
125 
126  GetGame().GetWorld().UpdatePathgraphDoorByAnimationSourceName(this, "EntranceDoor");
127 
128  SetSynchDirty();
129  }
130 
131  void GetConnectedPanels(array<Land_Underground_Panel> panels)
132  {
133  if (!Land_Underground_Panel.m_Panels)
134  {
135  return;
136  }
138  {
139  if (p.GetClosestDoor() == this)
140  {
141  panels.Insert(p);
142  }
143  }
144  }
145 
146  // checks whether we want to play this effect even when we are at a different(more advanced) state, as this effect is supposed to be playing over multiple states and was supposed to start during some earlier state switch
147  // param 'state' is the state this effect is supposed to be played in, and 'lastValidState' is the latests state where we still want to play this effect provided previous state for the client is UNINITIALIZED
148  // meaning the client just connected in/the item entered their multiplayer bubble
149  bool CheckShouldPlayPersistent(EUndegroundEntranceState state, EUndegroundEntranceState lastValidState)
150  {
151  return m_DoorState == state || ( IsInitDoorStateSync() && m_DoorState > state && m_DoorState <= lastValidState);
152  }
153 
154  float AdjustTime(float originalTime, float adjustedTime = -1)
155  {
156  #ifdef DIAG_DEVELOPER
157  float timeAccel = 1;
158 
159  if (adjustedTime != -1)
160  {
161  return adjustedTime;
162  }
163  if (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.UNDERGROUND_ENTRANCE))
164  {
165  timeAccel = FeatureTimeAccel.GetFeatureTimeAccelValue();
166  return originalTime / timeAccel;
167  }
168  #endif
169  return originalTime;
170  }
171 
172  float GetOpeningTime()
173  {
174  return 30;
175  }
176 
177  void RequestLatentTransition(float time, EUndegroundEntranceState targetState = EUndegroundEntranceState.UNINITIALIZED)
178  {
179  if (targetState == EUndegroundEntranceState.UNINITIALIZED)
180  {
181  targetState = m_DoorState + 1;
182  }
183  GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( SetDoorStateServer, time * 1000, false, targetState);
184  }
185 
186  void SetDoorStateServer(EUndegroundEntranceState newState)
187  {
188  m_DoorState = newState;
189  OnDoorStateChangedServer(newState);
190  SetSynchDirty();
191  }
192 
193  void OnDoorStateChangedServer(EUndegroundEntranceState newState);
194 
195  void OnDoorStateChangedClient(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
196  {
197  if (newState > EUndegroundEntranceState.CLOSED)
198  {
199  SetEventMask(EntityEvent.POSTSIMULATE);
200  }
201  else
202  {
203  ClearEventMask(EntityEvent.POSTSIMULATE);
205  }
206 
207  HandleAudioPlayback(newState, prevState);
208  HandleVisualPlayback(newState, prevState);
209 
210  if (!m_ConnectedPanels)
211  {
212  m_ConnectedPanels = new array<Land_Underground_Panel>();
213  GetConnectedPanels(m_ConnectedPanels);
214  }
215  foreach (Land_Underground_Panel p:m_ConnectedPanels)
216  {
217  p.OnDoorStateChangedClient(newState, prevState);
218  }
219  }
220 
221  void OpenServer(bool force = false)
222  {
223  GetGame().RegisterNetworkStaticObject(this);
224  if (m_DoorState == EUndegroundEntranceState.CLOSED || force)
225  {
226  SetDoorStateServer(EUndegroundEntranceState.OPENING_A);
227  }
228  }
229 
230  void HandleVisualPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState);
231  void HandleAudioPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState);
232 
233  void OnFinishedTimerServer();
234 
235  override void OnVariablesSynchronized()
236  {
237  super.OnVariablesSynchronized();
238 
239  if (m_DoorState != m_DoorStatePrev)
240  {
241  OnDoorStateChangedClient(m_DoorState, m_DoorStatePrev);
242  m_DoorStatePrev = m_DoorState;
243  }
244  }
245 
246  bool IsInitDoorStateSync()
247  {
248  return m_DoorStatePrev == EUndegroundEntranceState.UNINITIALIZED;
249  }
250 
251 
252  #ifdef DEVELOPER
253  override string GetDebugText()
254  {
255  string debug_output;
256 
257  if (GetGame().IsDedicatedServer())
258  {
259  debug_output += "current state: " + typename.EnumToString(EUndegroundEntranceState, m_DoorState) + "\n";
260  /*
261  if(GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ))
262  debug_output += "next stage timer: " + GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).GetRemainingTimeByName(this, "SetDoorStateServer").ToString();
263  */
264  }
265  else
266  {
267  debug_output += "current state: " + typename.EnumToString(EUndegroundEntranceState, m_DoorState) + "\n";
268  }
269  return debug_output;
270  }
271 
272  override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
273  {
274  outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.ACTIVATE_ENTITY, "Open", FadeColors.LIGHT_GREY));
275  outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.DEACTIVATE_ENTITY, "Close", FadeColors.LIGHT_GREY));
276  outputList.Insert(new TSelectableActionInfoWithColor(SAT_DEBUG_ACTION, EActions.SEPARATOR, "___________________________", FadeColors.LIGHT_GREY));
277 
278  super.GetDebugActions(outputList);
279  }
280 
281  override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
282  {
283  if (super.OnAction(action_id, player, ctx))
284  return true;
285  if (GetGame().IsServer() || !GetGame().IsMultiplayer())
286  {
287  if (action_id == EActions.ACTIVATE_ENTITY)
288  {
289  if (m_DoorState == EUndegroundEntranceState.CLOSED)
290  OpenServer(true);
291  }
292  else if (action_id == EActions.DEACTIVATE_ENTITY)
293  {
294  // just for debug controls
295  if (!m_AnimTimerDoorServer)
296  m_AnimTimerDoorServer = new AnimationTimer();
297 
298  if (m_DoorState == EUndegroundEntranceState.OPENING_G)
299  {
300  GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).Remove(SetDoorStateServer);
301  SetDoorStateServer(EUndegroundEntranceState.CLOSING_A);
302  }
303  }
304  }
305  return false;
306  }
307  #endif
308 }
309 
310 
311 //---------------------------------------------------------------------------------------------------------
312 //-------------------------------------- Land_Underground_Entrance ----------------------------------------
313 //---------------------------------------------------------------------------------------------------------
314 
315 class Land_Underground_Entrance : Land_Underground_EntranceBase
316 {
325 
326 
328 
329  const string SIREN_SOUNDSET = "UndergroundDoor_Alarm_Loop_SoundSet";
330  const string ENGINE_SOUNDSET_LOOP_IN = "UndergroundDoor_ElectricMotor_Start_SoundSet";
331  const string ENGINE_SOUNDSET_LOOP = "UndergroundDoor_ElectricMotor_Loop_SoundSet";
332  const string ENGINE_SOUNDSET_LOOP_OUT = "UndergroundDoor_ElectricMotor_End_SoundSet";
333  const string LOCKING_SOUNDSET = "UndergroundDoor_Lock_SoundSet";
334  const string DOORMOVING_SOUNDSET_LOOP = "UndergroundDoor_DoorOpen_Loop_SoundSet";
335  const string DOORMOVING_SOUNDSET_LOOP_OUT = "UndergroundDoor_DoorOpen_End_SoundSet";
336  const string DOORMOVING_SOUNDSET_LOOP_IN = "UndergroundDoor_DoorOpen_Start_SoundSet";
337 
338  const float LIGHT_ROT_SPEED = -400;
339 
340  override void CreateLights()
341  {
342  m_InteriorLight1 = EntranceLight.Cast(ScriptedLightBase.CreateLightAtObjMemoryPoint(EntranceLightMain1, this, "InteriorLightPos1"));
343  m_InteriorLight2 = EntranceLight.Cast(ScriptedLightBase.CreateLightAtObjMemoryPoint(EntranceLightMain2, this, "InteriorLightPos2"));
344  }
345 
346  override void CleanUpOnClosedClient()
347  {
348  SEffectManager.DestroySound(m_SirenSound);
349  SEffectManager.DestroySound(m_LockingSound);
353  SEffectManager.DestroySound(m_DoorEngineSoundIn);
354  SEffectManager.DestroySound(m_DoorEngineSoundOut);
356 
357  if (m_AlarmLight && GetGame())
358  {
359  m_AlarmLight.Destroy();
360  }
361  }
362 
364  {
365  switch (newState)
366  {
367  case EUndegroundEntranceState.OPENING_A:
368  RequestLatentTransition(AdjustTime(3));
369  break;
370  case EUndegroundEntranceState.OPENING_B:
371  RequestLatentTransition(AdjustTime(2));
372  break;
373  case EUndegroundEntranceState.OPENING_C:
374  RequestLatentTransition(AdjustTime(1));
375  break;
376  case EUndegroundEntranceState.OPENING_D:
377  m_AnimTimerDoorServer = new AnimationTimer();
378  m_AnimTimerDoorServer.Run(AdjustTime(GetOpeningTime()), this, "OnUpdateServer", "OnFinishedTimerServer",0, false,/*1/ AdjustTime(1)*/ 1);
379  m_NavmeshTimer = new Timer();
380  m_NavmeshTimer.Run(3, this, "NavmeshUpdate", NULL, true);
381  RequestLatentTransition(AdjustTime(GetOpeningTime()));
382  break;
383  case EUndegroundEntranceState.OPENING_E:
384  m_AnimTimerDoorServer.Stop();
385  NavmeshUpdate();
386  m_NavmeshTimer = null;
387  RequestLatentTransition(AdjustTime(3));
388  break;
389  case EUndegroundEntranceState.OPENING_F:
390  RequestLatentTransition(AdjustTime(3));
391  break;
392  case EUndegroundEntranceState.OPENING_G:
393  RequestLatentTransition(AdjustTime(300));
394  break;
395  case EUndegroundEntranceState.CLOSING_A:
396  RequestLatentTransition(AdjustTime(3));
397  break;
398  case EUndegroundEntranceState.CLOSING_B:
399  RequestLatentTransition(AdjustTime(3));
400  break;
401  case EUndegroundEntranceState.CLOSING_C:
402  m_NavmeshTimer = new Timer();
403  m_NavmeshTimer.Run(3, this, "NavmeshUpdate", NULL, true);
404  m_AnimTimerDoorServer.Run(0, this, "OnUpdateServer", "OnFinishedTimerServer", AdjustTime(GetOpeningTime()),false, /*1/ AdjustTime(1)*/ 1);
405  RequestLatentTransition(AdjustTime(GetOpeningTime()));
406  break;
407  case EUndegroundEntranceState.CLOSING_D:
408  NavmeshUpdate();
409  m_NavmeshTimer = null;
410  RequestLatentTransition(AdjustTime(2));
411  break;
412  case EUndegroundEntranceState.CLOSING_E:
413  RequestLatentTransition(AdjustTime(1));
414  break;
415  case EUndegroundEntranceState.CLOSING_F:
416  RequestLatentTransition(AdjustTime(3));
417  break;
418  case EUndegroundEntranceState.CLOSING_G:
419  RequestLatentTransition(0.25, EUndegroundEntranceState.CLOSED);
420  break;
421  }
422  }
423 
425  {
426  vector pos;
427  if (MemoryPointExists("SirenLightPos"))
428  {
429  pos = GetMemoryPointPos("SirenLightPos");
430  pos = ModelToWorld(pos);
431  }
432  else
433  {
434  ErrorEx("GetLightPosition could not locate memory point 'SirenLightPos'");
435  }
436  return pos;
437  }
438 
439  void SoundEnded(Effect eff)
440  {
441  if (eff == m_DoorMovementSoundIn)
442  {
443  PlaySoundSetAtMemoryPointLooped(m_DoorMovementSoundLoop, DOORMOVING_SOUNDSET_LOOP, "DoorEngineSoundPos");
444  m_DoorMovementSoundIn = null;
445  }
446  else if (eff == m_DoorEngineSoundIn)
447  {
448  PlaySoundSetAtMemoryPointLooped(m_DoorEngineSoundLoop, ENGINE_SOUNDSET_LOOP, "DoorEngineSoundPos");
449  m_DoorEngineSoundIn = null;
450  }
451  }
452 
453  //do note that one-time effects are played even if the client connects and misses the state switch, ie. they are not connected the exact moment when the effect is supposed to be played(just after a state switch), but connect sometime later
454  //we can prevent such effects from playing by checking for IsInitDoorStateSync(), but that seems unnecessary as the issue is really small
456  {
457  //Print("HandleAudioVisualPlayback " + newState + ", " + prevState);
458  //opening
459  if ( CheckShouldPlayPersistent(EUndegroundEntranceState.OPENING_A, EUndegroundEntranceState.OPENING_F))
460  {
461  PlaySoundSetAtMemoryPointLooped(m_SirenSound, SIREN_SOUNDSET, "SirenSoundPos",0.5,0.5);
462  }
463  if (newState == EUndegroundEntranceState.OPENING_B)
464  {
465  if (prevState == EUndegroundEntranceState.OPENING_A)//if they connected already during B, do not play the in
466  {
467  PlaySoundSetAtMemoryPoint(m_DoorEngineSoundIn, ENGINE_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
469  m_DoorEngineSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
470  }
471  }
472 
473  if (CheckShouldPlayPersistent(EUndegroundEntranceState.OPENING_B, EUndegroundEntranceState.OPENING_E))
474  {
475  if (!m_DoorEngineSoundLoop && !m_DoorEngineSoundIn)//missed playing of the IN soundset which automatically triggers playing of the loop(connected after ?)
476  {
477  PlaySoundSetAtMemoryPointLooped(m_DoorEngineSoundLoop, ENGINE_SOUNDSET_LOOP, "DoorEngineSoundPos");
478  }
479  }
480  if (newState == EUndegroundEntranceState.OPENING_C)
481  {
482  PlaySoundSetAtMemoryPoint(m_LockingSound, LOCKING_SOUNDSET, "DoorEngineSoundPos");
483  }
484  if (newState == EUndegroundEntranceState.OPENING_D)
485  {
486  if (prevState == EUndegroundEntranceState.OPENING_C)//if they connected already during C, do not play the in
487  {
488  PlaySoundSetAtMemoryPoint(m_DoorMovementSoundIn, DOORMOVING_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
490  m_DoorMovementSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
491  }
492  else if (!m_DoorMovementSoundIn && !m_DoorMovementSoundLoop)//missed playing of the IN soundset which automatically triggers playing of the loop(connected after ?)
493  {
494  PlaySoundSetAtMemoryPointLooped(m_DoorMovementSoundLoop, DOORMOVING_SOUNDSET_LOOP, "DoorEngineSoundPos");
495  }
496  }
497 
498  if (newState == EUndegroundEntranceState.OPENING_E)
499  {
500  StopSoundSet(m_DoorMovementSoundLoop);
501  PlaySoundSetAtMemoryPoint(m_DoorMovementSoundOut, DOORMOVING_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
502  }
503  if (newState == EUndegroundEntranceState.OPENING_F)
504  {
505  StopSoundSet(m_DoorEngineSoundLoop);
506  PlaySoundSetAtMemoryPoint(m_DoorEngineSoundOut, ENGINE_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
507  }
508  if (newState == EUndegroundEntranceState.OPENING_G)
509  {
510  StopSoundSet(m_SirenSound);
511  }
512 
513  //closing
514  if (CheckShouldPlayPersistent(EUndegroundEntranceState.CLOSING_A, EUndegroundEntranceState.CLOSING_F))
515  {
516  PlaySoundSetAtMemoryPointLooped(m_SirenSound, SIREN_SOUNDSET, "SirenSoundPos",0.5,0.5);
517  }
518  if (CheckShouldPlayPersistent(EUndegroundEntranceState.CLOSING_B, EUndegroundEntranceState.CLOSING_E))
519  {
520  if (prevState == EUndegroundEntranceState.CLOSING_A)//if they connected already during B, do not play the in
521  {
522  PlaySoundSetAtMemoryPoint(m_DoorEngineSoundIn, ENGINE_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
524  m_DoorEngineSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
525  }
526  }
527  if ( newState == EUndegroundEntranceState.CLOSING_C)
528  {
529  if (prevState == EUndegroundEntranceState.CLOSING_B)//if they connected already during C, do not play the in
530  {
531  PlaySoundSetAtMemoryPoint(m_DoorMovementSoundIn, DOORMOVING_SOUNDSET_LOOP_IN, "DoorEngineSoundPos");
533  m_DoorMovementSoundIn.Event_OnEffectEnded.Insert(SoundEnded);
534  }
535  else if (!m_DoorMovementSoundIn && !m_DoorMovementSoundLoop)//missed playing of the IN soundset which automatically triggers playing of the loop(connected after ?)
536  {
537  PlaySoundSetAtMemoryPointLooped(m_DoorMovementSoundLoop, DOORMOVING_SOUNDSET_LOOP, "DoorEngineSoundPos");
538  }
539  }
540  if (newState == EUndegroundEntranceState.CLOSING_D)
541  {
542  StopSoundSet(m_DoorMovementSoundLoop);
543  PlaySoundSetAtMemoryPoint(m_DoorMovementSoundOut, DOORMOVING_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
544  }
545  if (newState == EUndegroundEntranceState.CLOSING_E)
546  {
547  PlaySoundSetAtMemoryPoint(m_LockingSound, LOCKING_SOUNDSET, "DoorEngineSoundPos");
548  }
549  if (newState == EUndegroundEntranceState.CLOSING_F)
550  {
551  StopSoundSet(m_DoorEngineSoundLoop);
552  PlaySoundSetAtMemoryPoint(m_DoorEngineSoundOut, ENGINE_SOUNDSET_LOOP_OUT, "DoorEngineSoundPos");
553  }
554  if (newState == EUndegroundEntranceState.CLOSING_G || newState == EUndegroundEntranceState.CLOSED)
555  {
556  StopSoundSet(m_SirenSound);
557  }
558  }
559 
560  override void OnUpdateClient(float timeSlice)
561  {
562  SetAnimationPhaseNow("EntranceDoor",m_AnimPhase);
563  if (m_AlarmLight)
564  {
565  vector newOri = m_AlarmLight.GetOrientation() + Vector(timeSlice * LIGHT_ROT_SPEED,0,0);
566  m_AlarmLight.SetOrientation(newOri);
567  }
568  }
569 
571  {
572  if ( CheckShouldPlayPersistent(EUndegroundEntranceState.OPENING_A, EUndegroundEntranceState.OPENING_F) || CheckShouldPlayPersistent(EUndegroundEntranceState.CLOSING_A, EUndegroundEntranceState.CLOSING_F))
573  {
575  }
576  if ( newState == EUndegroundEntranceState.CLOSING_G || newState == EUndegroundEntranceState.CLOSED || newState == EUndegroundEntranceState.OPENING_G )
577  {
578  if (m_AlarmLight)
579  {
580  m_AlarmLight.Destroy();
581  }
582  }
583  }
584 
585 }
CLOSING_E
CLOSING_E
Definition: land_underground_entrance.c:17
GetGame
proto native CGame GetGame()
ENGINE_SOUNDSET_LOOP_OUT
const string ENGINE_SOUNDSET_LOOP_OUT
Definition: land_underground_entrance.c:332
CALL_CATEGORY_SYSTEM
const int CALL_CATEGORY_SYSTEM
Definition: tools.c:8
m_DoorMovementSoundIn
EffectSound m_DoorMovementSoundIn
Definition: land_underground_entrance.c:322
OPENING_B
OPENING_B
Definition: land_underground_entrance.c:6
OPENING_G
OPENING_G
Definition: land_underground_entrance.c:11
Param
Base Param Class with no parameters. Used as general purpose parameter overloaded with Param1 to Para...
Definition: param.c:11
Land_Underground_EntranceBase
Definition: land_underground_entrance.c:51
ENGINE_SOUNDSET_LOOP
const string ENGINE_SOUNDSET_LOOP
Definition: land_underground_entrance.c:331
AnimationTimer
AnimationTimer class. This timer is for animating float value. usage:
Definition: tools.c:652
SMALL
enum EUndegroundEntranceState SMALL
DOORMOVING_SOUNDSET_LOOP_IN
const string DOORMOVING_SOUNDSET_LOOP_IN
Definition: land_underground_entrance.c:336
OPENING_F
OPENING_F
Definition: land_underground_entrance.c:10
OPENING_E
OPENING_E
Definition: land_underground_entrance.c:9
m_DoorEngineSoundOut
EffectSound m_DoorEngineSoundOut
Definition: land_underground_entrance.c:320
m_DoorEngineSoundLoop
EffectSound m_DoorEngineSoundLoop
Definition: land_underground_entrance.c:319
m_LockingSound
EffectSound m_LockingSound
Definition: land_underground_entrance.c:321
LOCKING_SOUNDSET
const string LOCKING_SOUNDSET
Definition: land_underground_entrance.c:333
EUndegroundEntranceState
EUndegroundEntranceState
Definition: land_underground_entrance.c:1
EntranceLight
void EntranceLight()
Definition: entrancelight.c:5
CleanUpOnClosedClient
override void CleanUpOnClosedClient()
Definition: land_underground_entrance.c:346
m_AlarmLight
AlarmLight m_AlarmLight
Definition: land_underground_entrance.c:327
ENGINE_SOUNDSET_LOOP_IN
const string ENGINE_SOUNDSET_LOOP_IN
Definition: land_underground_entrance.c:330
SoundEnded
void SoundEnded(Effect eff)
Definition: land_underground_entrance.c:439
ErrorEx
enum ShapeType ErrorEx
IEntity
Definition: enentity.c:164
CLOSING_C
CLOSING_C
Definition: land_underground_entrance.c:15
m_DoorEngineSoundIn
EffectSound m_DoorEngineSoundIn
Definition: land_underground_entrance.c:318
Serializer
Serialization general interface. Serializer API works with:
Definition: serializer.c:55
OnDoorStateChangedServer
override void OnDoorStateChangedServer(EUndegroundEntranceState newState)
Definition: land_underground_entrance.c:363
CLOSING_G
CLOSING_G
Definition: land_underground_entrance.c:20
AlarmLight
enum EUndegroundEntranceState AlarmLight()
Definition: land_underground_entrance.c:31
EffectSound
Wrapper class for managing sound through SEffectManager.
Definition: effectsound.c:4
MAIN
enum EUndegroundEntranceState MAIN
vector
Definition: enconvert.c:105
Effect
void Effect()
ctor
Definition: effect.c:70
OPENING_C
OPENING_C
Definition: land_underground_entrance.c:7
OnUpdateClient
void OnUpdateClient(ActionData action_data)
Definition: actionbase.c:998
EnumTools
Definition: enconvert.c:589
CLOSED
CLOSED
Definition: land_underground_entrance.c:3
UNINITIALIZED
UNINITIALIZED
Definition: land_underground_entrance.c:2
AdjustTime
protected float AdjustTime(float originalTime)
Definition: land_underground_waterreservoir.c:901
GetDebugText
string GetDebugText()
Definition: modifierbase.c:68
CreateLights
override void CreateLights()
Definition: land_underground_entrance.c:340
ScriptedLightBase
Definition: pointlightbase.c:1
GetDebugActions
override void GetDebugActions(out TSelectableActionInfoArrayEx outputList)
Definition: edible_base.c:744
DOORMOVING_SOUNDSET_LOOP_OUT
const string DOORMOVING_SOUNDSET_LOOP_OUT
Definition: land_underground_entrance.c:335
EActions
EActions
Definition: eactions.c:1
OnAction
override bool OnAction(int action_id, Man player, ParamsReadContext ctx)
Definition: edible_base.c:755
m_SirenSound
Land_Underground_EntranceBase m_SirenSound
House
Definition: crashbase.c:1
array< Land_Underground_Panel >
CLOSING_D
CLOSING_D
Definition: land_underground_entrance.c:16
LIGHT_ROT_SPEED
const float LIGHT_ROT_SPEED
Definition: land_underground_entrance.c:338
CLOSING_B
CLOSING_B
Definition: land_underground_entrance.c:14
OPENING_A
OPENING_A
Definition: land_underground_entrance.c:5
CLOSING_A
CLOSING_A
Definition: land_underground_entrance.c:13
Timer
Definition: dayzplayerimplement.c:62
HandleVisualPlayback
override void HandleVisualPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
Definition: land_underground_entrance.c:570
SAT_DEBUG_ACTION
const int SAT_DEBUG_ACTION
Definition: constants.c:424
HandleAudioPlayback
override void HandleAudioPlayback(EUndegroundEntranceState newState, EUndegroundEntranceState prevState)
Definition: land_underground_entrance.c:455
DOORMOVING_SOUNDSET_LOOP
const string DOORMOVING_SOUNDSET_LOOP
Definition: land_underground_entrance.c:334
SIREN_SOUNDSET
const string SIREN_SOUNDSET
Definition: land_underground_entrance.c:329
EntityEvent
EntityEvent
Entity events for event-mask, or throwing event from code.
Definition: enentity.c:44
m_DoorMovementSoundOut
EffectSound m_DoorMovementSoundOut
Definition: land_underground_entrance.c:324
TSelectableActionInfoWithColor
Param4< int, int, string, int > TSelectableActionInfoWithColor
Definition: entityai.c:97
SEffectManager
Manager class for managing Effect (EffectParticle, EffectSound)
Definition: effectmanager.c:5
GetLightPosition
vector GetLightPosition()
Definition: land_underground_entrance.c:424
Vector
proto native vector Vector(float x, float y, float z)
Vector constructor from components.
OPENING_D
OPENING_D
Definition: land_underground_entrance.c:8
OnUpdateClient
override void OnUpdateClient(float timeSlice)
Definition: land_underground_entrance.c:560
Land_Underground_Panel
void Land_Underground_Panel()
Definition: land_underground_panel.c:38
CLOSING_F
CLOSING_F
Definition: land_underground_entrance.c:18
m_DoorMovementSoundLoop
EffectSound m_DoorMovementSoundLoop
Definition: land_underground_entrance.c:323