/// <summary>
/// Metodo responsavel por gerenciar a adicao de modificadores de atributos ao personagem
/// </summary>
/// <param name="attributeModifier_">Attribute modifier.</param>
public static void AddAttributeModifier(ref AttributeModifier[] attributeModifiers_, AttributeModifier attributeModifier_)
{
bool _canBeAdded = true; // Variavel para controle se o atributo pode ser adicionao na tabela, parte do principio que sempre pode.
// Percorre a tabela de atributos do personagem
for (int i = 0; i < attributeModifiers_.Length; i++)
{
// Se o espaco estiver vazio e pode ser adicionado inclui. Para a execucao do for
if (attributeModifiers_[i] == null && _canBeAdded){
attributeModifiers_[i] = attributeModifier_;
attributeModifiers_[i].InitialTime = Time.time;
attributeModifiers_[i].ExpireTime = Time.time + attributeModifier_.TimeInSeconds;
attributeModifiers_[i].Consumed = false;
break;
}
// Verifica se o atributo existe na tabela e inicia os testes
if (attributeModifiers_[i] != null)
{
// Se estiver aplicando o mesmo atributo somente atualiza na tabela
if (attributeModifiers_[i].AttributeType == attributeModifier_.AttributeType &&
attributeModifiers_[i].OriginID == attributeModifier_.OriginID &&
attributeModifiers_[i].ModifierType == attributeModifier_.ModifierType)
{
attributeModifiers_[i] = attributeModifier_;
attributeModifiers_[i].InitialTime = Time.time;
attributeModifiers_[i].ExpireTime = Time.time + attributeModifier_.TimeInSeconds;
attributeModifiers_[i].Consumed = false;
break;
}
}
}
}
/// <summary>
/// The AttributeModifier auto updater has been enabled or disabled.
/// </summary>
/// <param name="attributeModifier">The modifier that has been enabled or disabled.</param>
/// <param name="enable">True if the modifier has been enabled.</param>
private void ModifierAutoUpdateEnabled(AttributeModifier attributeModifier, bool enable)
{
if (enable)
{
return;
}
EventHandler.UnregisterEvent <AttributeModifier, bool>(attributeModifier, "OnAttributeModifierAutoUpdateEnable", ModifierAutoUpdateEnabled);
GenericObjectPool.Return(attributeModifier);
}
private void InitializeModifiers()
{
if (!modifiersInitialized)
{
modifiersInitialized = true;
AttributeModifier modifier = new AttributeModifier(overheatTemp.Id, baseOverheatTemp, UI.TOOLTIPS.BASE_VALUE, false, false, true);
AttributeModifier modifier2 = new AttributeModifier(fatalTemp.Id, baseFatalTemp, UI.TOOLTIPS.BASE_VALUE, false, false, true);
this.GetAttributes().Add(modifier);
this.GetAttributes().Add(modifier2);
}
}
public static void OnLoad()
{
// Defined in Edible
const float BASE_EAT_RATE = 50000.0f;
ImaginationLoader.Init(typeof(TraitReworkPatches));
InitStrings();
// Create modifier for "Eating in lit area"
EAT_LIT_MODIFIER = new AttributeModifier("CaloriesDelta", BASE_EAT_RATE * (1.0f /
(1.0f - TraitTuning.EAT_SPEED_BUFF) - 1.0f), TraitStrings.EATING_LIT);
}
public void AddModifier(AttributeModifier modifier)
{
int old = Value;
modifiers.Add(modifier);
CalculateValue();
if (onValueChange != null)
{
onValueChange(Value, old);
}
}
protected virtual int CompareModifierOrder(AttributeModifier a, AttributeModifier b)
{
if (a.Order < b.Order)
{
return(-1);
}
else if (a.Order > b.Order)
{
return(1);
}
return(0); // if (a.Order == b.Order)
}
public AttributeModifierExpectation(string id, string name, string description, AttributeModifier modifier, Sprite icon)
: base(id, name, description, delegate(MinionResume resume)
{
resume.GetAttributes().Get(modifier.AttributeId).Add(modifier);
}, delegate(MinionResume resume)
{
resume.GetAttributes().Get(modifier.AttributeId).Remove(modifier);
})
{
this.modifier = modifier;
this.icon = icon;
}
public override string GetFormattedModifier(AttributeModifier modifier, GameObject parent_instance)
{
float num = modifier.Value;
GameUtil.TimeSlice timeSlice = base.DeltaTimeSlice;
if (modifier.IsMultiplier)
{
num *= 100f;
timeSlice = GameUtil.TimeSlice.None;
}
return(GetFormattedValue(num, timeSlice, parent_instance));
}
private static int CompareModifierOrder(AttributeModifier x, AttributeModifier y)
{
if (x.Order < y.Order)
{
return(-1);
}
else if (x.Order > y.Order)
{
return(1);
}
return(0);
}
internal static void Postfix(AmountInstance ___rotAmountInstance,
AttributeModifier ___refrigeratedModifier,
AttributeModifier ___frozenModifier)
{
var delta = ___rotAmountInstance.deltaAttribute;
if (delta.GetTotalValue() > 0.0f)
{
// Cannot allow food to gain freshness!
delta.Remove(___refrigeratedModifier);
delta.Remove(___frozenModifier);
}
}
public override object VisitAttributeLine([NotNull] classlist_langParser.AttributeLineContext context)
{
//add attribute modif
AttributeModifier modif = new AttributeModifier();
modif.Option = (context.attributeOption().GetText() == "set" ? AttributeModifier.AttributeModifierOptions.SET : AttributeModifier.AttributeModifierOptions.FORBID);
modif.AttributeName = context.attribute().GetText();
currentClass.Modifiers.Add(modif);
return(base.VisitAttributeLine(context));
}
protected override void Serialize(IntermediateWriter output, AttributeModifier <TAttribute> value, ContentSerializerAttribute format)
{
switch (value.ComputationType)
{
case AttributeComputationType.Additive:
output.Xml.WriteValue(string.Format(CultureInfo.InvariantCulture, "{0}", value.Value) + " " + Enum.GetName(typeof(TAttribute), value.Type));
break;
case AttributeComputationType.Multiplicative:
output.Xml.WriteValue(string.Format(CultureInfo.InvariantCulture, "{0}", ((value.Value - 1) * 100)) + "% " + Enum.GetName(typeof(TAttribute), value.Type));
break;
}
}
protected override void OnSpawn()
{
base.OnSpawn();
if (radius == 0 || noise == 0)
{
Debug.LogWarning("Noisepollutor::OnSpawn [" + GetName() + "] noise: [" + noise + "] radius: [" + radius + "]");
UnityEngine.Object.Destroy(this);
}
else
{
ResetCells();
Operational component = GetComponent <Operational>();
if ((UnityEngine.Object)component != (UnityEngine.Object)null)
{
Subscribe(824508782, OnActiveChangedDelegate);
}
refreshCallback = Refresh;
refreshPartionerCallback = delegate
{
Refresh();
};
onCollectNoisePollutersCallback = OnCollectNoisePolluters;
Attributes attributes = this.GetAttributes();
Db db = Db.Get();
dB = attributes.Add(db.BuildingAttributes.NoisePollution);
dBRadius = attributes.Add(db.BuildingAttributes.NoisePollutionRadius);
if (noise != 0 && radius != 0)
{
AttributeModifier modifier = new AttributeModifier(db.BuildingAttributes.NoisePollution.Id, (float)noise, UI.TOOLTIPS.BASE_VALUE, false, false, true);
AttributeModifier modifier2 = new AttributeModifier(db.BuildingAttributes.NoisePollutionRadius.Id, (float)radius, UI.TOOLTIPS.BASE_VALUE, false, false, true);
attributes.Add(modifier);
attributes.Add(modifier2);
}
else
{
Debug.LogWarning("Noisepollutor::OnSpawn [" + GetName() + "] radius: [" + radius + "] noise: [" + noise + "]");
}
KBatchedAnimController component2 = GetComponent <KBatchedAnimController>();
isMovable = ((UnityEngine.Object)component2 != (UnityEngine.Object)null && component2.isMovable);
Singleton <CellChangeMonitor> .Instance.RegisterCellChangedHandler(base.transform, OnCellChange, "NoisePolluter.OnSpawn");
AttributeInstance attributeInstance = dB;
attributeInstance.OnDirty = (System.Action)Delegate.Combine(attributeInstance.OnDirty, refreshCallback);
AttributeInstance attributeInstance2 = dBRadius;
attributeInstance2.OnDirty = (System.Action)Delegate.Combine(attributeInstance2.OnDirty, refreshCallback);
if ((UnityEngine.Object)component != (UnityEngine.Object)null)
{
OnActiveChanged(component.IsActive);
}
}
}
public override object Clone()
{
AttributeModifier clone = new AttributeModifier(this.AttributeAlias, this.valueChange, this.ChangeType, this.Name);
constraints.ForEach(
constraint => {
ICloneable cloneable = constraint as ICloneable;
if (cloneable != null)
clone.AddConstraint((IConstraint)(cloneable.Clone())); //try to make a deep copy of the constraint list
else
clone.AddConstraint(constraint); //fallback, if the ICloneable interface is not implemented by the constraint
}
);
return clone;
}
void Start()
{
_activationCollider = GetComponent<BoxCollider>();
_activationCollider.isTrigger = true;
Modifier = new AttributeModifier();
Modifier.OriginID = this.gameObject.GetInstanceID();
Modifier.ModifierType = ModifierType;
Modifier.AttributeType = (int)AttributeType;
Modifier.CalcType = CalcType;
Modifier.ApplyTo = ApplyTo;
Modifier.Value = Value;
Modifier.TimeInSeconds = TimeInSeconds;
}
public virtual string GetTooltip(Amount master, AmountInstance instance)
{
string str = string.Format(master.description, formatter.GetFormattedValue(instance.value, GameUtil.TimeSlice.None, null));
str += "\n\n";
str = ((formatter.DeltaTimeSlice != GameUtil.TimeSlice.PerCycle) ? (str + string.Format(UI.CHANGEPERSECOND, formatter.GetFormattedValue(ToPercent(instance.deltaAttribute.GetTotalDisplayValue(), instance), GameUtil.TimeSlice.PerSecond, null))) : (str + string.Format(UI.CHANGEPERCYCLE, formatter.GetFormattedValue(ToPercent(instance.deltaAttribute.GetTotalDisplayValue(), instance), GameUtil.TimeSlice.PerCycle, null))));
for (int i = 0; i != instance.deltaAttribute.Modifiers.Count; i++)
{
AttributeModifier attributeModifier = instance.deltaAttribute.Modifiers[i];
float modifierContribution = instance.deltaAttribute.GetModifierContribution(attributeModifier);
str = str + "\n" + string.Format(UI.MODIFIER_ITEM_TEMPLATE, attributeModifier.GetDescription(), formatter.GetFormattedValue(ToPercent(modifierContribution, instance), formatter.DeltaTimeSlice, null));
}
return(str);
}
private void SetupDependentAttribute(Klei.AI.Attribute targetAttribute, AttributeConverter attributeConverter)
{
Klei.AI.Attribute attribute = attributeConverter.attribute;
AttributeInstance attributeInstance = attribute.Lookup(this);
AttributeModifier target_modifier = new AttributeModifier(targetAttribute.Id, attributeConverter.Lookup(this).Evaluate(), attribute.Name, false, false, false);
this.GetAttributes().Add(target_modifier);
AttributeInstance attributeInstance2 = attributeInstance;
attributeInstance2.OnDirty = (System.Action)Delegate.Combine(attributeInstance2.OnDirty, (System.Action) delegate
{
target_modifier.SetValue(attributeConverter.Lookup(this).Evaluate());
});
}
protected override void OnPrefabInit()
{
Amounts amounts = base.gameObject.GetAmounts();
maturity = amounts.Add(new AmountInstance(Db.Get().Amounts.Maturity, base.gameObject));
baseMaturityMax = new AttributeModifier(maturity.maxAttribute.Id, growthTime / 600f, null, false, false, true);
maturity.maxAttribute.Add(baseMaturityMax);
oldAge = amounts.Add(new AmountInstance(Db.Get().Amounts.OldAge, base.gameObject));
oldAge.maxAttribute.ClearModifiers();
oldAge.maxAttribute.Add(new AttributeModifier(Db.Get().Amounts.OldAge.maxAttribute.Id, maxAge, null, false, false, true));
base.OnPrefabInit();
Subscribe(1119167081, OnNewGameSpawnDelegate);
Subscribe(1272413801, ResetGrowthDelegate);
}
protected override void OnPrefabInit()
{
base.OnPrefabInit();
decorProvider = GetComponent <DecorProvider>();
if (decorModifier == null)
{
decorModifier = new AttributeModifier("Decor", 0f, DUPLICANTS.MODIFIERS.CLOTHING.NAME, false, false, false);
}
if (conductivityModifier == null)
{
AttributeInstance attributeInstance = base.gameObject.GetAttributes().Get("ThermalConductivityBarrier");
conductivityModifier = new AttributeModifier("ThermalConductivityBarrier", ClothingInfo.BASIC_CLOTHING.conductivityMod, DUPLICANTS.MODIFIERS.CLOTHING.NAME, false, false, false);
attributeInstance.Add(conductivityModifier);
}
}
protected override void OnPrefabInit()
{
primaryElement = GetComponent <PrimaryElement>();
average_kilowatts_exchanged = new RunningWeightedAverage(-10f, 10f, 20, true);
surfaceArea = 1f;
thickness = 0.002f;
groundTransferScale = 0f;
Attributes attributes = base.gameObject.GetAttributes();
AttributeInstance attributeInstance = attributes.Add(Db.Get().Attributes.ThermalConductivityBarrier);
AttributeModifier modifier = new AttributeModifier(Db.Get().Attributes.ThermalConductivityBarrier.Id, thickness, DUPLICANTS.MODIFIERS.BASEDUPLICANT.NAME, false, false, true);
attributeInstance.Add(modifier);
averageTemperatureTransferPerSecond = new AttributeModifier("TemperatureDelta", 0f, DUPLICANTS.MODIFIERS.TEMPEXCHANGE.NAME, false, true, false);
this.GetAttributes().Add(averageTemperatureTransferPerSecond);
base.OnPrefabInit();
}
private static void InitDb()
{
var db = Db.Get();
// тюнингуем и актифируем комнату
// подхватывать максимальный размер комнаты из тюнинга
int maxRoomSize = TuningData <RoomProber.Tuning> .Get().maxRoomSize;
RoomConstraints.Constraint MAXIMUM_SIZE_MAX = new RoomConstraints.Constraint(
building_criteria: null,
room_criteria: (Room room) => room.cavity.numCells <= maxRoomSize,
times_required: 1,
name: string.Format(ROOMS.CRITERIA.MAXIMUM_SIZE.NAME, maxRoomSize),
description: string.Format(ROOMS.CRITERIA.MAXIMUM_SIZE.DESCRIPTION, maxRoomSize),
stomp_in_conflict: null);
var additional_constraints = db.RoomTypes.MachineShop.additional_constraints;
for (int i = 0; i < additional_constraints.Length; i++)
{
if (additional_constraints[i] == RoomConstraints.MAXIMUM_SIZE_96)
{
additional_constraints[i] = MAXIMUM_SIZE_MAX;
break;
}
}
db.RoomTypes.Add(db.RoomTypes.MachineShop);
// добавляем перк для работы на станции
CanMachineTinker = db.SkillPerks.Add(new SimpleSkillPerk(REQUIRED_ROLE_PERK, STRINGS.PERK_CAN_MACHINE_TINKER.DESCRIPTION));
db.Skills.Technicals1.perks.Add(CanMachineTinker);
// добавляем модификаторы и эффекты
string text = DUPLICANTS.MODIFIERS.MACHINETINKER.NAME;
string description = STRINGS.DUPLICANTS.MODIFIERS.MACHINETINKER.TOOLTIP;
CraftingSpeed = db.Attributes.Add(new Attribute(CRAFTING_SPEED_MODIFIER_NAME, false, Attribute.Display.General, false, BASE_SPEED_VALUE));
CraftingSpeed.SetFormatter(new PercentAttributeFormatter());
MachinerySpeedModifier = new AttributeModifier(MACHINERY_SPEED_MODIFIER_NAME, MACHINERY_SPEED_MODIFIER, text);
CraftingSpeedModifier = new AttributeModifier(CRAFTING_SPEED_MODIFIER_NAME, CRAFTING_SPEED_MODIFIER, text);
MachineTinkerEffect = db.effects.Add(new Effect(MACHINE_TINKER_EFFECT_NAME, text, description, MACHINE_TINKER_EFFECT_DURATION * Constants.SECONDS_PER_CYCLE, true, true, false));
MachineTinkerEffect.Add(MachinerySpeedModifier);
MachineTinkerEffect.Add(CraftingSpeedModifier);
}
private void Clear()
{
currentItem = null;
currentModifier = null;
imagePicker.ResetGid();
var allTextBoxes = Utils.GetChildControls <TextBox>(this);
foreach (TextBox tb in allTextBoxes)
{
tb.Text = "";
}
ClearModifier();
modList.Items.Clear();
modifiers.Clear();
}
public void calculates_added_modifier()
{
// Arange
IAttribute attr = new Attribute();
AttributeModifier mod = new AttributeModifier(1f, AttrModType.Flat);
// Act
float actualBaseValue = attr.BaseValue;
AttrProcessor.AddModifier(ref attr, mod);
float actualValue = attr.Value;
// Assert
Assert.AreEqual(0f, actualBaseValue);
Assert.AreEqual(1f, actualValue);
}
private void OnStorageChanged(object data)
{
// inefficient - set the status of every symbol based on its presence
foreach (Tag tag in ArtifactsFilterTagList)
{
anim.SetSymbolVisiblity(tag.ToString(), false);
}
foreach (Tag tag in storage.GetAllTagsInStorage())
{
anim.SetSymbolVisiblity(tag.ToString(), true);
}
// determine appropriate decor amount
Attributes attributes = this.GetAttributes();
if (decorModifier.Count > 0)
{
foreach (AttributeModifier attr in decorModifier.Values)
{
attributes.Remove(attr);
}
decorModifier.Clear();
}
// probably need a hashmap from the tag of the artifact to the decor modifier and decor radius modifier for it so I can properly remove
// and add the components
foreach (GameObject go in storage.items)
{
if (go.GetComponent <DecorProvider>() != null)
{
float decorValue = go.GetComponent <PrimaryElement>().Units *Mathf.Max(Db.Get().BuildingAttributes.Decor.Lookup(go).GetTotalValue() * STORED_DECOR_MODIFIER, MINIMUM_DECOR_PER_ITEM);
string description = string.Format(STRINGS.BUILDINGS.PREFABS.ITEMPEDESTAL.DISPLAYED_ITEM_FMT, go.GetComponent <KPrefabID>().PrefabTag.ProperName());
Tag prefabTag = go.GetComponent <KPrefabID>().PrefabTag;
if (decorModifier.ContainsKey(prefabTag))
{
decorModifier[prefabTag].SetValue(decorModifier[prefabTag].Value + decorValue);
}
else
{
decorModifier[prefabTag] = new AttributeModifier(Db.Get().BuildingAttributes.Decor.Id, decorValue, description, false, false, true);
}
}
}
foreach (AttributeModifier attr in decorModifier.Values)
{
attributes.Add(attr);
}
}
internal static void Postfix(AttributeModifier ___unrefrigeratedModifier,
AttributeModifier ___refrigeratedModifier,
AttributeModifier ___frozenModifier,
AttributeModifier ___contaminatedAtmosphereModifier,
AttributeModifier ___normalAtmosphereModifier,
AttributeModifier ___sterileAtmosphereModifier)
{
// Modifiers were initialized by the constructor
// Normal: -0.5, Sterile: x0, Contaminated: -1
// Refrigerated/Frozen: +0.5, Unrefrigerated: +0
___unrefrigeratedModifier.SetValue(0.0f);
___refrigeratedModifier.SetValue(0.5f);
___frozenModifier.SetValue(0.5f);
___normalAtmosphereModifier.SetValue(-0.5f);
___contaminatedAtmosphereModifier.SetValue(-1.0f);
// IsReadonly is dead code, thankfully
___sterileAtmosphereModifier.SetValue(0.0f);
}
public void correctly_sorts_and_calculates_multiple_modifier_types()
{
// Arrange
IAttribute attr = new Attribute(10);
AttributeModifier modFlat = new AttributeModifier(100f, AttrModType.Flat);
AttributeModifier modPercentAdd1 = new AttributeModifier(0.025f, AttrModType.PercentAdd);
AttributeModifier modPercentAdd2 = new AttributeModifier(0.025f, AttrModType.PercentAdd);
AttributeModifier modPercentMult = new AttributeModifier(0.05f, AttrModType.PercentMult);
// Act
AttrProcessor.AddModifier(ref attr, modFlat);
AttrProcessor.AddModifier(ref attr, modPercentAdd1);
AttrProcessor.AddModifier(ref attr, modPercentAdd2);
AttrProcessor.AddModifier(ref attr, modPercentMult);
float actualValue = attr.Value;
// Assert
Assert.AreEqual(121f, Mathf.Round(actualValue));
}
private static void AddBuildingAndEffects()
{
Utils.AddBuildingToPlanScreen("Furniture", CarouselCentrifugeConfig.ID, EspressoMachineConfig.ID);
#if VANILLA
const string requiredTech = "ArtificialFriends";
#elif EXPANSION1
const string requiredTech = "SpaceProgram";
#endif
Utils.AddBuildingToTechnology(requiredTech, CarouselCentrifugeConfig.ID);
moraleModifier = new AttributeModifier(
attribute_id: "QualityOfLife",
value: CarouselCentrifugeOptions.Instance.MoraleBonus,
description: STRINGS.DUPLICANTS.MODIFIERS.RIDEONCAROUSEL.NAME,
is_multiplier: false,
uiOnly: false,
is_readonly: false
);
specificEffect = new Effect(
id: CarouselCentrifugeWorkable.specificEffectName,
name: STRINGS.DUPLICANTS.MODIFIERS.RIDEONCAROUSEL.NAME,
description: STRINGS.DUPLICANTS.MODIFIERS.RIDEONCAROUSEL.TOOLTIP,
duration: (CarouselCentrifugeOptions.Instance.SpecificEffectDuration - 0.05f) * Constants.SECONDS_PER_CYCLE,
show_in_ui: false,
trigger_floating_text: true,
is_bad: false
);
specificEffect.Add(moraleModifier);
trackingEffect = new Effect(
id: CarouselCentrifugeWorkable.trackingEffectName,
name: "",
description: "",
duration: CarouselCentrifugeOptions.Instance.TrackingEffectDuration * Constants.SECONDS_PER_CYCLE,
show_in_ui: false,
trigger_floating_text: false,
is_bad: false
);
Db.Get().effects.Add(specificEffect);
Db.Get().effects.Add(trackingEffect);
}
private static void AfterDbInit()
{
var db = Db.Get();
var effectFarmTinker = db.effects.Get(TinkerableEffectMonitor.FARMTINKEREFFECTID);
ColdBreatherThroughput = new Attribute(nameof(ColdBreatherThroughput), false, Attribute.Display.General, false, THROUGHPUT_BASE_VALUE);
ColdBreatherThroughput.SetFormatter(new PercentAttributeFormatter());
db.Attributes.Add(ColdBreatherThroughput);
ColdBreatherThroughputModifier = new AttributeModifier(ColdBreatherThroughput.Id, THROUGHPUT_MULTIPLIER - THROUGHPUT_BASE_VALUE);
effectFarmTinker.Add(ColdBreatherThroughputModifier);
OxyfernThroughput = new Attribute(nameof(OxyfernThroughput), false, Attribute.Display.General, false, THROUGHPUT_BASE_VALUE);
OxyfernThroughput.SetFormatter(new PercentAttributeFormatter());
db.Attributes.Add(OxyfernThroughput);
OxyfernThroughputModifier = new AttributeModifier(OxyfernThroughput.Id, THROUGHPUT_MULTIPLIER - THROUGHPUT_BASE_VALUE);
effectFarmTinker.Add(OxyfernThroughputModifier);
}
private void UpdateBaseDecorModifiers()
{
Attributes attributes = this.GetAttributes();
if (baseDecorModifier != null)
{
attributes.Remove(baseDecorModifier);
attributes.Remove(baseDecorRadiusModifier);
baseDecorModifier = null;
baseDecorRadiusModifier = null;
}
if (baseDecor != 0f)
{
baseDecorModifier = new AttributeModifier(Db.Get().BuildingAttributes.Decor.Id, baseDecor, UI.TOOLTIPS.BASE_VALUE, false, false, true);
baseDecorRadiusModifier = new AttributeModifier(Db.Get().BuildingAttributes.DecorRadius.Id, baseRadius, UI.TOOLTIPS.BASE_VALUE, false, false, true);
attributes.Add(baseDecorModifier);
attributes.Add(baseDecorRadiusModifier);
}
}
private void modEditButton_Click(object sender, EventArgs e)
{
if (currentModifier != null)
{
modifiers.Remove(currentModifier);
}
else
{
currentModifier = new AttributeModifier();
}
currentModifier.Attribute = (CharacterAttribute)Enum.Parse(typeof(CharacterAttribute), modAttribute.Text);
currentModifier.Type = (ModifierType)Enum.Parse(typeof(ModifierType), modType.Text);
currentModifier.Value = int.Parse(modValue.Text);
modifiers.Add(currentModifier);
LoadModifiers();
}
public Instance(IStateMachineTarget master, Def def)
: base(master, def)
{
pickupable = base.gameObject.RequireComponent <Pickupable>();
base.master.Subscribe(-2064133523, OnAbsorb);
base.master.Subscribe(1335436905, OnSplitFromChunk);
primaryElement = base.gameObject.GetComponent <PrimaryElement>();
Amounts amounts = master.gameObject.GetAmounts();
RotAmountInstance = amounts.Add(new AmountInstance(Db.Get().Amounts.Rot, master.gameObject));
RotAmountInstance.maxAttribute.ClearModifiers();
RotAmountInstance.maxAttribute.Add(new AttributeModifier("Rot", def.spoilTime, null, false, false, true));
RotAmountInstance.SetValue(def.spoilTime);
base.sm.rotParameter.Set(RotAmountInstance.value, base.smi);
UnrefrigeratedModifier = new AttributeModifier("Rot", 0f, DUPLICANTS.MODIFIERS.ROTTEMPERATURE.NAME, false, false, false);
ContaminatedAtmosphere = new AttributeModifier("Rot", 0f, DUPLICANTS.MODIFIERS.ROTATMOSPHERE.NAME, false, false, false);
RotAmountInstance.deltaAttribute.Add(UnrefrigeratedModifier);
RotAmountInstance.deltaAttribute.Add(ContaminatedAtmosphere);
RefreshModifiers(0f);
}
public void RemoveModifiers(int itemId)
{
AttributeSheet sheet = Global.Player.Attributes;
AttributeModifier mod = null;
foreach (AttributeModifier att in sheet.Modifiers)
{
if (att.ItemId == itemId)
{
mod = att;
break;
}
}
if (mod != null)
{
sheet.Modifiers.Remove(mod);
sheet.Recalculate();
}
}
public void removed_modifier_successfully()
{
// Arrange
IAttribute attr = new Attribute();
AttributeModifier mod = new AttributeModifier(10f, AttrModType.Flat);
// Act
float actualBaseValue = attr.BaseValue;
AttrProcessor.AddModifier(ref attr, mod);
float actualValueWithModifier = attr.Value;
AttrProcessor.RemoveModifier(ref attr, mod);
float actualValue = attr.Value;
// Assert
Assert.AreEqual(0f, actualBaseValue);
Assert.AreEqual(10f, actualValueWithModifier);
Assert.AreEqual(0f, actualValue);
}
/// <summary>
/// Remove os modificadores de atributo da lista
/// </summary>
/// <param name="attributeModifiers_">Attribute modifiers.</param>
public static void CheckAttributeModifiers(ref AttributeModifier[] attributeModifiers_, Effects effects_)
{
bool _needToReorder = false;
for(int i = 0; i < attributeModifiers_.Length; i++)
{
if (attributeModifiers_[i] != null)
{
// Modificador de atributo por Tempo e Expirou o Tempo = Remove da Tabela de Modificadores e marca que precisa reorganizar a tabela
if (attributeModifiers_[i].ModifierType == ENUMERATORS.Attribute.AttributeModifierTypeEnum.Time &&
attributeModifiers_[i].ExpireTime < Time.time)
{
//Remove os efeitos associados ao modificador
RemoveEffect(effects_, attributeModifiers_[i]);
attributeModifiers_[i] = null;
_needToReorder = true;
continue;
}
// Se for modificador para ser usado uma unica vez e esta marcado como consumido exclui da tabela
if (attributeModifiers_[i].ModifierType == ENUMERATORS.Attribute.AttributeModifierTypeEnum.OneTimeOnly &&
attributeModifiers_[i].Consumed)
{
//Remove os efeitos associados ao modificador
RemoveEffect(effects_, attributeModifiers_[i]);
attributeModifiers_[i] = null;
_needToReorder = true;
continue;
}
}
else
break;
}
// Reorganiza a tabela se algum modificador foi removido
if (_needToReorder)
{
Helper.ReorderArray<AttributeModifier>(attributeModifiers_);
}
}
public static void ApplyAttributesModifiers(ref AttributeBase[] attributes, ref AttributeModifier[] attributeModifiers_, Effects effects_)
{
int _attributeTypeIndex;
for (int i = 0; i < attributeModifiers_.Length; i++)
{
if (attributeModifiers_[i] != null)
{
_attributeTypeIndex = (int)attributeModifiers_[i].AttributeType;
switch(attributeModifiers_[i].CalcType)
{
case ENUMERATORS.Attribute.AttributeModifierCalcTypeEnum.Percent:
switch(attributeModifiers_[i].ApplyTo)
{
case ENUMERATORS.Attribute.AttributeModifierApplyToEnum.Max:
switch (attributeModifiers_[i].ApplyAs)
{
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Temporary:
attributes[_attributeTypeIndex].MaxModifiers += (attributes[_attributeTypeIndex].Max * attributeModifiers_[i].Value / 100);
break;
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Constant:
attributes[_attributeTypeIndex].Max += (attributes[_attributeTypeIndex].Max * attributeModifiers_[i].Value / 100);
break;
}
break;
case ENUMERATORS.Attribute.AttributeModifierApplyToEnum.Current:
switch (attributeModifiers_[i].ApplyAs)
{
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Temporary:
attributes[_attributeTypeIndex].CurrentModifiers += (attributes[_attributeTypeIndex].Current * attributeModifiers_[i].Value / 100);
break;
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Constant:
attributes[_attributeTypeIndex].Current += (attributes[_attributeTypeIndex].Current * attributeModifiers_[i].Value / 100); // PERCENTUAL SEMPRE EM CIMA DO MAXIMO
break;
}
break;
case ENUMERATORS.Attribute.AttributeModifierApplyToEnum.Both:
switch (attributeModifiers_[i].ApplyAs)
{
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Temporary:
attributes[_attributeTypeIndex].MaxModifiers += (attributes[_attributeTypeIndex].Max * attributeModifiers_[i].Value / 100);
attributes[_attributeTypeIndex].CurrentModifiers += (attributes[_attributeTypeIndex].Current * attributeModifiers_[i].Value / 100);
break;
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Constant:
attributes[_attributeTypeIndex].Max += (attributes[_attributeTypeIndex].Max * attributeModifiers_[i].Value / 100);
attributes[_attributeTypeIndex].Current += (attributes[_attributeTypeIndex].Max * attributeModifiers_[i].Value / 100); // PERCENTUAL SEMPRE EM CIMA DO MAXIMO
break;
}
break;
}
break;
case ENUMERATORS.Attribute.AttributeModifierCalcTypeEnum.Value:
switch(attributeModifiers_[i].ApplyTo)
{
case ENUMERATORS.Attribute.AttributeModifierApplyToEnum.Max:
switch(attributeModifiers_[i].ApplyAs)
{
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Temporary:
attributes[_attributeTypeIndex].MaxModifiers += attributeModifiers_[i].Value;
break;
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Constant:
attributes[_attributeTypeIndex].Max += attributeModifiers_[i].Value;
break;
}
break;
case ENUMERATORS.Attribute.AttributeModifierApplyToEnum.Current:
switch(attributeModifiers_[i].ApplyAs)
{
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Temporary:
attributes[_attributeTypeIndex].CurrentModifiers += attributeModifiers_[i].Value;
break;
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Constant:
attributes[_attributeTypeIndex].Current += attributeModifiers_[i].Value;
break;
}
break;
case ENUMERATORS.Attribute.AttributeModifierApplyToEnum.Both:
switch(attributeModifiers_[i].ApplyAs)
{
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Temporary:
attributes[_attributeTypeIndex].MaxModifiers += attributeModifiers_[i].Value;
attributes[_attributeTypeIndex].CurrentModifiers += attributeModifiers_[i].Value;
break;
case ENUMERATORS.Attribute.AttributeModifierApplyAsEnum.Constant:
attributes[_attributeTypeIndex].Max += attributeModifiers_[i].Value;
attributes[_attributeTypeIndex].Current += attributeModifiers_[i].Value;
break;
}
break;
}
break;
}
// Marca o atributo como consumido
attributeModifiers_[i].Consumed = true;
// Aplica os valores maximos caso o modificador de atributo esteja configurado para nao exceder
if (!attributeModifiers_[i].CanSetToCurrentExceedMax &&
attributes[(int)attributeModifiers_[i].AttributeType].Current > attributes[(int)attributeModifiers_[i].AttributeType].Max)
{
attributes[(int)attributeModifiers_[i].AttributeType].Current = attributes[(int)attributeModifiers_[i].AttributeType].Max;
}
// Aplica os efeitos atrelados ao modificador
ApplyEffect(effects_, attributeModifiers_[i]);
}
}
}
private static AttributeModifier[] InitializeAttributesModifiers()
{
AttributeModifier[] _tempModifier = new AttributeModifier[CONSTANTS.ATTRIBUTES.ATTRIBUTE_MODIFIERS_COUNT];
for (int i = 0; i < _tempModifier.Length; i++)
{
_tempModifier[i] = null;
}
return _tempModifier;
}
/// <summary>
/// Aplica os efeitos utilizando as operacoes BitWise
/// </summary>
/// <param name="effects_">Effects.</param>
/// <param name="modifier_">Modifier.</param>
private static void ApplyEffect(Effects effects_, AttributeModifier modifier_)
{
if (effects_ != null)
{
if (modifier_.HasSkillEffect &&
(( effects_.SkillEffects & modifier_.SkillEffects ) == 0))
{
effects_.SkillEffects = effects_.SkillEffects | modifier_.SkillEffects;
}
}
}
/// <summary>
/// Remove os efeitos associados a um modificador utilizando as operacoes BitWise
/// </summary>
/// <param name="effects_">Effects.</param>
/// <param name="modifier_">Modifier.</param>
private static void RemoveEffect(Effects effects_, AttributeModifier modifier_)
{
if (effects_ != null)
{
if (modifier_.HasSkillEffect &&
(( effects_.SkillEffects & modifier_.SkillEffects ) != 0))
{
effects_.SkillEffects &= ~modifier_.SkillEffects;
}
}
}
/// <summary>
/// Metodo responsavel por gerenciar a adicao de modificadores de atributos ao personagem
/// </summary>
/// <param name="attributeModifier_">Lista de Attribute modifier.</param>
public static void AddAttributeModifier(ref AttributeModifier[] attributeModifiers_, AttributeModifier[] attributeModifierList_)
{
if (attributeModifierList_ != null){
for(int i = 0; i < attributeModifierList_.Length; i++)
{
AttributeModifier.AddAttributeModifier(ref attributeModifiers_, attributeModifierList_[i]);
}
}
}
