chore: initialize OshimaBot repository (rename from Enhancement)

This commit is contained in:
2026-11-09 19:38:28 +08:00
commit f9052358a9
414 changed files with 36653 additions and 0 deletions
@@ -0,0 +1,231 @@
using FunGame.Core.Api;
using FunGame.Core.Entity;
using FunGame.Core.Library.Constant;
using FunGame.Core.Model.EffectContext;
using FunGame.Core.Model.EffectResult;
namespace OshimaBot.Content.Skills
{
public class 概念之骰 : Skill
{
public override long Id => (long)PassiveID.概念之骰;
public override string Name => "概念之骰";
public override string Description => Effects.Count > 0 ? ((概念之骰特效)Effects.First()).GeneralDescription : "";
public int 力层数 { get; set; } = 0;
public int 暴层数 { get; set; } = 0;
public int 噬层数 { get; set; } = 0;
public int 御层数 { get; set; } = 0;
public 概念之骰(Character? character = null) : base(SkillType.Passive, character)
{
Effects.Add(new 概念之骰特效(this));
}
public override IEnumerable<Effect> AddPassiveEffectToCharacter()
{
return Effects;
}
public override void OnCharacterRespawn(Skill newSkill)
{
if (newSkill is 概念之骰 skill)
{
skill.力层数 = 力层数;
skill.暴层数 = 暴层数;
skill.噬层数 = 噬层数;
skill.御层数 = 御层数;
}
}
}
public class 概念之骰特效 : Effect
{
public override long Id => Skill.Id;
public override string Name => Skill.Name;
public override string Description { get; set; } = "";
public string GeneralDescription => $"{Skill.SkillOwner()}的助攻窗口期永远不会过期。{Skill.SkillOwner()}每次参与击杀时都会进行一次概念投掷,获得一层永久持续的增益效果,且每个概念都最多可以叠加 {最多层数} 层。每次概念投掷可取得以下任意一项概念增益:\r\n" +
$"「力」:攻击力提升 {攻击力提升 * 100:0.##}% [ {Skill.Character?.BaseATK * 攻击力提升:0.##} ]。\r\n「暴」:暴击率提升 {暴击率提升 * 100:0.##}%,暴击伤害提升 {暴击伤害提升 * 100:0.##}%。\r\n「噬」:生命偷取提升 {生命偷取提升 * 100:0.##}%。\r\n「御」:受到的伤害减少 {攻击力提升 * 100:0.##}%。\r\n" +
$"取得第一层「噬」后,同时获得「恒」效果:当总生命偷取超过 {生命偷取阈值 * 100:0.##}% 后,超出部分每 {生命偷取每单位 * 100:0.##}% 转化为 {生命偷取转化 * 100:0.##}% 攻击力。";
public static int 最多层数 => 8;
public static double 攻击力提升 => 0.06;
public static double 暴击率提升 => 0.03;
public static double 暴击伤害提升 => 0.06;
public static double 生命偷取提升 => 0.04;
public static double 受到伤害减少 => 0.05;
public static double 生命偷取阈值 => 0.3;
public static double 生命偷取每单位 => 0.01;
public static double 生命偷取转化 => 0.005;
private double 实际攻击力提升 = 0;
private double 实际暴击率提升 = 0;
private double 实际暴击伤害提升 = 0;
private double 实际生命偷取提升 = 0;
private double 实际受到伤害减少 = 0;
private double 实际生命偷取转化 = 0;
public 概念之骰特效(Skill skill) : base(skill)
{
Description = GeneralDescription;
}
public override AlterActualDamageResult AlterActualDamageAfterCalculation(DamageContext ctx)
{
if (ctx.Trigger is not Character character || ctx.Enemy is not Character enemy) return default;
double damage = ctx.Damage;
bool isNormalAttack = ctx.IsNormalAttack;
DamageType damageType = ctx.DamageType;
MagicType magicType = ctx.MagicType;
DamageResult damageResult = ctx.DamageResult;
Dictionary<Effect, double> totalDamageBonus = ctx.TotalDamageBonus;
if (enemy == Skill.Character && 实际受到伤害减少 > 0 && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical))
{
double reduce = damage * 实际受到伤害减少;
WriteLine($"[ {Skill.Character} ] 发动了概念之骰!伤害减少了 {reduce:0.##} 点!");
return new AlterActualDamageResult { DamageDelta = -reduce };
}
return default;
}
public override void AfterDeathCalculation(DeathContext ctx)
{
if (ctx.Trigger is not Character death) return;
bool hasMaster = ctx.HasMaster;
Character? killer = ctx.Killer;
Dictionary<Character, int> continuousKilling = ctx.ContinuousKilling;
Dictionary<Character, int> earnedMoney = ctx.EarnedMoney;
Character[] assists = ctx.Assists;
if (Skill.Character != null && death != Skill.Character && !hasMaster && (killer == Skill.Character || assists.Contains(Skill.Character)) && Skill is 概念之骰 skill)
{
WriteLine($"[ {Skill.Character} ] 进行概念投掷:“此乃,神之概念。”");
bool result = false;
do
{
switch (Random.Next(4))
{
case 0:
if (skill.力层数 < 最多层数)
{
skill.力层数++;
WriteLine($"[ {Skill.Character} ] 获得了「力」概念效果,当前「力」层数:{skill.力层数}。");
result = true;
}
break;
case 1:
if (skill.暴层数 < 最多层数)
{
skill.暴层数++;
WriteLine($"[ {Skill.Character} ] 获得了「暴」概念效果,当前「暴」层数:{skill.暴层数}。");
result = true;
}
break;
case 2:
if (skill.噬层数 < 最多层数)
{
skill.噬层数++;
WriteLine($"[ {Skill.Character} ] 获得了「噬」概念效果,当前「噬」层数:{skill.噬层数}。");
result = true;
}
break;
case 3:
if (skill.御层数 < 最多层数)
{
skill.御层数++;
WriteLine($"[ {Skill.Character} ] 获得了「御」概念效果,当前「御」层数:{skill.御层数}。");
result = true;
}
break;
}
if (skill.力层数 + skill.暴层数 + skill.噬层数 + skill.御层数 >= 最多层数 * 4)
{
WriteLine($"[ {Skill.Character} ] 已经完成了「概念之骰」的全部概念收集!!");
result = true;
}
}
while (!result);
if (result)
{
刷新技能效果(Skill.Character);
}
}
}
public override void OnEffectGained(HookContext ctx)
{
if (ctx.Trigger is not Character character) return;
刷新技能效果(character);
}
public override void OnTimeElapsed(TimeLapseContext ctx)
{
if (ctx.Trigger is not Character character) return;
double elapsed = ctx.Elapsed;
刷新技能效果(character);
if (GamingQueue != null && GamingQueue.AssistDetails.TryGetValue(character, out AssistDetail? ad) && ad != null)
{
foreach (Character enemy in ad.DamageLastTime.Keys)
{
ad.DamageLastTime[enemy] = GamingQueue.TotalTime;
}
foreach (Character teammate in ad.NotDamageAssistLastTime.Keys)
{
ad.NotDamageAssistLastTime[teammate] = GamingQueue.TotalTime;
}
}
}
public void 刷新技能效果(Character character)
{
if (实际攻击力提升 != 0)
{
character.ExATKPercentage -= 实际攻击力提升;
实际攻击力提升 = 0;
}
if (实际暴击率提升 != 0)
{
character.ExCritRate -= 实际暴击率提升;
实际暴击率提升 = 0;
}
if (实际暴击伤害提升 != 0)
{
character.ExCritDMG -= 实际暴击伤害提升;
实际暴击伤害提升 = 0;
}
if (实际生命偷取提升 != 0)
{
character.Lifesteal -= 实际生命偷取提升;
实际生命偷取提升 = 0;
}
if (实际受到伤害减少 != 0)
{
实际受到伤害减少 = 0;
}
if (实际生命偷取转化 != 0)
{
character.ExATKPercentage -= 实际生命偷取转化;
实际生命偷取转化 = 0;
}
if (Skill is 概念之骰 skill)
{
实际攻击力提升 = 攻击力提升 * skill.力层数;
实际暴击率提升 = 暴击率提升 * skill.暴层数;
实际暴击伤害提升 = 暴击伤害提升 * skill.暴层数;
实际生命偷取提升 = 生命偷取提升 * skill.噬层数;
实际受到伤害减少 = 受到伤害减少 * skill.御层数;
character.ExATKPercentage += 实际攻击力提升;
character.ExCritRate += 实际暴击率提升;
character.ExCritDMG += 实际暴击伤害提升;
character.Lifesteal += 实际生命偷取提升;
if (skill.噬层数 > 0 && character.Lifesteal > 生命偷取阈值)
{
double 超出部分 = character.Lifesteal - 生命偷取阈值;
实际生命偷取转化 = 超出部分 / 生命偷取每单位 * 生命偷取转化;
}
character.ExATKPercentage += 实际生命偷取转化;
Description = $"{Skill.SkillOwner()}的助攻窗口期永远不会过期。{Skill.SkillOwner()}每次参与击杀时都会进行一次概念投掷,获得一层永久持续的增益效果,且每个概念都最多可以叠加 {最多层数} 层。(当前层数:「力」× {skill.力层数}、「暴」× {skill.暴层数}、「噬」× {skill.噬层数}、「御」× {skill.御层数},攻击力提升:{(实际攻击力提升 + 实际生命偷取转化) * 100:0.##}% [ {character.BaseATK * (实际攻击力提升 + 实际生命偷取转化):0.##} ] 点,暴击率提升:{实际暴击率提升 * 100:0.##}%,暴击伤害提升:{实际暴击伤害提升 * 100:0.##}%,生命偷取提升:{实际生命偷取提升 * 100:0.##}%,受到伤害减少:{实际受到伤害减少 * 100:0.##}%)";
}
}
}
}
@@ -0,0 +1,124 @@
using FunGame.Core.Api;
using FunGame.Core.Entity;
using FunGame.Core.Library.Constant;
using FunGame.Core.Model.EffectContext;
using FunGame.Core.Model.EffectResult;
using FunGame.Core.Model.Framework;
namespace OshimaBot.Content.Skills
{
public class 神之因果 : Skill
{
public override long Id => (long)SuperSkillID.神之因果;
public override string Name => "神之因果";
public override string Description => Effects.Count > 0 ? Effects.First().Description : "";
public override string DispelDescription => Effects.Count > 0 ? Effects.First().DispelDescription : "";
public override double EPCost => 100;
public override bool CostAllEP => true;
public override double CD => 90;
public override double HardnessTime { get; set; } = 1;
public override bool CanSelectSelf => true;
public override bool CanSelectEnemy => false;
public 神之因果(Character? character = null) : base(SkillType.SuperSkill, character)
{
Effects.Add(new 神之因果特效(this));
}
}
public class 神之因果特效(Skill skill) : Effect(skill)
{
public override long Id => Skill.Id;
public override string Name => Skill.Name;
public override string Description => $"{Skill.SkillOwner()}短暂显现其「神」之本质,开启持续 4 回合的「神之领域」:在持续时间内,{Skill.SkillOwner()}对任意敌方目标造成的伤害,都将记录为「因果伤害值」。" +
$"在持续时间结束后,所有敌方角色都会受到 [ 基于总因果伤害值的 {系数 * 100:0.##}% 除以当前在场敌方角色数量 ] 的真实伤害。在持续时间内,{Skill.SkillOwner()}可以对任何负面效果进行豁免。" +
(因果伤害值 > 0 ? $"(当前累计因果:{因果伤害值:0.##} 点)" : "");
public override DispelledType DispelledType => DispelledType.CannotBeDispelled;
public override bool Durative => false;
public override int DurationTurn => 4;
public double 因果伤害值 { get; set; } = 0;
public double 系数 => 1 + 0.2 * (Skill.Level - 1);
public override OnExemptionCheckResult OnExemptionCheck(ImmuneContext ctx)
{
if (ctx.Trigger is not Character character) return default;
if (character == Skill.Character)
{
return new OnExemptionCheckResult { ThrowingBonusDelta = 300 };
}
return default;
}
public override void AfterDamageCalculation(DamageContext ctx)
{
if (ctx.Trigger is not Character character || ctx.Enemy is not Character enemy) return;
double damage = ctx.Damage;
double actualDamage = ctx.ActualDamage;
bool isNormalAttack = ctx.IsNormalAttack;
DamageType damageType = ctx.DamageType;
MagicType magicType = ctx.MagicType;
DamageResult damageResult = ctx.DamageResult;
if (character == Skill.Character && (damageResult == DamageResult.Normal || damageResult == DamageResult.Critical))
{
因果伤害值 += actualDamage;
}
}
public override void AfterDeathCalculation(DeathContext ctx)
{
if (ctx.Trigger is not Character death) return;
bool hasMaster = ctx.HasMaster;
Character? killer = ctx.Killer;
Dictionary<Character, int> continuousKilling = ctx.ContinuousKilling;
Dictionary<Character, int> earnedMoney = ctx.EarnedMoney;
Character[] assists = ctx.Assists;
if (death == Skill.Character)
{
因果伤害值 = 0;
}
}
public override void OnEffectGained(HookContext ctx)
{
if (ctx.Trigger is not Character character) return;
因果伤害值 = 0;
}
public override void OnEffectLost(HookContext ctx)
{
if (ctx.Trigger is not Character character) return;
if (GamingQueue != null && 因果伤害值 > 0)
{
WriteLine($"[ {character} ] 发动了神之因果!万象因果,命运既定!!!");
List<Character> enemies = [.. GamingQueue.GetEnemies(character).Where(GamingQueue.Queue.Contains)];
double damage = 因果伤害值 * 系数 / enemies.Count;
foreach (Character enemy in enemies)
{
DamageToEnemy(character, enemy, DamageType.True, MagicType, damage, new(character)
{
CalculateShield = false,
IgnoreImmune = true,
TriggerEffects = false
});
}
因果伤害值 = 0;
}
}
public override void OnSkillCasted(SkillCastContext ctx)
{
if (ctx.Trigger is not Character caster) return;
List<Character> targets = ctx.Targets;
List<Grid> grids = ctx.Grids;
Dictionary<string, object> others = ctx.Others;
RemainDurationTurn = DurationTurn;
if (!caster.Effects.Contains(this))
{
caster.Effects.Add(this);
OnEffectGained(new HookContext(GamingQueue, caster));
}
GamingQueue?.AddApplyEffects(caster, EffectType.Focusing);
}
}
}