gewidgetsmetadatableeding.c

Go to the documentation of this file.

 
class GameplayEffectsDataBleeding extends GameplayEffectsData
{
 protected bool m_Initialized; //tied to initialization of 'BleedingSourcesManagerBase' on player object, skips updates until ready, even when formally active
 protected bool m_Visible; //overall visibility
 protected ref map<int,ref BleedingIndicator> m_RegisteredInstances;
 protected ref array<int> m_CleanupQueue;
 protected ref array<int> m_RunningIndicators;
 protected int m_LastDropIdx;
 protected int m_ImageWidgetCount; //number of available blood drop image widgets
 protected ref map<int,ref array<float>> m_ProbabilityMap;
 protected ref array<Widget> m_PositioningFramesArray;
 protected Widget m_BloodDropsFrame;
 
 protected int m_LastPositionFrameUsed;
 
 void GameplayEffectsDataBleeding(array<ref Widget> input, int type, int user_override = -1)
 {
 m_RegisteredInstances = new map<int,ref BleedingIndicator>;
 m_CleanupQueue = new array<int>;
 m_RunningIndicators = new array<int>;
 m_Initialized = false;
 }
 
 override void Init(array<ref Widget> input, int type, Widget layout_root, int user_override = -1)
 {
 super.Init(input, type, layout_root, user_override);
 
 m_WidgetArray.ShuffleArray(); //shuffles order of the widgets on every init
 m_ImageWidgetCount = m_WidgetArray.Count();
 m_BloodDropsFrame = m_LayoutRoot.FindAnyWidgetById(EffectWidgetsTypes.BLEEDING_LAYER);
 m_Visible = g_Game.GetProfileOption(EDayZProfilesOptions.BLEEDINGINDICATION);
 m_BloodDropsFrame.Show(m_Visible);
 m_LastDropIdx = -1;
 m_LastPositionFrameUsed = -1;
 
 BuildProbabilityData(BleedingIndicationConstants.INDICATOR_SEVERITY_LOW,BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_LOW);
 BuildProbabilityData(BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM,BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_MEDIUM);
 BuildProbabilityData(BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH,BleedingIndicationConstants.SEQUENCE_DROP_AVERAGE_HIGH);
 BuildPositioningData();
 }
 
 override bool HasDefinedHandle()
 {
 return true;
 }
 
 override bool DataInitialized()
 {
 return m_Initialized;
 }
 
 override void RegisterData(Param p)
 {
 if (m_Initialized)
 {
 #ifdef DEVELOPER
 ErrorEx("" + this + " is already initialized, further registration not possible!");
 #else
 Debug.Log("ERROR: " + this + " is already initialized, further registration not possible!");
 #endif
 return;
 }
 
 //<finish registration,bit,flow_modifier>
 Param3<bool,int,float> par;
 if (Class.CastTo(par,p))
 {
 if (par.param1 == true) //finish registration
 {
 m_Initialized = true;
 return;
 }
 
 RegisterBleedingIndicatorInstance(par.param2,par.param3);
 }
 }
 
 void RegisterBleedingIndicatorInstance(int bit, float flow_modifier)
 {
 int severity = CalculateSeverity(flow_modifier);
 BleedingIndicator indicator = new BleedingIndicator(bit,severity,this); //source_ID == bit for the purpose of pairing
 m_RegisteredInstances.Set(bit,indicator);
 }
 
 void SpawnBleedingIndicator(int source_ID, vector position)
 {
 if (m_RunningIndicators.Find(source_ID) != -1)
 {
 return;
 }
 BleedingIndicator indicator = m_RegisteredInstances.Get(source_ID);
 //indicator.InitIndicator(position); //would be nice if we could pair the indicator position to the hit position that caused the bleeding, wouldn't it
 indicator.InitIndicator(GenerateSequenceRandomPosition());
 m_RunningIndicators.Insert(source_ID);
 }
 
 int CalculateSeverity(float flow_modifier)
 {
 switch (flow_modifier)
 {
 case PlayerConstants.BLEEDING_SOURCE_FLOW_MODIFIER_LOW:
 return BleedingIndicationConstants.INDICATOR_SEVERITY_LOW;
 
 case PlayerConstants.BLEEDING_SOURCE_FLOW_MODIFIER_MEDIUM:
 return BleedingIndicationConstants.INDICATOR_SEVERITY_MEDIUM;
 
 case PlayerConstants.BLEEDING_SOURCE_FLOW_MODIFIER_HIGH:
 return BleedingIndicationConstants.INDICATOR_SEVERITY_HIGH;
 }
 return BleedingIndicationConstants.INDICATOR_SEVERITY_LOW;
 }
 
 ImageWidget GetNextDropImage()
 {
 m_LastDropIdx++;
 if (m_LastDropIdx > (m_ImageWidgetCount - 1))
 {
 m_LastDropIdx = 0;
 }
 
 return ImageWidget.Cast(m_WidgetArray[m_LastDropIdx]);
 }
 
 void StopBleedingIndicator(int source_ID, bool instant = false)
 {
 m_RegisteredInstances.Get(source_ID).StopIndicator(instant); //stop queued, evaluated on update!
 }
 
 void UpdateBleedingIndicators(float timeSlice)
 {
 BleedingIndicator bib;
 for (int i = 0; i < m_RunningIndicators.Count(); i++)
 {
 bib = m_RegisteredInstances.Get(m_RunningIndicators[i]);
 bib.Update(timeSlice);
 if ( bib.GetEndNow() )
 {
 m_CleanupQueue.Insert(m_RunningIndicators[i]);
 }
 }
 }
 
 void CleanupBleedingIndicators()
 {
 for (int i = 0; i < m_CleanupQueue.Count(); i++)
 {
 m_RunningIndicators.RemoveItem(m_CleanupQueue[i]);
 }
 m_CleanupQueue.Clear();
 }
 
 override void Update(float timeSlice = 0, Param p = null, int handle = -1)
 {
 //starts or ends a bleeding indicator
 if (p)
 {
 //start/stop of the indicator
 //<state,bit,position,immediate>
 Param4<bool,int,vector,bool> par;
 
 //hide/show of bleeding effect visuals
 //<state>
 Param1<bool> parShow;
 
 if (Class.CastTo(par,p))
 {
 bool state = par.param1;
 if (state) //queue add indicator
 {
 SpawnBleedingIndicator(par.param2,par.param3);
 }
 else //queue stop indicator
 {
 StopBleedingIndicator(par.param2,par.param4);
 }
 }
 else if (Class.CastTo(parShow,p) && m_Visible != parShow.param1)
 {
 m_Visible = parShow.param1;
 m_BloodDropsFrame.Show(m_Visible);
 }
 }
 
 //updates bleeding indicators
 UpdateBleedingIndicators(timeSlice);
 CleanupBleedingIndicators();
 
 if (m_RunningIndicators.Count() <= 0)
 {
 GetGame().GetMission().GetEffectWidgets().RemoveActiveEffects({EffectWidgetsTypes.BLEEDING_LAYER});
 m_WidgetArray.ShuffleArray();
 }
 }
 
 override void UpdateVisibility(bool state)
 {
 m_Visible = g_Game.GetProfileOption(EDayZProfilesOptions.BLEEDINGINDICATION); //ugh
 //manage layout visibility
 Widget w = m_BloodDropsFrame;
 while (w && w != m_LayoutRoot && m_Visible == state && w.IsVisibleHierarchy() != state)
 {
 w.Show(state);
 w = w.GetParent();
 }
 }
 
 override void ForceStop()
 {
 super.ForceStop();
 
 foreach (int i: m_RunningIndicators)
 {
 m_RegisteredInstances.Get(i).StopIndicator(true);
 }
 Update();
 }
 
 void BuildProbabilityData(int severity, float frequency)
 {
 if (!m_ProbabilityMap)
 {
 m_ProbabilityMap = new map<int,ref array<float>>;
 }
 
 array<float> probabilities = new array<float>;
 
 for (int i = 0; i < BleedingIndicationConstants.SEQUENCE_STEPS; i++)
 {
 probabilities.Insert(Math.Poisson(frequency,i));
 }
 
 m_ProbabilityMap.Insert(severity,probabilities);
 }
 
 array<float> GetProbabilities(int severity)
 {
 array<float> ret = m_ProbabilityMap.Get(severity);
 if (!ret)
 {
 ErrorEx("No defined data for the selected severity!");
 }
 return ret;
 }
 
 void BuildPositioningData()
 {
 Widget frameParent = m_LayoutRoot.FindAnyWidget("PoisitioningFrames");
 if (frameParent)
 {
 if (!m_PositioningFramesArray)
 {
 m_PositioningFramesArray = new array<Widget>;
 }
 
 Widget frame = frameParent.GetChildren();
 while (frame)
 {
 m_PositioningFramesArray.Insert(frame);
 frame = frame.GetSibling();
 }
 }
 }
 
 vector GenerateSequenceRandomPosition()
 {
 if (m_PositioningFramesArray)
 {
 int arrayCount = m_PositioningFramesArray.Count();
 int index = Math.RandomInt(0,arrayCount);
 if (index == m_LastPositionFrameUsed)
 {
 index++;
 if (index >= arrayCount)
 {
 index = 0;
 }
 }
 
 Widget frame = m_PositioningFramesArray[index];
 m_LastPositionFrameUsed = index;
 
 if (frame)
 {
 int screenX,screenY;
 float x,y,x_size,y_size;
 frame.GetScreenPos(x,y);
 frame.GetScreenSize(x_size,y_size);
 
 x = Math.RandomFloatInclusive(x,x+x_size);
 y = Math.RandomFloatInclusive(y,y+y_size);
 
 return Vector(x,y,0);
 }
 }
 return vector.Zero;
 }
}