架构大更

This commit is contained in:
SoulliesOfficial
2026-03-20 11:56:50 -04:00
parent e60ef64d01
commit d09b58fd80
3663 changed files with 15232012 additions and 105579 deletions

View File

@@ -5,42 +5,37 @@ using Continentis.MainGame.Character;
using Continentis.MainGame.Equipment;
using SLSFramework.General;
using SLSFramework.UModAssistance;
using UniRx;
using UnityEngine;
namespace Continentis.MainGame.Card
{
public abstract partial class CardLogicBase
{
[Header("Reference")]
[Header("Reference")]
public CardInstance card;
public CardData cardData => card.cardData;
public CharacterBase user => card.user;
public HashSet<CardLogicComponentBase> logicComponents { get; private set; }
/// <summary>
/// 生成卡牌逻辑实例
/// </summary>
/// <summary>生成卡牌逻辑实例。</summary>
public static CardLogicBase GenerateCardLogic(CardData data)
{
string typeID = ModManager.GetTypeID(data.modName, "Cards", data.categoryName, data.className);
Type logicType = ModManager.GetType(typeID);
if(logicType == null)
if (logicType == null)
{
Debug.LogError($"Card class '{typeID}' not found in assemblies.");
return null;
}
if (Activator.CreateInstance(logicType) is CardLogicBase cardLogic)
{
return cardLogic;
}
Debug.LogError($"Card class '{typeID}' not found or could not be instantiated.");
return null;
}
public virtual void Initialize(CardInstance cardInstance)
{
card = cardInstance;
@@ -49,11 +44,8 @@ namespace Continentis.MainGame.Card
card.eventSubmodule.onUntargeting += UntargetingEffect;
}
public virtual void SetUpLogicComponents()
{
}
public virtual void SetUpLogicComponents() { }
public T AddLogicComponent<T>() where T : CardLogicComponentBase, new()
{
if (logicComponents.Any(component => component is T))
@@ -61,178 +53,171 @@ namespace Continentis.MainGame.Card
Debug.LogWarning($"Card {card.cardData.className} already has component of type {typeof(T)}, cannot add duplicate.");
return null;
}
else
{
T component = new T();
component.Initialize(this);
logicComponents.Add(component);
return component;
}
T component = new T();
component.Initialize(this);
logicComponents.Add(component);
return component;
}
public T LogicComponent<T>() where T : CardLogicComponentBase
{
return logicComponents.OfType<T>().FirstOrDefault();
}
public virtual void ApplyAttributeChangesByCard()
public virtual void ApplyAttributeChangesByCard() { }
/// <summary>卡牌出牌效果,返回一个 CommandGroup 供队列执行。</summary>
public virtual CommandGroup PlayEffect(List<CharacterBase> targetList)
{
}
public virtual List<CommandBase> PlayEffect(List<CharacterBase> targetList)
{
return null;
return new CommandGroup();
}
public virtual void AfterPlayEffect(List<CharacterBase> targetList)
{
}
public virtual void AfterPlayEffect(List<CharacterBase> targetList) { }
}
#region Attributes
#region Attributes
public partial class CardLogicBase
{
/// <summary>
/// 设置可变属性值
/// </summary>
/// <param name="attributeName">属性名,通常为</param>
/// <param name="additive">是否为叠加true为叠加false为覆盖true时originalValue为外部传入值</param>
/// <param name="originalValue">原始伤害值仅在additive为true时有效否则此值被覆盖为BaseAttribute</param>
/// <param name="baseOffset">伤害增量</param>
/// <summary>设置可变属性值。</summary>
public void SetVariableAttribute(string attributeName, int baseOffset, bool additive = false, int originalValue = 0)
{
card.SetVariableAttribute(attributeName, baseOffset, additive, originalValue);
}
/// <summary>
/// 检查卡牌是否具有某属性
/// </summary>
public bool HasAttribute(string attributeName)
{
return card.HasAttribute(attributeName);
}
/// <summary>
/// 获取卡牌的属性值
/// </summary>
public int GetAttribute(string attributeName, int defaultValue = 0)
{
return card.GetAttribute(attributeName, defaultValue);
}
public float GetRawAttribute(string attributeName, float defaultValue = 0)
{
return card.GetRawAttribute(attributeName, defaultValue);
}
/// <summary>
/// 设置卡牌的属性值
/// </summary>
public void SetAttribute(string attributeName, int value)
{
card.SetAttribute(attributeName, value);
}
/// <summary>
/// 设置卡牌的属性值
/// </summary>
public void SetAttribute(string attributeName, float value)
{
card.SetAttribute(attributeName, value);
}
/// <summary>
/// 修改卡牌的属性值
/// </summary>
public void ModifyAttribute(string attributeName, int delta)
{
card.ModifyAttribute(attributeName, delta);
card.SetVariableAttribute(attributeName, baseOffset, additive, originalValue);
}
/// <summary>检查卡牌是否具有某属性。</summary>
public bool HasAttribute(string attributeName) => card.HasAttribute(attributeName);
/// <summary>获取卡牌的属性值。</summary>
public int GetAttribute(string attributeName, int defaultValue = 0) => card.GetAttribute(attributeName, defaultValue);
public float GetRawAttribute(string attributeName, float defaultValue = 0) => card.GetRawAttribute(attributeName, defaultValue);
/// <summary>设置卡牌的属性值int。</summary>
public void SetAttribute(string attributeName, int value) => card.SetAttribute(attributeName, value);
/// <summary>设置卡牌的属性值float。</summary>
public void SetAttribute(string attributeName, float value) => card.SetAttribute(attributeName, value);
/// <summary>修改卡牌的属性值。</summary>
public void ModifyAttribute(string attributeName, int delta) => card.ModifyAttribute(attributeName, delta);
}
#endregion
#region Command
#region Command
public partial class CardLogicBase
{
// ── 新 API闭包工厂推荐Mod 制作者优先使用) ─────────────────────
/// <summary>
/// 创建一个命令组,组内命令按顺序执行
/// 对 targetList 中的每个目标调用工厂 lambda生成的命令按 mainExecutionMode 组合。
/// </summary>
protected CommandGroup ForEachTarget(
List<CharacterBase> targetList,
Func<CharacterBase, CommandBase> factory,
ExecutionMode mainExecutionMode = ExecutionMode.Sequential)
{
var group = new CommandGroup(mainExecutionMode);
foreach (CharacterBase target in targetList)
{
CharacterBase captured = target;
group.AddCommand(factory(captured));
}
return group;
}
/// <summary>
/// 对 targetList 中的每个目标调用工厂 lambda生成的 CommandGroup 按 mainExecutionMode 组合。
/// </summary>
protected CommandGroup ForEachTarget(
List<CharacterBase> targetList,
Func<CharacterBase, CommandGroup> factory,
ExecutionMode mainExecutionMode = ExecutionMode.Sequential)
{
var group = new CommandGroup(mainExecutionMode);
foreach (CharacterBase target in targetList)
{
CharacterBase captured = target;
group.AddCommand(factory(captured));
}
return group;
}
// ── 旧 API模板 Clone 模式(保留供向后兼容,后续迁移完成后移除) ──
/// <summary>
/// 克隆命令模板列表,组合为单个并行 CommandGroup。
/// </summary>
/// <param name="commands">命令模板</param>
protected CommandGroup SingleCommandGroup(params CommandBase[] commands)
{
return SingleCommandGroup(ExecutionMode.Parallel, commands);
}
/// <summary>
/// 创建一个命令组,组内命令按指定顺序执行
/// 克隆命令模板列表,按 executionMode 组合为单个 CommandGroup。
/// </summary>
/// <param name="executionMode">执行模式,顺序或并行</param>
/// <param name="commands">命令模板</param>
protected virtual CommandGroup SingleCommandGroup(
ExecutionMode executionMode = ExecutionMode.Parallel, params CommandBase[] commands)
{
CommandGroup singleGroup = new CommandGroup(executionMode);
var group = new CommandGroup(executionMode);
foreach (CommandBase template in commands)
{
singleGroup.AddCommand(template.Clone());
}
return singleGroup;
group.AddCommand(template.Clone());
return group;
}
/// <summary>
/// 对目标列表中的每个目标依次执行一组有参函数命令每组命令的参数为targetList中的个体主体Group顺序执行单体Group并行执行
/// 对目标列表中的每个目标克隆命令模板并注入 Target生成嵌套 CommandGroup。
/// 新代码请改用 <see cref="ForEachTarget"/> 闭包工厂模式。
/// </summary>
/// <param name="targetList">目标列表</param>
/// <param name="singleCommands">单体命令模板</param>
protected CommandGroup TargetListCommandGroup(List<CharacterBase> targetList,
[Obsolete("请改用 ForEachTarget(targetList, target => ...) 闭包工厂模式。")]
protected CommandGroup TargetListCommandGroup(
List<CharacterBase> targetList,
params CommandBase[] singleCommands)
{
return TargetListCommandGroup(targetList, ExecutionMode.Sequential, ExecutionMode.Parallel,
singleCommands);
return TemplateTargetGroup(targetList, ExecutionMode.Sequential, ExecutionMode.Parallel, singleCommands);
}
/// <summary>
/// 对目标列表中的每个目标依次执行一组有参函数命令每组命令的参数为targetList中的个体
/// 对目标列表中的每个目标克隆命令模板并注入 Target生成嵌套 CommandGroup
/// 新代码请改用 <see cref="ForEachTarget"/> 闭包工厂模式。
/// </summary>
/// <param name="targetList">目标列表</param>
/// <param name="mainExecutionMode">主体Group各个目标的执行顺序</param>
/// <param name="singleExecutionMode">单体Group一个目标中指令的执行顺序</param>
/// <param name="singleCommands">单体命令模板</param>
[Obsolete("请改用 ForEachTarget(targetList, target => ...) 闭包工厂模式。")]
protected virtual CommandGroup TargetListCommandGroup(
List<CharacterBase> targetList, ExecutionMode mainExecutionMode = ExecutionMode.Sequential,
List<CharacterBase> targetList,
ExecutionMode mainExecutionMode = ExecutionMode.Sequential,
ExecutionMode singleExecutionMode = ExecutionMode.Parallel,
params CommandBase[] singleCommands)
{
CommandGroup mainGroup = new CommandGroup(mainExecutionMode);
return TemplateTargetGroup(targetList, mainExecutionMode, singleExecutionMode, singleCommands);
}
/// <summary>
/// 模板 Clone 模式的底层实现,供旧代码向后兼容。
/// 克隆每条模板命令并向所有子命令的 selfContext 注入 Target。
/// </summary>
protected virtual CommandGroup TemplateTargetGroup(
List<CharacterBase> targetList,
ExecutionMode mainExecutionMode = ExecutionMode.Sequential,
ExecutionMode singleExecutionMode = ExecutionMode.Parallel,
params CommandBase[] singleCommands)
{
var mainGroup = new CommandGroup(mainExecutionMode);
foreach (CharacterBase target in targetList)
{
CommandGroup singleGroup = new CommandGroup(singleExecutionMode);
var singleGroup = new CommandGroup(singleExecutionMode);
foreach (CommandBase template in singleCommands)
{
CommandBase clone = template.Clone();
List<CommandBase> allCommands = new List<CommandBase>();
if (clone is CommandGroup group)
{
allCommands.AddRange(group.GetAllCommands(true));
}
else
{
allCommands.Add(clone);
}
// 收集所有子命令(含嵌套组内的命令)并注入 Target
var allCommands = clone is CommandGroup group
? group.GetAllCommands(true)
: new List<CommandBase> { clone };
foreach (CommandBase cmd in allCommands)
{
cmd.selfContext.context["Target"] = target;
}
cmd.selfContext.Set(CommandContextKeys.Target, target);
singleGroup.AddCommand(clone);
}
@@ -244,76 +229,55 @@ namespace Continentis.MainGame.Card
}
}
#endregion
#region Attack
public partial class CardLogicBase
{
/// <summary>
/// 获取最终伤害
/// </summary>
/// <param name="target">目标</param>
/// <param name="elementalTags">元素标签若为null则使用卡牌的元素标签</param>
/// <summary>获取对指定目标的最终伤害值。</summary>
public virtual int GetTargetedFinalDamage(CharacterBase target, List<string> elementalTags = null)
{
return GetFinalDamage(target, elementalTags, out _, out _, out _, out _);
}
/// <summary>
/// 获取最终伤害
/// </summary>
/// <param name="elementalTags">元素标签若为null则使用卡牌的元素标签</param>
/// <summary>获取无目标时的最终伤害值。</summary>
public virtual int GetNoTargetFinalDamage(List<string> elementalTags = null)
{
return GetFinalDamage(null, elementalTags, out _, out _, out _, out _);
}
protected virtual int GetFinalDamage(CharacterBase target, List<string> elementalTags,
out float baseDamageAfterOffset, out float elementalMultiplier,
protected virtual int GetFinalDamage(
CharacterBase target, List<string> elementalTags,
out float baseDamageAfterOffset, out float elementalMultiplier,
out float magicMultiplier, out float finalMultiplier)
{
bool haveTarget = target != null;
elementalTags ??= card.GetElementalKeywords();
//----计算基础伤害增量----
int physicsOffset = 0;
if (card.HasKeyword("Physics") || card.HasKeyword("Slash") || card.HasKeyword("Prick") || card.HasKeyword("Strike"))
{
physicsOffset = user.GetAttribute("PhysicsDamageDealtOffset"); //物理伤害基础增量
}
physicsOffset = user.GetAttribute("PhysicsDamageDealtOffset");
int magicOffset = 0;
if (card.HasKeyword("Magic") || card.HasKeyword("Arcane") || card.HasKeyword("Sorcery"))
{
magicOffset = user.GetAttribute("MagicDamageDealtOffset"); //魔法伤害基础增量
}
magicOffset = user.GetAttribute("MagicDamageDealtOffset");
//----计算伤害因数----
//计算元素伤害加成注意“物理Physics”也是一种元素因此下方没有“通用物理伤害加成”的计算
elementalMultiplier = 1;
elementalMultiplier = 1f;
foreach (string element in elementalTags)
{
float targetGain = haveTarget ? target.GetRawAttribute(element + "DamageGainMultiplier", 1) : 1;
elementalMultiplier *= user.GetRawAttribute(element + "DamageDealtMultiplier", 1) * targetGain;
float targetGain = haveTarget ? target.GetRawAttribute(element + "DamageGainMultiplier", 1f) : 1f;
elementalMultiplier *= user.GetRawAttribute(element + "DamageDealtMultiplier", 1f) * targetGain;
}
//计算通用的魔法伤害加成
magicMultiplier = 1;
magicMultiplier = 1f;
if (card.HasKeyword("Magic") || card.HasKeyword("Arcane") || card.HasKeyword("Sorcery"))
{
float targetGain = haveTarget ? target.GetRawAttribute("MagicDamageGainMultiplier", 1) : 1;
magicMultiplier = user.GetRawAttribute("MagicDamageDealtMultiplier", 1) * targetGain;
float targetGain = haveTarget ? target.GetRawAttribute("MagicDamageGainMultiplier", 1f) : 1f;
magicMultiplier = user.GetRawAttribute("MagicDamageDealtMultiplier", 1f) * targetGain;
}
//计算最终伤害加成
float targetFinalGain = haveTarget ? target.GetRawAttribute("FinalDamageGainMultiplier", 1) : 1;
finalMultiplier = user.GetRawAttribute("FinalDamageDealtMultiplier", 1) * targetFinalGain;
//----计算最终伤害----
float targetFinalGain = haveTarget ? target.GetRawAttribute("FinalDamageGainMultiplier", 1f) : 1f;
finalMultiplier = user.GetRawAttribute("FinalDamageDealtMultiplier", 1f) * targetFinalGain;
baseDamageAfterOffset = card.attributeSubmodule.GetCurrentAttribute("Damage") + physicsOffset + magicOffset;
float finalDamage = baseDamageAfterOffset * elementalMultiplier * magicMultiplier * finalMultiplier;
@@ -325,123 +289,85 @@ namespace Continentis.MainGame.Card
#region Buffs
public partial class CardLogicBase
{
/// <summary>
/// 创建一个角色战斗Buff实例
/// 注意此函数依赖ModManager的类型注册功能请确保在Mod加载时已注册对应Buff类型
/// 此函数中的T并不是原型参数而是获取Mod中注册的类型用的
/// </summary>
public T CreateCharacterBuff<T>(params object[] parameters) where T :CharacterCombatBuffBase
/// <summary>创建一个角色战斗 Buff 实例(通过 ModManager 类型注册)。</summary>
public T CreateCharacterBuff<T>(params object[] parameters) where T : CharacterCombatBuffBase
{
string buffTypeID = ModManager.GetTypeID(typeof(T));
if (string.IsNullOrEmpty(buffTypeID))
{
Debug.LogError($"Failed to get buff name for type {typeof(T).FullName}");
return null;
}
return ModManager.CreateInstance<T>(buffTypeID, parameters);
}
public T CreateCharacterBuff<T>(string buffTypeID, params object[] parameters) where T :CharacterCombatBuffBase
public T CreateCharacterBuff<T>(string buffTypeID, params object[] parameters) where T : CharacterCombatBuffBase
{
if (string.IsNullOrEmpty(buffTypeID))
{
Debug.LogError($"Failed to get buff name for type {typeof(T).FullName}");
return null;
}
return ModManager.CreateInstance<T>(buffTypeID, parameters);
}
/// <summary>
/// 创建一个卡牌战斗Buff实例
/// 注意此函数依赖ModManager的类型注册功能请确保在Mod加载时已注册对应Buff类型
/// 此函数中的T并不是原型参数而是获取Mod中注册的类型用的
/// </summary>
public T CreateCardBuff<T>(params object[] parameters) where T :CardBuffBase
/// <summary>创建一个卡牌战斗 Buff 实例(通过 ModManager 类型注册)。</summary>
public T CreateCardBuff<T>(params object[] parameters) where T : CardBuffBase
{
string buffTypeID = ModManager.GetTypeID(typeof(T));
if (string.IsNullOrEmpty(buffTypeID))
{
Debug.LogError($"Failed to get buff name for type {typeof(T).FullName}");
return null;
}
return ModManager.CreateInstance<T>(buffTypeID, parameters);
}
public T CreateCardBuff<T>(string buffTypeID, params object[] parameters) where T :CardBuffBase
public T CreateCardBuff<T>(string buffTypeID, params object[] parameters) where T : CardBuffBase
{
if (string.IsNullOrEmpty(buffTypeID))
{
Debug.LogError($"Failed to get buff name for type {typeof(T).FullName}");
return null;
}
return ModManager.CreateInstance<T>(buffTypeID, parameters);
}
}
#endregion
public abstract partial class CardLogicBase
{
/// <summary>
/// 获取衍生卡牌数据
/// </summary>
/// <summary>获取衍生卡牌数据(按索引)。</summary>
public CardData GetDerivativeCardData(int index)
{
return ModManager.GetData<CardData>(cardData.derivativeCardDataRefs[index]);
}
/// <summary>
/// 获取衍生卡牌数据
/// </summary>
/// <summary>获取衍生卡牌数据(按名称)。</summary>
public CardData GetDerivativeCardData(string dataName)
{
if (cardData.derivativeCardDataRefs.Contains(dataName))
{
return ModManager.GetData<CardData>(dataName);
}
Debug.LogError($"Card {cardData.className} does not contain derivative card data '{dataName}'.");
return null;
}
/// <summary>
/// 选中目标时触发的效果效果在所有逻辑组件的Targeting之前执行在SetUp函数生成EventSubmodule的时候
/// 如果必须需要在逻辑组件之后执行请重写Initialize函数。
/// </summary>
public virtual void TargetingEffect(CharacterBase target)
{
}
/// <summary>
/// 取消选中目标时触发的效果效果在所有逻辑组件的Untargeting之前执行在SetUp函数生成EventSubmodule的时候
/// 如果必须需要在逻辑组件之后执行请重写Initialize函数。
/// </summary>
public virtual void UntargetingEffect()
{
}
/// <summary>选中目标时触发的效果(在逻辑组件的 Targeting 之前执行)。</summary>
public virtual void TargetingEffect(CharacterBase target) { }
/// <summary>取消选中目标时触发的效果(在逻辑组件的 Untargeting 之前执行)。</summary>
public virtual void UntargetingEffect() { }
}
/// <summary>
/// 卡牌逻辑组件基类接口
/// 注意,所有的子接口需要实现的函数:
/// ComponentTargetingEffect此牌瞄准目标时调用
/// ComponentUntargetingEffect此牌取消瞄准目标时调用
/// </summary>
/// <summary>卡牌逻辑组件基类。</summary>
public abstract class CardLogicComponentBase
{
protected CardLogicBase mainLogic;
protected CardInstance card => mainLogic.card;
protected CharacterBase user => card.user;
protected CombatTeam usingTeam => card.usingTeam;
public virtual void Initialize(CardLogicBase card)
{
this.mainLogic = card;
@@ -449,14 +375,8 @@ namespace Continentis.MainGame.Card
this.card.eventSubmodule.onUntargeting += UntargetingEffect;
}
protected virtual void TargetingEffect(CharacterBase target)
{
}
protected virtual void TargetingEffect(CharacterBase target) { }
protected virtual void UntargetingEffect()
{
}
protected virtual void UntargetingEffect() { }
}
}
}