universaltemperaturesource.c

Go to the documentation of this file.

class UniversalTemperatureSourceSettings
{
 float m_UpdateInterval = 1.0; 
 float m_TemperatureMin = 0; 
 float m_TemperatureMax = 100; 
 float m_TemperatureCap = float.MAX; 
 float m_RangeFull = 1; 
 float m_RangeMax = 2; 
 
 bool m_Updateable = false; 
 bool m_ManualUpdate = false; 
 bool m_AffectStat = false; 
 
 vector m_Position = vector.Zero;
 EntityAI m_Parent = null; 
}
 
class UniversalTemperatureSourceResult
{
 float m_Temperature = 0;
 // ?? what else
}
 
class UniversalTemperatureSourceTimer : Timer
{
 override void OnTimer()
 {
 if (m_params)
 {
 GetGame().GameScript.CallFunctionParams(m_target, m_function, null, m_params);
 }
 else
 {
 GetGame().GameScript.CallFunction(m_target, m_function, null, 0);
 }
 }
 
 override void Stop()
 {
 SetRunning(false);
 m_time = 0;
 }
 
 void SetParams(Param params)
 {
 m_params = params;
 }
}
 
typedef UniversalTemperatureSource UTemperatureSource;
 
class UniversalTemperatureSource
{
 protected bool m_Active
 protected ref UniversalTemperatureSourceTimer m_Timer;
 protected UniversalTemperatureSourceSettings m_Settings;
 protected ref UniversalTemperatureSourceResult m_ResultValues;
 protected ref UniversalTemperatureSourceLambdaBase m_Lambda;
 
 void UniversalTemperatureSource(EntityAI pParent, UniversalTemperatureSourceSettings pSettings, UniversalTemperatureSourceLambdaBase pLambda)
 {
 m_Active = false;
 m_Settings = pSettings;
 m_Lambda = pLambda;
 m_ResultValues = new UniversalTemperatureSourceResult();
 m_Timer = new UniversalTemperatureSourceTimer();
 
 Init(pParent);
 }
 
 void ~UniversalTemperatureSource() {};
 
 void Init(EntityAI pParent)
 {
 if (pParent)
 {
 pParent.SetUniversalTemperatureSource(this);
 
 m_Settings.m_Parent = pParent;
 m_Settings.m_Position = pParent.GetPosition();
 }
 
 if (!m_Settings.m_ManualUpdate)
 {
 auto params = new Param2<UniversalTemperatureSourceSettings, UniversalTemperatureSourceLambdaBase>(m_Settings, m_Lambda);
 
 m_Timer.Run(m_Settings.m_UpdateInterval, this, "Update", params, m_Settings.m_Updateable);
 SetActive(false);
 }
 }
 
 vector GetPosition()
 {
 return m_Settings.m_Position;
 }
 
 float GetFullRange()
 {
 return m_Settings.m_RangeFull;
 }
 
 float GetMaxRange()
 {
 return m_Settings.m_RangeMax;
 }
 
 float GetTemperature()
 {
 if (m_Settings.m_TemperatureCap != float.MAX)
 {
 return Math.Min(m_Settings.m_TemperatureCap, GetTemperatureRaw());
 }
 
 return GetTemperatureRaw();
 }
 
 float GetTemperatureRaw()
 {
 if (m_ResultValues)
 {
 return m_ResultValues.m_Temperature;
 }
 
 return 0;
 }
 
 float GetTemperatureMin()
 {
 return m_Settings.m_TemperatureMin;
 }
 
 float GetTemperatureMax()
 {
 return m_Settings.m_TemperatureMax;
 }
 
 EntityAI GetParent()
 {
 return m_Settings.m_Parent;
 }
 
 bool IsActive()
 {
 if (m_Settings.m_ManualUpdate)
 {
 return m_Active;
 }
 
 return m_Timer && m_Timer.IsRunning();
 }
 
 void SetActive(bool pActive)
 {
 if (m_Settings.m_ManualUpdate)
 {
 m_Active = pActive;
 return;
 }
 
 if (pActive && !m_Timer.IsRunning())
 {
 m_Timer.Continue();
 }
 else
 {
 m_Timer.Stop();
 }
 }
 
 void SetDefferedActive(bool pActive, float pSeconds)
 {
 GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLaterByName(this, "SetActive", pSeconds * 1000, false, new Param1<bool>(pActive));
 }
 
 void ChangeSettings(UniversalTemperatureSourceSettings pSettings)
 {
 m_Timer.SetParams(new Param2<UniversalTemperatureSourceSettings, UniversalTemperatureSourceLambdaBase>(m_Settings, m_Lambda));
 }
 
 void Update(UniversalTemperatureSourceSettings settings, UniversalTemperatureSourceLambdaBase lambda)
 {
 if (!IsActive())
 {
 return;
 }
 
 if (lambda)
 {
 settings.m_Position = settings.m_Parent.GetUniversalTemperatureSourcePosition();
 lambda.Execute(settings, m_ResultValues);
 }
 
 }
}
 
typedef UniversalTemperatureSourceDebug UTemperatureSourceDebug
 
class UniversalTemperatureSourceDebug
{
 const string DELIMITER_DATA = "|";
 const string DELIMITER_KEYPAIR = ":";
 
 string m_Header;
 string m_Data;
 ref array<string> m_Names; 
 ref array<string> m_Values; 
 ref array<string> m_Pairs; 
 
 void UniversalTemperatureSourceDebug()
 {
 m_Header = "";
 m_Data = "";
 m_Pairs = new array<string>();
 m_Names = new array<string>();
 m_Values = new array<string>();
 }
 
 void AddHeader(string header)
 {
 m_Header = header;
 }
 
 void Add(string name, string value)
 {
 m_Data = string.Format("%1%2:%3%4", m_Data, name, value, DELIMITER_DATA); 
 }
 
 void Commit()
 {
 m_Pairs = ParseData();
 ParseKeyPairs();
 }
 
 int PairsCount()
 {
 return m_Pairs.Count();
 }
 
 string GetHeader()
 {
 return m_Header;
 }
 
 string GetName(int pIndex)
 {
 if (m_Names.Count() - 1 < pIndex)
 {
 Debug.Log(string.Format("GetName index: %1 from data of length: %2", pIndex, m_Names.Count()), "UniversalTemperatureSourceDebug");
 return "";
 }
 
 return m_Names.Get(pIndex);
 }
 
 string GetValue(int pIndex)
 {
 if (m_Values.Count() - 1 < pIndex)
 {
 Debug.Log(string.Format("GetValue index: %1 from data of length: %2", pIndex, m_Values.Count()), "UniversalTemperatureSourceDebug");
 return "";
 }
 
 return m_Values.Get(pIndex);
 }
 
 protected array<string> ParseData()
 {
 
 array<string> parsed = new array<string>();
 if (m_Data)
 {
 m_Data.Split(DELIMITER_DATA, parsed);
 }
 
 return parsed;
 }
 
 protected void ParseKeyPairs()
 {
 m_Names.Clear();
 m_Values.Clear();
 
 if (m_Pairs)
 {
 for (int i = 0; i < m_Pairs.Count(); i++)
 {
 array<string> keypair = new array<string>();
 
 m_Pairs.Get(i).Split(DELIMITER_KEYPAIR, keypair);
 m_Names.Insert(keypair[0]);
 m_Values.Insert(keypair[1]);
 }
 }
 }
 
 void Debug()
 {
 for (int i = 0; i < m_Names.Count(); i++)
 {
 Debug.Log(string.Format("%1: %2", m_Names.Get(i), m_Values.Get(i)), "UniversalTemperatureSourceDebug");
 }
 }
}