private void ResetSpeed(CallReason continueReason)
{
var speedModifier = new FloatModifier(ModifyMode.Divide, AttributeCode.Speed, 1.5f);
World.Instance.ApplyModifier(ActionSource, speedModifier);
ContinueEvent -= ResetSpeed;
}
protected override Damage OnModify(GameObject victim, GameObject attacker, Damage damage)
{
HealthComponent health;
switch (this.target)
{
case DamageSubject.Victim:
health = victim.GetComponent <HealthComponent>();
break;
case DamageSubject.Attacker:
health = attacker.GetComponent <HealthComponent>();
break;
default:
throw new ArgumentOutOfRangeException();
}
var modifier = new FloatModifier(
Mathf.Clamp(
(1 - health.HealthFraction) * 100 * this.amountPerPercent,
this.min,
this.max
),
ModifierType);
var modified = modifier.Modify(damage.Amount);
return(new Damage(modified, damage.Type, damage.WeaponSound, damage.Flags, damage.InfoFlags));
}
protected override Damage OnModify(GameObject victim, GameObject attacker, Damage damage)
{
HealthComponent health;
switch (this.data.Target)
{
case DamageSubject.Victim:
health = victim.GetComponent <HealthComponent>();
break;
case DamageSubject.Attacker:
health = attacker.GetComponent <HealthComponent>();
break;
default:
throw new ArgumentOutOfRangeException();
}
if (!Comparator.Compare(health.HealthFraction, this.data.RequiredHealthFraction, this.data.Comparator))
{
return(damage);
}
var modified = new FloatModifier(this.data.Amount, ModifierType).Modify(damage.Amount);
return(new Damage(modified, damage.Type, damage.WeaponSound, damage.Flags, damage.InfoFlags));
}
public virtual bool RemoveSingleModifier(FloatModifier mod, bool hardRemove)
{
bool result = RemoveModifier(mod, hardRemove);
floatModifiers.Sort(CompareModifierOrder);
return(result);
}
//结束
public override void EndAbility()
{
if (StatusConfigObject.EnabledAttributeModify)
{
switch (StatusConfigObject.AttributeType)
{
case AttributeType.None:
break;
case AttributeType.AttackPower:
GetParent <CombatEntity>().AttributeComponent.AttackPower.RemoveAddModifier(NumericModifier);
break;
case AttributeType.AttackDefense:
break;
case AttributeType.SpellPower:
break;
case AttributeType.MagicDefense:
break;
case AttributeType.CriticalProb:
break;
default:
break;
}
}
NumericModifier = null;
GetParent <CombatEntity>().OnStatusRemove(this);
base.EndAbility();
}
public override void OnGUI(SerializedPropertyX property, GUIContent label)
{
FloatRange attr = property.GetValue <FloatRange>();
label.text = property.displayName + " (" + attr.Value + ")";
property.isExpanded = EditorGUILayout.Foldout(property.isExpanded, label);
if (property.isExpanded)
{
property["baseValue"].Value = (float)(EditorGUILayout.FloatField(new GUIContent("Base Value"), property["baseValue"].GetValue <float>()));
if (Mathf.Approximately(attr.BaseValue, 0))
{
attr.BaseValue = 0;
}
attr.BaseValue = property["baseValue"].GetValue <float>();
property["currentValue"].Value = attr.Value;
EditorGUI.indentLevel++;
FloatModifier[] modifiers = attr.GetReadOnlyModiferList();
for (int i = 0; i < modifiers.Length; i++)
{
FloatModifier modifier = modifiers[i];
string valueStr = "Flat: " + modifier.flatBonus + " Percent: " + modifier.percentBonus;
GUI.enabled = false;
EditorGUILayout.TextField(new GUIContent(modifier.id), valueStr);
GUI.enabled = true;
}
EditorGUILayoutX.PropertyField(property["min"]);
EditorGUILayoutX.PropertyField(property["max"]);
EditorGUI.indentLevel--;
}
}
internal FloatModifier Compute()
{
FloatModifier modifier = new FloatModifier();
modifier.flat = flat.Value;
modifier.percent = percent.Value;
return(modifier);
}
public static FloatModifier operator +(FloatModifier x, FloatModifier y)
{
FloatModifier result = new FloatModifier();
result.flat = x.flat + y.flat;
result.percent = x.percent + y.percent;
return(result);
}
//激活
public override void ActivateAbility()
{
base.ActivateAbility();
if (StatusConfigObject.EnabledStateModify)
{
}
if (StatusConfigObject.EnabledAttributeModify)
{
switch (StatusConfigObject.AttributeType)
{
case AttributeType.None:
break;
case AttributeType.AttackPower:
var value = int.Parse(StatusConfigObject.NumericValue);
NumericModifier = new FloatModifier()
{
Value = value
};
GetParent <CombatEntity>().AttributeComponent.AttackPower.AddAddModifier(NumericModifier);
break;
case AttributeType.AttackDefense:
break;
case AttributeType.SpellPower:
break;
case AttributeType.MagicDefense:
break;
case AttributeType.CriticalProb:
break;
default:
break;
}
}
if (StatusConfigObject.EnabledLogicTrigger)
{
foreach (var item in StatusConfigObject.Effects)
{
var logicEntity = EntityFactory.CreateWithParent <LogicEntity>(this, item);
if (item.EffectTriggerType == EffectTriggerType.Interval)
{
logicEntity.AddComponent <LogicIntervalTriggerComponent>();
}
if (item.EffectTriggerType == EffectTriggerType.Condition)
{
logicEntity.AddComponent <LogicConditionTriggerComponent>();
}
if (item.EffectTriggerType == EffectTriggerType.Action)
{
logicEntity.AddComponent <LogicActionTriggerComponent>();
}
}
}
}
protected virtual void AddModifier(FloatModifier mod)
{
floatModifiers.Add(mod);
mod.associatedFloat = this;
if (mod.isTimed)
{
mod.additionTime = Time.time;
}
}
protected virtual bool RemoveModifier(FloatModifier mod, bool hardRemove)
{
if ((!mod.ignoreRemove || hardRemove) && floatModifiers.Remove(mod))
{
mod.associatedFloat = null;
return(true);
}
return(false);
}
public override void OnEffectApplied()
{
health = target.resourceManager.GetResource("Health");
if (health != null && reduceByPercent > 0)
{
reduceByPercent = Mathf.Clamp01(reduceByPercent);
health.SetModifier("ReduceTotalHealth", FloatModifier.Percent(reduceByPercent));
}
}
public void AddItemData(ItemData itemData)
{
ItemDatas.Add(itemData.Id, itemData);
var equipmentConfig = ConfigHelper.Get <EquipmentConfig>(itemData.ConfigId);
var modifier = new FloatModifier();
modifier.Value = equipmentConfig.Value;
GetEntity <CombatEntity>().GetComponent <AttributeComponent>().GetNumeric(equipmentConfig.Attribute).AddAddModifier(modifier);
EquipmentNumerics.Add(itemData.Id, modifier);
}
protected override void Awake()
{
base.Awake();
speedReducer = new FloatModifier(speedReductionPercent, FloatModifier.FloatModType.PercentMult, this);
Action FocusHealInterUpdate = aEntity.BaseActionUpdate;
FocusHealInterUpdate += FocusHealUpdate;
focusState = new StateSetter(this, FocusHealthControl, FocusHealInterUpdate, aEntity.BaseActionFixedUpdate, CancelFocusHeal);
}
private void Awake()
{
ObjectRb2d = GetComponent <Rigidbody2D>();
gravity = new FloatModifier(0f, FloatModifier.FloatModType.Flat);
yMovement.AddSingleModifier(gravity);
contactFilter2D.useTriggers = false;
contactFilter2D.SetLayerMask(Physics2D.GetLayerCollisionMask(gameObject.layer));
contactFilter2D.useLayerMask = true;
}
protected virtual int CompareModifierOrder(FloatModifier a, FloatModifier b)
{
if (a.order < b.order)
{
return(-1);
}
else if (a.order > b.order)
{
return(1);
}
return(0); //if (a.Order == b.Order)
}
private void SetState()
{
var speedModifier = new FloatModifier(ModifyMode.Multiplication, AttributeCode.Speed, 1.5f);
World.Instance.ApplyModifier(ActionSource, speedModifier);
SetActionCooldown();
AddCondition(new TimedContinueCondition(m_SkillDuration));
ContinueEvent += ResetSpeed;
StartConditions();
}
public void RemoveModifier(string id)
{
for (int i = 0; i < modifiers.Count; i++)
{
if (modifiers[i].id == id)
{
FloatModifier prev = modifiers[i];
flatBonus -= prev.flatBonus;
percentBonus -= prev.percentBonus;
BaseValue = BaseValue;
break;
}
}
}
private void Awake()
{
if (controller == null)
{
controller = new FloatModifier(0, FloatModifier.FloatModType.Flat, this);
}
boxCollider = GetComponent <BoxCollider2D>();
transitionState = new StateSetter(this, null, Player.instance.BaseActionUpdate, Player.instance.BaseActionFixedUpdate, StateSetter.SetStrength.Strong);
transitionStateUp = new StateSetter(this, null, null, null, StateSetter.SetStrength.Strong);
PositionExit();
OrientMoveVector();
}
public override void OnGUI(SerializedPropertyX property, GUIContent label)
{
FloatValue attr = property.GetValue <FloatValue>();
string labelText = property.displayName + " (" + attr.Value + ")";
if (Mathf.Approximately(attr.Value, float.MaxValue) || Mathf.Approximately(attr.Value, float.MinValue))
{
labelText = property.displayName + " (--)";
}
label.text = labelText;
shown = EditorGUILayout.Foldout(shown, label);
if (shown)
{
EditorGUI.indentLevel++;
attr.BaseValue = (float)System.Math.Round(EditorGUILayout.FloatField(new GUIContent("Base Value"), attr.BaseValue), 3);
if (Mathf.Approximately(attr.BaseValue, 0))
{
attr.BaseValue = 0;
}
property["baseValue"].Value = attr.BaseValue;
FloatRange.FloatRangeBoundry rangeBoundry = attr as FloatRange.FloatRangeBoundry;
if (rangeBoundry != null)
{
//this code makes sure the parent's value is clamped now that we've updated a range boundry
rangeBoundry.BaseValue = property["baseValue"].GetValue <float>();
float parentValue = rangeBoundry.parent.Value;
property["parent"]["currentValue"].Value = parentValue;
}
FloatModifier[] modifiers = attr.GetReadOnlyModiferList();
for (int i = 0; i < modifiers.Length; i++)
{
FloatModifier modifier = modifiers[i];
string valueStr = "";
if (modifier.flatBonus != 0)
{
valueStr += modifier.flatBonus;
}
else if (modifier.percentBonus != 0)
{
valueStr += modifier.percentBonus + " %";
}
EditorGUILayout.LabelField(modifier.id);
EditorGUILayout.LabelField(valueStr);
}
EditorGUI.indentLevel--;
}
}
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label)
{
pos = new Rect(pos)
{
height = EditorGUIUtility.singleLineHeight
};
object target = prop.serializedObject.targetObject;
FloatRange attr = target.GetType().GetField(prop.name).GetValue(target) as FloatRange;
label.text += " (" + attr.Value + ")";
shown = EditorGUI.Foldout(pos, shown, label);
if (shown)
{
pos.y += EditorGUIUtility.singleLineHeight;
EditorGUI.indentLevel++;
attr.BaseValue = EditorGUI.FloatField(pos, new GUIContent("Base Value"), attr.BaseValue);
pos.y += EditorGUIUtility.singleLineHeight;
FloatModifier[] modifiers = attr.GetReadOnlyModiferList();
for (int i = 0; i < modifiers.Length; i++)
{
FloatModifier modifier = modifiers[i];
string valueStr = "";
if (modifier.flatBonus != 0)
{
valueStr += modifier.flatBonus;
}
else if (modifier.percentBonus != 0)
{
valueStr += modifier.percentBonus + " %";
}
var keyRect = new Rect(pos)
{
width = EditorGUIUtility.labelWidth
};
var valueRect = new Rect(pos)
{
x = EditorGUIUtility.labelWidth,
};
EditorGUI.LabelField(keyRect, modifier.id);
EditorGUI.LabelField(valueRect, valueStr);
pos.y += EditorGUIUtility.singleLineHeight;
}
EditorGUI.indentLevel--;
}
}
//handle progression of entity, attributes, and resources
public void Awake()
{
attr = new FloatRange(0);
attr.SetModifier("Mod1", FloatModifier.Value(1));
attr.SetModifier("Mod2", FloatModifier.Value(3));
attr.SetModifier("Mod3", FloatModifier.Value(6));
attr2 = new FloatRange(0);
attr2.SetModifier("Mod1", FloatModifier.Value(5));
attr2.SetModifier("Mod2", FloatModifier.Percent(0.2f));
attr2.SetModifier("Mod3", FloatModifier.Value(5));
resourceManager = new ResourceManager(this);
statusManager = new StatusEffectManager(this);
abilityManager = new AbilityManager(this);
emitter = new EventEmitter();
EntityManager.Instance.Register(this);
//gameObject.layer = LayerMask.NameToLayer("Entity");
}
public void SetModifier(string id, FloatModifier modifier) {
modifier = new FloatModifier(id, modifier);
for (int i = 0; i < modifiers.Count; i++) {
if (modifiers[i].id == id) {
FloatModifier prev = modifiers[i];
flatBonus -= prev.flatBonus;
percentBonus -= prev.percentBonus;
break;
}
}
modifiers.Add(modifier);
flatBonus += modifier.flatBonus;
percentBonus += modifier.percentBonus;
}
protected virtual float CalculateFinalValue()
{
float finalValue = BaseValue;
float sumPercentAdd = 0;
//floatModifiers.Sort(CompareModifierOrder);
for (int i = floatModifiers.Count - 1; i >= 0; i--)
{
if (floatModifiers[i].TimeCheck())
{
RemoveSingleModifier(floatModifiers[i], false);
}
}
for (int i = 0; i < floatModifiers.Count; i++)
{
FloatModifier mod = floatModifiers[i];
if (mod.type == FloatModifier.FloatModType.Flat)
{
finalValue += mod.ModifierValue;
}
else if (mod.type == FloatModifier.FloatModType.PercentAdd)
{
sumPercentAdd += mod.ModifierValue;
if (i + 1 >= floatModifiers.Count || floatModifiers[i + 1].type != FloatModifier.FloatModType.PercentAdd)
{
finalValue *= sumPercentAdd; //If you want to do increases, it needs to start at 1.
sumPercentAdd = 0;
}
}
else if (mod.type == FloatModifier.FloatModType.PercentMult)
{
finalValue *= mod.ModifierValue; //If you want to do increases, it needs to start at 1.
}
}
return(finalValue);
// Workaround for float calculation errors, like displaying 12.00001 instead of 12
//return (float)Math.Round(finalValue, 4);
}
public void SetModifier(string id, FloatModifier modifier)
{
modifier = new FloatModifier(id, modifier);
for (int i = 0; i < modifiers.Count; i++)
{
if (modifiers[i].id == id)
{
FloatModifier prev = modifiers[i];
flatBonus -= prev.flatBonus;
percentBonus -= prev.percentBonus;
break;
}
}
modifiers.Add(modifier);
flatBonus += modifier.flatBonus;
percentBonus += modifier.percentBonus;
}
internal override AEffectReport Apply(Unit a_target)
{
if (effectInfos == null)
{
Debug.LogError("Null effect for this modifier effect");
return(null);
}
FloatModifier percent;
IntModifier flat;
IntModifierFromEffect intMod;
FloatModifierFromEffect floatMod;
//PHYSICAL
if (physical.flat > 0)
{
flat = new IntModifier();
flat.flat = ComputeStackModification(physical.flat);
intMod = new IntModifierFromEffect();
intMod.modifier = flat;
intMod.source = effectInfos.effectOverTime;
a_target.attack.bonusPhysical.damage.flat.AddModifierFromEffect(intMod);
}
if (physical.percent > 0)
{
percent = new FloatModifier();
percent.flat = ComputeStackModification(physical.percent); // Only flat % modification.
floatMod = new FloatModifierFromEffect();
floatMod.modifier = percent;
floatMod.source = effectInfos.effectOverTime;
a_target.attack.bonusPhysical.damage.percent.AddModifierFromEffect(floatMod);
}
//MAGIC
if (magic.flat > 0)
{
flat = new IntModifier();
flat.flat = ComputeStackModification(magic.flat);
intMod = new IntModifierFromEffect();
intMod.modifier = flat;
intMod.source = effectInfos.effectOverTime;
a_target.attack.bonusMagical.damage.flat.AddModifierFromEffect(intMod);
}
if (magic.percent > 0)
{
percent = new FloatModifier();
percent.flat = ComputeStackModification(magic.percent); // Only flat % modification.
floatMod = new FloatModifierFromEffect();
floatMod.modifier = percent;
floatMod.source = effectInfos.effectOverTime;
a_target.attack.bonusMagical.damage.percent.AddModifierFromEffect(floatMod);
}
return(null);
}
private void OnModifierStackChanged(FloatModifier modifier)
{
OnChange();
}
public virtual void AddSingleModifier(FloatModifier mod)
{
AddModifier(mod);
floatModifiers.Sort(CompareModifierOrder);
}
public FloatModifier(string id, FloatModifier other)
{
this.id = id;
flatBonus = other.flatBonus;
percentBonus = other.percentBonus;
}
public override void OnEquip()
{
var c = item.Owner.character;
c.parameters.baseParameters.strength.SetModifier("Protein Powder", FloatModifier.Percent(50.2f));
}
//激活
public override void ActivateAbility()
{
base.ActivateAbility();
//子状态效果
if (StatusConfigObject.EnableChildrenStatuses)
{
foreach (var item in StatusConfigObject.ChildrenStatuses)
{
var status = OwnerEntity.AttachStatus <StatusAbility>(item.StatusConfigObject);
status.Caster = OwnerEntity;
status.IsChildStatus = true;
status.ChildStatusData = item;
status.TryActivateAbility();
ChildrenStatuses.Add(status);
}
}
//行为禁制
if (StatusConfigObject.EnabledStateModify)
{
OwnerEntity.ActionControlType |= StatusConfigObject.ActionControlType;
}
//属性修饰
if (StatusConfigObject.EnabledAttributeModify)
{
if (StatusConfigObject.AttributeType != AttributeType.None && StatusConfigObject.NumericValue != "")
{
var numericValue = StatusConfigObject.NumericValue;
if (IsChildStatus)
{
foreach (var item in ChildStatusData.Params)
{
numericValue = numericValue.Replace(item.Key, item.Value);
}
}
numericValue = numericValue.Replace("%", "");
var expression = ExpressionHelper.ExpressionParser.EvaluateExpression(numericValue);
var value = (float)expression.Value;
NumericModifier = new FloatModifier()
{
Value = value
};
var attributeType = StatusConfigObject.AttributeType.ToString();
if (StatusConfigObject.ModifyType == ModifyType.Add)
{
GetParent <CombatEntity>().GetComponent <AttributeComponent>().GetNumeric(attributeType).AddFinalAddModifier(NumericModifier);
}
if (StatusConfigObject.ModifyType == ModifyType.PercentAdd)
{
GetParent <CombatEntity>().GetComponent <AttributeComponent>().GetNumeric(attributeType).AddFinalPctAddModifier(NumericModifier);
}
}
}
//逻辑触发
if (StatusConfigObject.EnabledLogicTrigger)
{
foreach (var item in StatusConfigObject.Effects)
{
var logicEntity = Entity.CreateWithParent <LogicEntity>(this, item);
if (item.EffectTriggerType == EffectTriggerType.Instant)
{
logicEntity.ApplyEffect();
Destroy(logicEntity);
}
if (item.EffectTriggerType == EffectTriggerType.Interval)
{
logicEntity.AddComponent <LogicIntervalTriggerComponent>();
}
if (item.EffectTriggerType == EffectTriggerType.Condition)
{
logicEntity.AddComponent <LogicConditionTriggerComponent>();
}
if (item.EffectTriggerType == EffectTriggerType.Action)
{
logicEntity.AddComponent <LogicActionTriggerComponent>();
}
}
}
}
