public virtual void Init(MyObjectBuilder_Base objectBuilder)
{
MyEntityStatDefinition definition;
MyObjectBuilder_EntityStat stat = (MyObjectBuilder_EntityStat)objectBuilder;
MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(stat.TypeId, stat.SubtypeId), out definition);
this.StatDefinition = definition;
this.m_maxValue = definition.MaxValue;
this.m_minValue = definition.MinValue;
this.m_currentValue = stat.Value * this.m_maxValue;
this.m_defaultValue = definition.DefaultValue;
this.m_lastSyncValue = this.m_currentValue;
this.m_statId = MyStringHash.GetOrCompute(definition.Name);
this.m_regenAmountMultiplier = stat.StatRegenAmountMultiplier;
this.m_regenAmountMultiplierDuration = stat.StatRegenAmountMultiplierDuration;
this.m_regenAmountMultiplierTimeStart = MySandboxGame.TotalGamePlayTimeInMilliseconds;
this.m_regenAmountMultiplierTimeAlive = 0;
this.m_regenAmountMultiplierActive = this.m_regenAmountMultiplierDuration > 0f;
this.ClearEffects();
if (stat.Effects != null)
{
foreach (MyObjectBuilder_EntityStatRegenEffect effect in stat.Effects)
{
this.AddEffect(effect);
}
}
}
public virtual void Init(MyObjectBuilder_Base objectBuilder)
{
var builder = (MyObjectBuilder_EntityStat)objectBuilder;
MyEntityStatDefinition definition;
MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(builder.TypeId, builder.SubtypeId), out definition);
Debug.Assert(definition != null);
StatDefinition = definition;
m_maxValue = builder.MaxValue * 100.0f;
m_minValue = 0.0f;
m_currentValue = builder.Value * m_maxValue;
m_lastSyncValue = m_currentValue;
m_statId = MyStringHash.GetOrCompute(definition.Name);
if (builder.Effects != null)
{
foreach (var effectBuilder in builder.Effects)
{
AddEffect(effectBuilder);
}
}
}
public override void Deserialize(MyObjectBuilder_ComponentBase objectBuilder)
{
var builder = objectBuilder as MyObjectBuilder_CharacterStatComponent;
if (builder != null)
{
if (builder.Stats != null)
{
foreach (var stat in builder.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(stat.TypeId, stat.SubtypeId), out statDefinition) &&
statDefinition.Enabled &&
((statDefinition.EnabledInCreative && MySession.Static.CreativeMode) ||
(statDefinition.AvailableInSurvival && MySession.Static.SurvivalMode)))
{
AddStat(stat.SubtypeId, stat);
}
}
}
if (builder.ScriptNames != null && Sync.IsServer)
{
foreach (var scriptName in builder.ScriptNames)
{
InitScript(scriptName);
}
}
}
base.Deserialize(objectBuilder);
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyEntityStatComponentDefinition entityStatDefinition = definition as MyEntityStatComponentDefinition;
Debug.Assert(entityStatDefinition != null);
if (entityStatDefinition == null || !entityStatDefinition.Enabled || MySession.Static == null ||
(!entityStatDefinition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
if (Sync.IsServer) // Only init scripts on server
{
m_statActionsRequested = true;
}
return;
}
foreach (var statId in entityStatDefinition.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (!MyDefinitionManager.Static.TryGetDefinition(statId, out statDefinition))
{
continue;
}
if (!statDefinition.Enabled ||
(!statDefinition.EnabledInCreative && MySession.Static.CreativeMode) ||
(!statDefinition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
continue;
}
var nameHash = MyStringHash.GetOrCompute(statDefinition.Name);
MyEntityStat existingStat = null;
if (m_stats.TryGetValue(nameHash, out existingStat) && existingStat.StatDefinition.Id.SubtypeId == statDefinition.Id.SubtypeId)
{
continue;
}
var builder = new MyObjectBuilder_EntityStat();
builder.SubtypeName = statId.SubtypeName;
builder.MaxValue = 1.0f;
builder.Value = statDefinition.DefaultValue / statDefinition.MaxValue;
AddStat(nameHash, builder);
}
if (Sync.IsServer) // Only init scripts on server
{
Debug.Assert(m_scripts.Count == 0);
foreach (var scriptName in entityStatDefinition.Scripts)
{
InitScript(scriptName);
}
m_statActionsRequested = true;
}
}
public void InitStats(MyStatsDefinition definition)
{
if (definition == null || !definition.Enabled || (!definition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
return;
}
foreach (var statId in definition.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (!MyDefinitionManager.Static.TryGetDefinition(statId, out statDefinition))
{
continue;
}
if (!statDefinition.Enabled ||
(!statDefinition.EnabledInCreative && MySession.Static.CreativeMode) ||
(!statDefinition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
continue;
}
var nameHash = MyStringHash.GetOrCompute(statDefinition.Name);
MyEntityStat existingStat = null;
if (m_stats.TryGetValue(statId.SubtypeId, out existingStat) && existingStat.StatId == nameHash)
{
continue;
}
var builder = new MyObjectBuilder_EntityStat();
builder.SubtypeName = statId.SubtypeName;
builder.MaxValue = 1.0f;
builder.Value = 1.0f;
AddStat(nameHash, builder);
}
if (Sync.IsServer) // Only init scripts on server
{
foreach (var scriptName in definition.Scripts)
{
MyStatLogic script = null;
if ((script = m_scripts.Find((otherScript) => { return(otherScript.Name == scriptName); })) != null)
{
script.Close();
m_scripts.Remove(script); // On load we might've had less stats to consider (moving from creative to survival for example) so replace the old script
}
InitScript(scriptName);
}
}
else
{
RequestStatActions(); // Only request the stat actions from the server
}
}
public void InitStats(MyStatsDefinition definition)
{
if (definition == null || !definition.Enabled || (!definition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
return;
}
foreach (var statId in definition.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (!MyDefinitionManager.Static.TryGetDefinition(statId, out statDefinition))
{
continue;
}
if (!statDefinition.Enabled ||
(!statDefinition.EnabledInCreative && MySession.Static.CreativeMode) ||
(!statDefinition.AvailableInSurvival && MySession.Static.SurvivalMode))
{
continue;
}
var nameHash = MyStringHash.GetOrCompute(statDefinition.Name);
MyEntityStat existingStat = null;
if (m_stats.TryGetValue(statId.SubtypeId, out existingStat) && existingStat.StatId == nameHash)
{
continue;
}
var builder = new MyObjectBuilder_EntityStat();
builder.SubtypeName = statId.SubtypeName;
builder.MaxValue = 1.0f;
builder.Value = statDefinition.DefaultValue / statDefinition.MaxValue;
AddStat(nameHash, builder);
}
if (Sync.IsServer) // Only init scripts on server
{
// MW: remove all scripts because of the broken saves (Medieval character has multiple scripts (peasant's and player's))
foreach (var script in m_scripts)
{
script.Close();
}
m_scripts.Clear();
foreach (var scriptName in definition.Scripts)
{
InitScript(scriptName);
}
}
else
{
RequestStatActions(); // Only request the stat actions from the server
}
}
public virtual MyObjectBuilder_EntityStat GetObjectBuilder()
{
var builder = new MyObjectBuilder_EntityStat();
MyEntityStatDefinition definition = MyDefinitionManager.Static.GetDefinition(new MyDefinitionId(builder.TypeId, StatDefinition.Id.SubtypeId)) as MyEntityStatDefinition;
builder.SubtypeName = StatDefinition.Id.SubtypeName;
Debug.Assert(definition != null);
if (definition != null)
{
Debug.Assert(definition.MaxValue != 0);
builder.Value = m_currentValue / (definition.MaxValue != 0 ? definition.MaxValue : 1); // Save stat value relative to the definition maximum value
builder.MaxValue = m_maxValue / (definition.MaxValue != 0 ? definition.MaxValue : 1); // Save stat maximum value relative to the definition maximum value
}
else
{
builder.Value = m_currentValue / m_maxValue;
builder.MaxValue = 1.0f;
}
if (m_regenAmountMultiplierActive)
{
builder.StatRegenAmountMultiplier = m_regenAmountMultiplier;
builder.StatRegenAmountMultiplierDuration = m_regenAmountMultiplierDuration;
}
builder.Effects = null;
if (m_effects != null && m_effects.Count > 0)
{
int savedEffectCount = m_effects.Count;
foreach (var effectPair in m_effects)
{
if (effectPair.Value.Duration < 0)
{
--savedEffectCount; // Don't save the permanent effects
}
}
if (savedEffectCount > 0)
{
builder.Effects = new MyObjectBuilder_EntityStatRegenEffect[savedEffectCount];
int effectIndex = 0;
foreach (var effectPair in m_effects)
{
if (effectPair.Value.Duration >= 0)
{
builder.Effects[effectIndex++] = effectPair.Value.GetObjectBuilder();
}
}
}
}
return(builder);
}
public virtual MyObjectBuilder_EntityStat GetObjectBuilder()
{
MyObjectBuilder_EntityStat stat = new MyObjectBuilder_EntityStat();
MyEntityStatDefinition definition = MyDefinitionManager.Static.GetDefinition(new MyDefinitionId(stat.TypeId, this.StatDefinition.Id.SubtypeId)) as MyEntityStatDefinition;
stat.SubtypeName = this.StatDefinition.Id.SubtypeName;
if (definition != null)
{
stat.Value = this.m_currentValue / ((definition.MaxValue != 0f) ? definition.MaxValue : 1f);
stat.MaxValue = this.m_maxValue / ((definition.MaxValue != 0f) ? definition.MaxValue : 1f);
}
else
{
stat.Value = this.m_currentValue / this.m_maxValue;
stat.MaxValue = 1f;
}
if (this.m_regenAmountMultiplierActive)
{
stat.StatRegenAmountMultiplier = this.m_regenAmountMultiplier;
stat.StatRegenAmountMultiplierDuration = this.m_regenAmountMultiplierDuration;
}
stat.Effects = null;
if ((this.m_effects != null) && (this.m_effects.Count > 0))
{
int count = this.m_effects.Count;
foreach (KeyValuePair <int, MyEntityStatRegenEffect> pair in this.m_effects)
{
if (pair.Value.Duration < 0f)
{
count--;
}
}
if (count > 0)
{
stat.Effects = new MyObjectBuilder_EntityStatRegenEffect[count];
int index = 0;
foreach (KeyValuePair <int, MyEntityStatRegenEffect> pair2 in this.m_effects)
{
if (pair2.Value.Duration >= 0f)
{
index++;
stat.Effects[index] = pair2.Value.GetObjectBuilder();
}
}
}
}
return(stat);
}
public override void Deserialize(MyObjectBuilder_ComponentBase objectBuilder)
{
var builder = objectBuilder as MyObjectBuilder_CharacterStatComponent;
// Because of switching helmet on/off
foreach (var script in m_scripts)
{
script.Close();
}
m_scripts.Clear();
if (builder != null)
{
if (builder.Stats != null)
{
foreach (var stat in builder.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(stat.TypeId, stat.SubtypeId), out statDefinition) &&
statDefinition.Enabled &&
((statDefinition.EnabledInCreative && MySession.Static.CreativeMode) ||
(statDefinition.AvailableInSurvival && MySession.Static.SurvivalMode)))
{
AddStat(MyStringHash.GetOrCompute(statDefinition.Name), stat, true);
}
}
}
if (builder.ScriptNames != null && Sync.IsServer)
{
// Should fix broken saves
// I assume that StatComponent should hold only once instance per script
builder.ScriptNames = builder.ScriptNames.Distinct().ToArray();
foreach (var scriptName in builder.ScriptNames)
{
InitScript(scriptName);
}
}
}
base.Deserialize(objectBuilder);
}
public override void Init(MyComponentDefinitionBase definition)
{
base.Init(definition);
MyEntityStatComponentDefinition definition2 = definition as MyEntityStatComponentDefinition;
if (((definition2 == null) || (!definition2.Enabled || (MySession.Static == null))) || (!definition2.AvailableInSurvival && MySession.Static.SurvivalMode))
{
if (Sync.IsServer)
{
this.m_statActionsRequested = true;
}
}
else
{
foreach (MyDefinitionId id in definition2.Stats)
{
MyEntityStatDefinition definition3 = null;
if (MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(id, out definition3) && (definition3.Enabled && ((definition3.EnabledInCreative || !MySession.Static.CreativeMode) && (definition3.AvailableInSurvival || !MySession.Static.SurvivalMode))))
{
MyStringHash orCompute = MyStringHash.GetOrCompute(definition3.Name);
MyEntityStat stat = null;
if (!this.m_stats.TryGetValue(orCompute, out stat) || (stat.StatDefinition.Id.SubtypeId != definition3.Id.SubtypeId))
{
MyObjectBuilder_EntityStat objectBuilder = new MyObjectBuilder_EntityStat {
SubtypeName = id.SubtypeName,
MaxValue = 1f,
Value = definition3.DefaultValue / definition3.MaxValue
};
this.AddStat(orCompute, objectBuilder, false);
}
}
}
if (Sync.IsServer)
{
foreach (string str in definition2.Scripts)
{
this.InitScript(str);
}
this.m_statActionsRequested = true;
}
}
}
public void InitStats(MyStatsDefinition definition)
{
if (definition == null)
{
return;
}
foreach (var statId in definition.Stats)
{
MyEntityStatDefinition statDefinition = null;
if (!MyDefinitionManager.Static.TryGetDefinition(statId, out statDefinition))
{
continue;
}
if (!statDefinition.Enabled || (!statDefinition.EnabledInCreative && MySession.Static.CreativeMode))
{
continue;
}
var builder = new MyObjectBuilder_EntityStat();
builder.MaxValue = statDefinition.MaxValue;
builder.MinValue = statDefinition.MinValue;
builder.Value = statDefinition.MaxValue;
AddStat(statId.SubtypeId, builder);
}
Type scriptType;
foreach (var scriptName in definition.Scripts)
{
if (MyScriptManager.Static.StatScripts.TryGetValue(scriptName, out scriptType))
{
var script = (MyStatLogic)Activator.CreateInstance(scriptType);
script.Init(Entity as MyCharacter, m_stats);
m_scripts.Add(script);
}
}
}
public override void Deserialize(MyObjectBuilder_ComponentBase objectBuilder)
{
MyObjectBuilder_CharacterStatComponent component = objectBuilder as MyObjectBuilder_CharacterStatComponent;
using (List <MyStatLogic> .Enumerator enumerator = this.m_scripts.GetEnumerator())
{
while (enumerator.MoveNext())
{
enumerator.Current.Close();
}
}
this.m_scripts.Clear();
if (component != null)
{
if (component.Stats != null)
{
foreach (MyObjectBuilder_EntityStat stat in component.Stats)
{
MyEntityStatDefinition definition = null;
if ((MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(stat.TypeId, stat.SubtypeId), out definition) && definition.Enabled) && ((definition.EnabledInCreative && MySession.Static.CreativeMode) || (definition.AvailableInSurvival && MySession.Static.SurvivalMode)))
{
this.AddStat(MyStringHash.GetOrCompute(definition.Name), stat, true);
}
}
}
if ((component.ScriptNames != null) && Sync.IsServer)
{
component.ScriptNames = component.ScriptNames.Distinct <string>().ToArray <string>();
foreach (string str in component.ScriptNames)
{
this.InitScript(str);
}
}
}
base.Deserialize(objectBuilder);
}
public virtual void Init(MyObjectBuilder_Base objectBuilder)
{
var builder = (MyObjectBuilder_EntityStat)objectBuilder;
MyEntityStatDefinition definition;
MyDefinitionManager.Static.TryGetDefinition <MyEntityStatDefinition>(new MyDefinitionId(builder.TypeId, builder.SubtypeId), out definition);
Debug.Assert(definition != null);
StatDefinition = definition;
System.Diagnostics.Debug.Assert(!float.IsNaN(definition.MaxValue) && !float.IsNaN(definition.MinValue) && !float.IsNaN(definition.DefaultValue), "Invalid values in stat definition!");
m_maxValue = definition.MaxValue;
m_minValue = definition.MinValue;
m_currentValue = builder.Value * m_maxValue;
m_defaultValue = definition.DefaultValue;
m_lastSyncValue = m_currentValue;
m_statId = MyStringHash.GetOrCompute(definition.Name);
m_regenAmountMultiplier = builder.StatRegenAmountMultiplier;
m_regenAmountMultiplierDuration = builder.StatRegenAmountMultiplierDuration;
m_regenAmountMultiplierTimeStart = MySandboxGame.TotalGamePlayTimeInMilliseconds;
m_regenAmountMultiplierTimeAlive = 0;
m_regenAmountMultiplierActive = m_regenAmountMultiplierDuration > 0;
ClearEffects();
if (builder.Effects != null)
{
foreach (var effectBuilder in builder.Effects)
{
AddEffect(effectBuilder);
}
}
}
