private IEnumerable <PowerUpWrapper> GetPowerUpsOfItemOptions(Item item, AttributeSystem attributeHolder)
{
var options = item.ItemOptions;
if (options == null)
{
yield break;
}
foreach (var optionLink in options)
{
var option = optionLink.ItemOption;
var powerUp = option.PowerUpDefinition;
var level = option.LevelType == LevelType.ItemLevel ? item.Level : optionLink.Level;
if (level > 1)
{
var optionOfLevel = option.LevelDependentOptions.FirstOrDefault(l => l.Level == level);
if (optionOfLevel == null)
{
// TODO: Log, this should never happen.
continue;
}
powerUp = optionOfLevel.PowerUpDefinition;
}
foreach (var wrapper in PowerUpWrapper.CreateByPowerUpDefintion(powerUp, attributeHolder))
{
yield return(wrapper);
}
}
}
/// <inheritdoc/>
public IEnumerable <PowerUpWrapper> GetPowerUps(Item item, AttributeSystem attributeHolder)
{
if (item.Durability <= 0)
{
yield break;
}
if (item.ItemSlot < InventoryConstants.FirstEquippableItemSlotIndex || item.ItemSlot > InventoryConstants.LastEquippableItemSlotIndex)
{
yield break;
}
if (item.Definition == null)
{
Log.Warn($"Item of slot {item.ItemSlot} got no Definition.");
yield break;
}
foreach (var attribute in item.Definition.BasePowerUpAttributes)
{
foreach (var powerUp in this.GetBasePowerUpWrappers(item, attributeHolder, attribute))
{
yield return(powerUp);
}
}
foreach (var powerUp in this.GetPowerUpsOfItemOptions(item, attributeHolder))
{
yield return(powerUp);
}
}
protected virtual void OnEquip(GameObject obj)
{
attr = obj.GetComponent <AttributeSystem>();
for (int i = 0; i < attributeList.Length; i++)
{
attr.AddFixed(attributeList[i].type, attributeList[i].quantity);
}
}
/// <inheritdoc/>
public IEnumerable <PowerUpWrapper> GetSetPowerUps(
IEnumerable <Item> equippedItems,
AttributeSystem attributeHolder,
GameConfiguration gameConfiguration)
{
var activeItems = equippedItems
.Where(i => i.Durability > 0)
.ToList();
var itemGroups = activeItems
.SelectMany(i => i.ItemSetGroups ?? Enumerable.Empty <ItemSetGroup>())
.Distinct();
var result = Enumerable.Empty <PowerUpDefinition>();
foreach (var group in itemGroups)
{
if (group.AlwaysApplies)
{
result = result.Concat(group.Options.Select(o => o.PowerUpDefinition));
continue;
}
var itemsOfGroup = activeItems.Where(i => (i.ItemSetGroups?.Contains(group) ?? false) &&
(group.SetLevel == 0 || i.Level >= group.SetLevel));
var setMustBeComplete = group.MinimumItemCount == group.Items.Count;
if (group.SetLevel > 0 && setMustBeComplete && itemsOfGroup.All(i => i.Level > group.SetLevel))
{
// When all items are of higher level and the set bonus is applied when all items are there, another item set group will take care.
// This should prevent that for example set bonus defense is applied multiple times.
continue;
}
var itemCount = group.CountDistinct ? itemsOfGroup.Select(item => item.Definition).Distinct().Count() : itemsOfGroup.Count();
var setIsComplete = itemCount == group.Items.Count;
if (setIsComplete)
{
// Take all options when the set is complete
result = result.Concat(group.Options.Select(o => o.PowerUpDefinition));
continue;
}
if (itemCount >= group.MinimumItemCount)
{
// Take the first n-1 options
result = result.Concat(group.Options.OrderBy(o => o.Number)
.Take(itemCount - 1)
.Select(o => o.PowerUpDefinition));
}
}
result = result.Concat(this.GetOptionCombinationBonus(activeItems, gameConfiguration));
return(result.SelectMany(p => PowerUpWrapper.CreateByPowerUpDefinition(p, attributeHolder)));
}
protected virtual void OnValidate()
{
// Caching components
Attributes = GetComponent <AttributeSystem>();
SpriteRenderer = GetComponent <SpriteRenderer>();
Animator = GetComponent <Animator>();
// Default attributes
Attributes.AddAttribute(DefaultAttributes.HEALTH);
Attributes.AddAttribute(DefaultAttributes.INVULNERABLE);
}
/// <summary>
/// Initializes a new instance of the <see cref="PowerUpWrapper"/> class.
/// </summary>
/// <param name="element">The element.</param>
/// <param name="targetAttribute">The target attribute.</param>
/// <param name="attributeHolder">The attribute holder.</param>
public PowerUpWrapper(IElement element, AttributeDefinition targetAttribute, AttributeSystem attributeHolder)
{
this.parentAttribute = attributeHolder.GetComposableAttribute(targetAttribute);
if (this.parentAttribute is null)
{
throw new ArgumentException($"Target attribute [{targetAttribute}] is not composable", nameof(targetAttribute));
}
this.element = element;
this.parentAttribute.AddElement(this);
this.element.ValueChanged += this.OnValueChanged;
}
private IEnumerable <PowerUpWrapper> GetBasePowerUpWrappers(Item item, AttributeSystem attributeHolder, ItemBasePowerUpDefinition attribute)
{
yield return(new PowerUpWrapper(attribute.BaseValueElement, attribute.TargetAttribute, attributeHolder));
if (item.Level == 0)
{
yield break;
}
var levelBonus = (attribute.BonusPerLevel ?? Enumerable.Empty <LevelBonus>()).FirstOrDefault(bonus => bonus.Level == item.Level);
if (levelBonus != null)
{
yield return(new PowerUpWrapper(levelBonus.AdditionalValueElement, attribute.TargetAttribute, attributeHolder));
}
}
public void Instance()
{
if (_CopyType == true)
{
Component _source = GetComponent(typeof(AttributeSystem));
// 同樣先取得 Component 的 Type
Type _type = _source.GetType();
GameObject _attribute_object = new GameObject(_NamePrefix);
_attribute_object.transform.position = transform.position;
_attribute_object.transform.parent = transform.parent;
// 先把這個類型的初始 Component 加到物件上
Component _target = _attribute_object.AddComponent(_type);
// 使用 Reflection 取得此 Type 上的所有 Fields
FieldInfo[] _fields = _type.GetFields();
foreach (FieldInfo _field in _fields)
{
// 把來源 Component 上的所有 Field 數值設定到目標 Component 上
_field.SetValue(_target, _field.GetValue(_source));
}
if (_ColliderType == ColliderType.None)
{
return;
}
if (_ColliderType == ColliderType.Box)
{
AttributeSystem _attribute_system = _attribute_object.GetComponent <AttributeSystem>();
_attribute_object.AddComponent <BoxCollider>().isTrigger = true;
_attribute_system._BoxCollider = _attribute_object.GetComponent <BoxCollider>();
return;
}
if (_ColliderType == ColliderType.Sphere)
{
AttributeSystem _attribute_system = _attribute_object.GetComponent <AttributeSystem>();
_attribute_object.AddComponent <SphereCollider>().isTrigger = true;
_attribute_system._SphereCollider = _attribute_object.GetComponent <SphereCollider>();
return;
}
return;
}
if (_CopyType == false)
{
GameObject _attribute_object = new GameObject(_NamePrefix, typeof(AttributeSystem));
_attribute_object.transform.position = transform.position;
_attribute_object.transform.parent = transform.parent;
return;
}
}
/// <inheritdoc/>
public IEnumerable <PowerUpWrapper> GetPowerUps(Item item, AttributeSystem attributeHolder)
{
if (item.Durability <= 0)
{
yield break;
}
if (item.ItemSlot < InventoryConstants.FirstEquippableItemSlotIndex || item.ItemSlot > InventoryConstants.LastEquippableItemSlotIndex)
{
yield break;
}
if (item.Definition != null)
{
foreach (var attribute in item.Definition.BasePowerUpAttributes)
{
yield return(new PowerUpWrapper(attribute.BaseValueElement, attribute.TargetAttribute, attributeHolder));
if (item.Level > 0)
{
var levelBonus = (attribute.BonusPerLevel ?? Enumerable.Empty <LevelBonus>()).FirstOrDefault(bonus => bonus.Level == item.Level);
if (levelBonus != null)
{
yield return(new PowerUpWrapper(levelBonus.AdditionalValueElement, attribute.TargetAttribute, attributeHolder));
}
}
}
foreach (var powerUp in this.GetPowerUpsOfItemOptions(item, attributeHolder))
{
yield return(powerUp);
}
}
////// TODO: Sockets...
////if (item.AppliedSockets != null)
////{
//// foreach (var socket in item.AppliedSockets)
//// {
//// yield return socket.Definition.PowerUp;
//// }
////}
}
private IEnumerable <PowerUpWrapper> GetPowerUpsOfItemOptions(Item item, AttributeSystem attributeHolder)
{
var options = item.ItemOptions;
if (options == null)
{
yield break;
}
foreach (var optionLink in options)
{
var option = optionLink.ItemOption;
var powerUp = option.PowerUpDefinition;
var level = option.LevelType == LevelType.ItemLevel ? item.Level : optionLink.Level;
if (level > 1)
{
var optionOfLevel = option.LevelDependentOptions.FirstOrDefault(l => l.Level == level);
if (optionOfLevel == null)
{
Log.Warn($"Item has {nameof(IncreasableItemOption)} with level > 0, but no definition in {nameof(IncreasableItemOption.LevelDependentOptions)}");
continue;
}
powerUp = optionOfLevel.PowerUpDefinition;
}
if (powerUp?.Boost == null)
{
// Some options are level dependent. If they are at level 0, they might not have any boost yet.
continue;
}
foreach (var wrapper in PowerUpWrapper.CreateByPowerUpDefinition(powerUp, attributeHolder))
{
yield return(wrapper);
}
}
}
/// <inheritdoc/>
public IEnumerable <PowerUpWrapper> GetSetPowerUps(IEnumerable <Item> equippedItems, AttributeSystem attributeHolder)
{
var itemGroups = equippedItems
.Where(i => i.Durability > 0)
.Where(i => i.ItemSetGroups != null)
.SelectMany(i => i.ItemSetGroups)
.Distinct();
var result = Enumerable.Empty <PowerUpDefinition>();
foreach (var group in itemGroups)
{
if (group.AlwaysApplies)
{
result = result.Concat(group.Options.Select(o => o.PowerUpDefinition));
continue;
}
var itemsOfGroup = equippedItems.Where(i => group.SetLevel == 0 || i.Level == group.SetLevel).Select(i => i.Definition);
var itemCount = group.CountDistinct ? itemsOfGroup.Distinct().Count() : itemsOfGroup.Count();
if (itemCount >= group.MinimumItemCount)
{
result = result.Concat(group.Options.Take(itemCount - 1).Select(o => o.PowerUpDefinition));
}
}
return(result.SelectMany(p => PowerUpWrapper.CreateByPowerUpDefintion(p, attributeHolder)));
}
public EnumAttribute(AttributeSystem <RPGAttributeExample> parent, AttributeConfig <RPGAttributeExample> config) :
base(parent, config)
{
}
/// <summary>
/// Creates elements by a <see cref="PowerUpDefinition"/>.
/// </summary>
/// <param name="powerUpDef">The power up definition.</param>
/// <param name="attributeHolder">The attribute holder.</param>
/// <returns>The elements which represent the power-up.</returns>
public static IEnumerable <PowerUpWrapper> CreateByPowerUpDefinition(PowerUpDefinition powerUpDef, AttributeSystem attributeHolder)
{
if (powerUpDef.Boost?.ConstantValue != null)
{
yield return(new PowerUpWrapper(
powerUpDef.Boost.ConstantValue,
powerUpDef.TargetAttribute ?? throw Error.NotInitializedProperty(powerUpDef, nameof(PowerUpDefinition.TargetAttribute)),
attributeHolder));
}
if (powerUpDef.Boost?.RelatedValues != null)
{
foreach (var relationship in powerUpDef.Boost.RelatedValues)
{
yield return(new PowerUpWrapper(
attributeHolder.CreateRelatedAttribute(relationship, attributeHolder),
powerUpDef.TargetAttribute ?? throw Error.NotInitializedProperty(powerUpDef, nameof(PowerUpDefinition.TargetAttribute)),
attributeHolder));
}
}
}
private IEnumerable <PowerUpWrapper> GetPowerUpsOfItemOptions(IEnumerable <ItemOptionLink> options, AttributeSystem attributeHolder)
{
if (options == null)
{
yield break;
}
foreach (var optionLink in options)
{
var option = optionLink.ItemOption;
var powerUp = option.PowerUpDefinition;
if (optionLink.Level > 1)
{
var levelRelated = option as IncreasableItemOption;
var optionOfLevel = levelRelated?.LevelDependentOptions.FirstOrDefault(l => l.Level == optionLink.Level);
if (optionOfLevel == null)
{
// TODO: Log, this should never happen.
continue;
}
powerUp = optionOfLevel.PowerUpDefinition;
}
foreach (var wrapper in PowerUpWrapper.CreateByPowerUpDefintion(powerUp, attributeHolder))
{
yield return(wrapper);
}
}
}
/// <summary>
/// Creates elements by a power up defintion.
/// </summary>
/// <param name="powerUpDef">The power up definition.</param>
/// <param name="attributeHolder">The attribute holder.</param>
/// <returns>The elements which represent the powerup.</returns>
public static IEnumerable <PowerUpWrapper> CreateByPowerUpDefintion(PowerUpDefinition powerUpDef, AttributeSystem attributeHolder)
{
if (powerUpDef.Boost.ConstantValue != null)
{
yield return(new PowerUpWrapper(powerUpDef.Boost.ConstantValue, powerUpDef.TargetAttribute, attributeHolder));
}
if (powerUpDef.Boost.RelatedValues != null)
{
foreach (var relationship in powerUpDef.Boost.RelatedValues)
{
yield return(new PowerUpWrapper(attributeHolder.CreateRelatedAttribute(relationship, attributeHolder), powerUpDef.TargetAttribute, attributeHolder));
}
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
_a_s = target as AttributeSystem;
if (_a_s._Mode == AttributeSystem.Mode.Enable)
{
if (GUILayout.Button("關閉編輯"))
{
_a_s._Mode = AttributeSystem.Mode.Disable;
return;
}
_a_s._NamePrefix = EditorGUILayout.TextField("標題名稱", _a_s._NamePrefix);
if (GUILayout.Button("實例化物件"))
{
_a_s.Instance();
}
_a_s._CopyType = EditorGUILayout.Toggle("複製實例化參數數值", _a_s._CopyType);
_a_s._ColliderType = (AttributeSystem.ColliderType)EditorGUILayout.EnumPopup("觸發器選擇", _a_s._ColliderType);
if (_a_s._ColliderType == AttributeSystem.ColliderType.None)
{
_a_s._AttributeMode = AttributeSystem.AttributeMode.None;
return;
}
if (GUILayout.Button("生成觸發器"))
{
_a_s.AddCollider();
}
if (GUILayout.Button("刪除觸發器"))
{
_a_s.DeleteCollider();
}
_a_s._ColliderColor = EditorGUILayout.ColorField("觸發器顏色", _a_s._ColliderColor);
if (_a_s._ColliderType == AttributeSystem.ColliderType.Box)
{
_a_s._BoxCollider = EditorGUILayout.ObjectField("方塊觸發器", _a_s._BoxCollider, typeof(BoxCollider), true) as BoxCollider;
_a_s._BoxSize = EditorGUILayout.Vector3Field("方塊觸發器大小", _a_s._BoxSize);
}
else if (_a_s._ColliderType == AttributeSystem.ColliderType.Sphere)
{
_a_s._SphereCollider = EditorGUILayout.ObjectField("圓球觸發器", _a_s._SphereCollider, typeof(SphereCollider), true) as SphereCollider;
_a_s._SphereRadius = EditorGUILayout.FloatField("圓球觸發器大小", _a_s._SphereRadius);
}
_a_s._AttributeMode = (AttributeSystem.AttributeMode)EditorGUILayout.EnumPopup("屬性模式改變", _a_s._AttributeMode);
if (_a_s._AttributeMode == AttributeSystem.AttributeMode.None)
{
return;
}
if (_a_s._AttributeMode == AttributeSystem.AttributeMode.Gravity)
{
_a_s._ConstantForceValue = EditorGUILayout.Vector3Field("恆力設置", _a_s._ConstantForceValue);
_a_s._Disposable = EditorGUILayout.Toggle("一次性觸發", _a_s._Disposable);
return;
}
if (_a_s._AttributeMode == AttributeSystem.AttributeMode.Force)
{
_a_s._ForceValue = EditorGUILayout.FloatField("力道設置", _a_s._ForceValue);
_a_s._Direction = (AttributeSystem.Direction)EditorGUILayout.EnumPopup("方向性", _a_s._Direction);
if (_a_s._Direction == AttributeSystem.Direction.Customize)
{
_a_s._ForceDirectionValue = EditorGUILayout.Vector3Field("自定義方向設置", _a_s._ForceDirectionValue);
}
return;
}
if (_a_s._AttributeMode == AttributeSystem.AttributeMode.Velocity)
{
_a_s._VelocityValue = EditorGUILayout.Vector3Field("速率設置", _a_s._VelocityValue);
return;
}
}
if (_a_s._Mode == AttributeSystem.Mode.Disable)
{
if (GUILayout.Button("開啟編輯"))
{
_a_s._Mode = AttributeSystem.Mode.Enable;
return;
}
}
}
protected override void OnInit(GameObject obj)
{
attr = obj.GetComponent <AttributeSystem>();
}
/// <inheritdoc/>
public IEnumerable <PowerUpWrapper> GetSetPowerUps(IEnumerable <Item> equippedItems, AttributeSystem attributeHolder)
{
var activeItems = equippedItems
.Where(i => i.Durability > 0)
.Where(i => i.ItemSetGroups != null)
.ToList();
var itemGroups = activeItems
.SelectMany(i => i.ItemSetGroups)
.Distinct();
var result = Enumerable.Empty <PowerUpDefinition>();
foreach (var group in itemGroups)
{
if (group.AlwaysApplies)
{
result = result.Concat(group.Options.Select(o => o.PowerUpDefinition));
continue;
}
if (group.SetLevel > 0 && group.MinimumItemCount == group.Items.Count && activeItems.All(i => i.Level > group.SetLevel))
{
// When all items are of higher level and the set bonus is applied when all items are there, another item set group will take care.
// This should prevent that for example set bonus defense is applied multiple times.
continue;
}
var itemsOfGroup = activeItems.Where(i => group.SetLevel == 0 || i.Level >= group.SetLevel).Select(i => i.Definition).ToList();
// The set item bonus options are always given, regardless if the set is complete or not.
result = result.Concat(group.Items.Where(i => i.BonusOption != null && itemsOfGroup.Contains(i.ItemDefinition)).Select(i => i.BonusOption.PowerUpDefinition));
var itemCount = group.CountDistinct ? itemsOfGroup.Distinct().Count() : itemsOfGroup.Count;
if (itemCount >= group.MinimumItemCount)
{
result = result.Concat(group.Options.OrderBy(o => o.Number).Take(itemCount - 1).Select(o => o.PowerUpDefinition));
}
}
return(result.SelectMany(p => PowerUpWrapper.CreateByPowerUpDefinition(p, attributeHolder)));
}
