public void setDamageInfo(DamageStruct d, string t)
{
//get damage properties of corresponding attack type.
damageValue = d.damage;
hKnockBack = d.hKnockback;
vKnockBack = d.vKnockback;
hitDelay = d.hitDelay;
TargetType = t;
}
public override void DamageEffect(TrustedAI ai, ref DamageStruct damage, DamageStruct.DamageStep step)
{
if (damage.From != null && damage.Card != null && damage.From.HasWeapon(Name) && damage.Card.Name.Contains(Slash.ClassName) && !damage.Transfer && !damage.Chain)
{
Room room = ai.Room;
List <int> ids = ai.GetKnownCards(damage.From);
foreach (int id in ids)
{
if (damage.Card.SubCards.Contains(id))
{
continue;
}
WrappedCard card = room.GetCard(id);
FunctionCard fcard = Engine.GetFunctionCard(card.Name);
if (fcard is Slash || fcard is Weapon)
{
damage.Damage++;
break;
}
}
}
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
room.SendCompulsoryTriggerLog(player, Name, true);
DamageStruct damage = (DamageStruct)data;
LogMessage log = new LogMessage
{
Type = "#yuanyu",
From = player.Name,
Arg = damage.Damage.ToString(),
Arg2 = (--damage.Damage).ToString()
};
room.SendLog(log);
if (damage.Damage < 1)
{
return(true);
}
data = damage;
return(false);
}
IEnumerator WaitPlayDamage(DamageStruct es)
{
//如果特效没有启用则不进行播放
if (es.isEnabled)
{
yield return(new WaitForSeconds(es.DelayTime));
}
else
{
yield break;
}
//if you have bullet, then you can not use damage event because bullet will triggers the callback function
for (int i = 0; i < EnemyList.Length; ++i)
{
if (EnemyList[i] != null)
{
mxAnimationEvent.OnDamageEvent(this.gameObject, EnemyList[i], es.index);
}
}
yield return(new WaitForEndOfFrame());
}
public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
if (data is string str)
{
string[] strs = str.Split(':');
Player who = ai.Room.FindPlayer(strs[1]);
DamageStruct damage = new DamageStruct(Name, who, player);
if (ai.IsFriend(who) || ai.GetDamageScore(damage).Score > 0)
{
return(true);
}
}
else if (data is Player target)
{
DamageStruct damage = new DamageStruct(Name, player, target);
if (ai.GetDamageScore(damage).Score > 0)
{
return(true);
}
}
return(false);
}
public void TakeDamage(DamageStruct aDmgStruct)
{
myDamageVelocity = (transform.position - aDmgStruct.myOrigin).normalized * Mathf.Max(aDmgStruct.myPushBackStrength - myPushBackResistance, 0);
Instantiate(myDamageParticleSystem, transform.position + new Vector3(0, myAgent.height, 0), Quaternion.LookRotation((transform.position - myLastAttackOrigin).normalized, Vector3.up));
myLastAttackOrigin = aDmgStruct.myOrigin;
}
public virtual ScoreStruct GetDamageScore(TrustedAI ai, DamageStruct damage) => new ScoreStruct();
public virtual void DamageEffect(TrustedAI ai, ref DamageStruct damage, DamageStruct.DamageStep step)
{
}
public void NotifyPlayerDamaged(string attackerId, string damagedPlayerId, int damage)
{
DamageStruct damageMessage = new DamageStruct(attackerId, damagedPlayerId, damage);
io.Emit("damage", JsonUtility.ToJson(damageMessage));
}
public override bool Effect(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player target, TriggerStruct trigger_info)
{
if (room.SkipGameRule)
{
room.SkipGameRule = false;
return(false);
}
// Handle global events
if (player == null)
{
if (triggerEvent == TriggerEvent.GameStart)
{
OnGameStart(room, ref data);
}
if (triggerEvent != TriggerEvent.BeforeCardsMove && triggerEvent != TriggerEvent.CardsMoveOneTime)
{
return(false);
}
}
switch (triggerEvent)
{
case TriggerEvent.TurnStart:
OnTurnStart(room, player, ref data);
break;
case TriggerEvent.EventPhaseProceeding:
OnPhaseProceed(room, player, ref data);
break;
case TriggerEvent.EventPhaseEnd:
OnPhaseEnd(room, player, ref data);
break;
case TriggerEvent.EventPhaseChanging:
OnPhaseChanging(room, player, ref data);
break;
case TriggerEvent.PreCardUsed:
OnPreCardUsed(room, player, ref data);
break;
case TriggerEvent.CardUsed:
OnCardUsed(room, player, ref data);
break;
case TriggerEvent.CardFinished:
CardUseStruct use = (CardUseStruct)data;
//room.ClearCardFlag(use.Card);
use.Card.ClearFlags(); //RoomCard会在其移动后自动清除flag
room.RemoveSubCards(use.Card);
//以askforcard形式使用的卡牌没有onUse的trigger，但有finish
if (use.Reason != CardUseStruct.CardUseReason.CARD_USE_REASON_RESPONSE)
{
room.RemoveUseOnFinish();
}
if (Engine.GetFunctionCard(use.Card.Name).IsNDTrick())
{
room.RemoveHegNullification(use.Card);
}
foreach (Client p in room.Clients)
{
room.DoNotify(p, CommandType.S_COMMAND_NULLIFICATION_ASKED, new List <string> {
"."
});
}
break;
case TriggerEvent.EventAcquireSkill:
case TriggerEvent.EventLoseSkill:
InfoStruct info = (InfoStruct)data;
string skill_name = info.Info;
Skill skill = Engine.GetSkill(skill_name);
bool refilter = skill is FilterSkill;
if (!refilter && skill is TriggerSkill)
{
TriggerSkill trigger = (TriggerSkill)skill;
ViewAsSkill vsskill = trigger.ViewAsSkill;
if (vsskill != null && (vsskill is FilterSkill))
{
refilter = true;
}
}
if (refilter)
{
room.FilterCards(player, player.GetCards("he"), triggerEvent == TriggerEvent.EventLoseSkill);
}
CheckBigKingdoms(room);
break;
case TriggerEvent.PostHpReduced:
if (player.Hp > 0 || player.HasFlag("Global_Dying")) // newest GameRule -- a player cannot enter dying when it is dying.
{
break;
}
if (data is DamageStruct damage)
{
room.EnterDying(player, damage);
}
else
{
room.EnterDying(player, new DamageStruct());
}
break;
case TriggerEvent.AskForPeaches:
OnAskforPeach(room, player, ref data);
break;
case TriggerEvent.AskForPeachesDone:
{
if (player.Hp <= 0 && player.Alive)
{
DyingStruct dying = (DyingStruct)data;
room.KillPlayer(player, dying.Damage);
}
break;
}
case TriggerEvent.ConfirmDamage:
{
break;
}
case TriggerEvent.DamageDone:
{
damage = (DamageStruct)data;
if (damage.From != null && !damage.From.Alive)
{
damage.From = null;
}
room.SendDamageLog(damage);
if (damage.Nature != DamageNature.Normal && player.Chained && !damage.Chain && !damage.ChainStarter)
{
damage.ChainStarter = true;
}
data = damage;
bool reduce = !room.ApplyDamage(player, damage);
if (reduce)
{
room.RoomThread.Trigger(TriggerEvent.PostHpReduced, room, player, ref data);
}
break;
}
case TriggerEvent.DamageComplete:
{
damage = (DamageStruct)data;
if (damage.Prevented)
{
return(false);
}
/*
* if (damage.Nature != DamageNature.Normal && player.Chained)
* {
* room.ChainedRemoveOnDamageDone(player, damage);
* }
*/
if (damage.Nature != DamageNature.Normal && !damage.Chain && damage.ChainStarter) // iron chain effect
{
List <Player> chained_players = new List <Player>();
if (!room.Current.Alive)
{
chained_players = room.GetOtherPlayers(room.Current);
}
else
{
chained_players = room.GetAllPlayers();
}
chained_players.Remove(damage.To);
foreach (Player chained_player in chained_players)
{
if (chained_player.Chained)
{
Thread.Sleep(500);
LogMessage log = new LogMessage
{
Type = "#IronChainDamage",
From = chained_player.Name
};
room.SendLog(log);
DamageStruct chain_damage = damage;
chain_damage.To = chained_player;
chain_damage.Chain = true;
chain_damage.Transfer = false;
chain_damage.TransferReason = null;
room.Damage(chain_damage);
}
}
}
foreach (Player p in room.GetAllPlayers())
{
if (p.HasFlag("Global_DFDebut"))
{
p.SetFlags("-Global_DFDebut");
room.RoomThread.Trigger(TriggerEvent.DFDebut, room, p);
}
}
break;
}
case TriggerEvent.CardEffect:
{
if (data is CardEffectStruct effect)
{
if (Engine.GetFunctionCard(effect.Card.Name) is DelayedTrick)
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_DELAYTRICK_EFFECT,
effect.To.Name, effect.Card.Skill, effect.Card.Name)
{
Card = effect.Card
};
room.MoveCardTo(effect.Card, effect.To, Place.PlaceTable, reason, true);
Thread.Sleep(500);
}
}
break;
}
case TriggerEvent.CardEffected:
{
if (data is CardEffectStruct effect)
{
FunctionCard fcard = Engine.GetFunctionCard(effect.Card.Name);
if (!(fcard is Slash) && effect.BasicEffect.Nullified)
{
LogMessage log = new LogMessage
{
Type = "#Cardnullified",
From = effect.To.Name,
Arg = effect.Card.Name
};
room.SendLog(log);
return(true);
}
else if (fcard.TypeID == CardType.TypeTrick && room.IsCanceled(effect))
{
effect.To.SetFlags("Global_NonSkillnullify");
return(true);
}
object _effect = effect;
room.RoomThread.Trigger(TriggerEvent.CardEffectConfirmed, room, effect.To, ref _effect);
if (effect.To.Alive || fcard is Slash)
{
fcard.OnEffect(room, effect);
}
}
break;
}
case TriggerEvent.SlashEffected:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
if (effect.Nullified)
{
LogMessage log = new LogMessage
{
Type = "#Cardnullified",
From = effect.To.Name,
Arg = effect.Slash.Name
};
room.SendLog(log);
return(true);
}
if (effect.Jink_num > 0)
{
room.RoomThread.Trigger(TriggerEvent.SlashProceed, room, effect.From, ref data);
}
else
{
room.SlashResult(effect, null);
}
break;
}
case TriggerEvent.SlashProceed:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
string slasher = effect.From.Name;
if (!effect.To.Alive)
{
break;
}
if (effect.Jink_num == 1)
{
CardResponseStruct resp = room.AskForCard(effect.To, Slash.ClassName, Jink.ClassName, string.Format("slash-jink:{0}::{1}", slasher, effect.Slash.Name),
data, HandlingMethod.MethodUse, null, effect.From, false, false);
room.SlashResult(effect, room.IsJinkEffected(effect.To, resp) ? resp.Card : null);
}
else
{
WrappedCard jink = new WrappedCard(DummyCard.ClassName);
for (int i = effect.Jink_num; i > 0; i--)
{
string prompt = string.Format("@multi-jink{0}:{1}::{2}:{3}", i == effect.Jink_num ? "-start" : string.Empty, slasher, i, effect.Slash.Name);
CardResponseStruct resp = room.AskForCard(effect.To, Slash.ClassName, Jink.ClassName, prompt, data, HandlingMethod.MethodUse, null, effect.From, false, false);
if (!room.IsJinkEffected(effect.To, resp))
{
//delete jink;
room.SlashResult(effect, null);
return(false);
}
else
{
jink.AddSubCard(resp.Card);
}
}
room.SlashResult(effect, jink);
}
break;
}
case TriggerEvent.SlashHit:
{
SlashEffectStruct effect = (SlashEffectStruct)data;
if (effect.Drank > 0)
{
LogMessage log = new LogMessage
{
Type = "#AnalepticBuff",
From = effect.From.Name,
To = new List <string> {
effect.To.Name
},
Arg = (1 + effect.ExDamage).ToString(),
Arg2 = (1 + effect.ExDamage + effect.Drank).ToString()
};
room.SendLog(log);
}
DamageStruct slash_damage = new DamageStruct(effect.Slash, effect.From, effect.To, 1 + effect.ExDamage + effect.Drank, effect.Nature)
{
Drank = effect.Drank > 0
};
room.Damage(slash_damage);
break;
}
case TriggerEvent.BeforeGameOverJudge:
{
if (!player.General1Showed)
{
room.ShowGeneral(player, true, false, false);
}
if (!player.General2Showed)
{
room.ShowGeneral(player, false, false, false);
}
break;
}
case TriggerEvent.GameOverJudge:
{
string winner = GetWinner(room);
if (!string.IsNullOrEmpty(winner))
{
room.GameOver(winner);
return(true);
}
break;
}
case TriggerEvent.BuryVictim:
{
OnBuryVictim(room, player, ref data);
break;
}
case TriggerEvent.StartJudge:
{
int card_id = room.GetNCards(1)[0];
JudgeStruct judge_struct = (JudgeStruct)data;
judge_struct.Card = room.GetCard(card_id);
LogMessage log = new LogMessage
{
Type = "$InitialJudge",
From = judge_struct.Who.Name,
Card_str = card_id.ToString()
};
room.SendLog(log);
room.MoveCardTo(judge_struct.Card, null, judge_struct.Who, Place.PlaceJudge,
new CardMoveReason(MoveReason.S_REASON_JUDGE, judge_struct.Who.Name, null, null, judge_struct.Reason), true);
Thread.Sleep(500);
bool effected = judge_struct.Good == Engine.MatchExpPattern(room, judge_struct.Pattern, judge_struct.Who, judge_struct.Card);
judge_struct.UpdateResult(effected);
data = judge_struct;
break;
}
case TriggerEvent.JudgeResult:
{
JudgeStruct judge = (JudgeStruct)data;
LogMessage log = new LogMessage
{
Type = "$JudgeResult",
From = player.Name,
Card_str = RoomLogic.CardToString(room, judge.Card)
};
room.SendLog(log);
//Thread.Sleep(500);
if (judge.PlayAnimation)
{
room.SendJudgeResult(judge);
Thread.Sleep(800);
}
break;
}
case TriggerEvent.FinishJudge:
{
JudgeStruct judge = (JudgeStruct)data;
if (room.GetCardPlace(judge.Card.Id) == Place.PlaceJudge)
{
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_JUDGEDONE, judge.Who.Name, null, judge.Reason);
room.MoveCardTo(judge.Card, judge.Who, null, Place.DiscardPile, reason, true);
}
break;
}
case TriggerEvent.ChoiceMade:
{
foreach (Player p in room.GetAlivePlayers())
{
List <string> flags = new List <string>(p.Flags);
foreach (string flag in flags)
{
if (flag.StartsWith("Global_") && flag.EndsWith("Failed"))
{
p.SetFlags("-" + flag);
}
}
}
break;
}
case TriggerEvent.GeneralShown:
{
string winner = GetWinner(room);
if (!string.IsNullOrEmpty(winner))
{
room.GameOver(winner); // if all hasShownGenreal, and they are all friend, game over.
return(true);
}
if (!room.ContainsTag("TheFirstToShowRewarded"))
{
room.SetTag("TheFirstToShowRewarded", true);
room.SetPlayerMark(player, "@pioneer", 1);
room.AttachSkillToPlayer(player, "pioneer");
}
if (player.Alive && player.HasShownAllGenerals())
{
if (player.GetMark("CompanionEffect") > 0)
{
room.RemovePlayerMark(player, "CompanionEffect");
room.DoSuperLightbox(player, string.Empty, "companion");
room.SetPlayerMark(player, "@companion", 1);
room.AttachSkillToPlayer(player, "companion");
}
if (player.GetMark("HalfMaxHpLeft") > 0)
{
room.RemovePlayerMark(player, "HalfMaxHpLeft");
room.SetPlayerMark(player, "@megatama", 1);
room.AttachSkillToPlayer(player, "megatama");
}
}
CheckBigKingdoms(room);
break;
}
case TriggerEvent.BeforeCardsMove:
{
if (data is CardsMoveOneTimeStruct move)
{
bool should_find_io = false;
if (move.To_place == Place.DiscardPile)
{
if (move.Reason.Reason != MoveReason.S_REASON_USE)
{
should_find_io = true; // not use
}
else if (move.Card_ids.Count > 1)
{
should_find_io = true; // use card isn't IO
}
else
{
WrappedCard card = room.GetCard(move.Card_ids[0]);
if (card.Name == Edict.ClassName && !card.HasFlag("edict_normal_use"))
{
should_find_io = true; // use card isn't IO
}
}
}
if (should_find_io)
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == Edict.ClassName)
{
room.MoveCardTo(card, null, Place.PlaceTable, true);
room.AddToPile(room.Players[0], "#edict", card, false);
LogMessage log = new LogMessage
{
Type = "#RemoveEdict",
Arg = Edict.ClassName
};
room.SendLog(log);
room.SetTag("EdictInvoke", true);
room.SetTag("EdictCard", card);
int i = move.Card_ids.IndexOf(id);
move.From_places.RemoveAt(i);
move.Open.RemoveAt(i);
move.From_pile_names.RemoveAt(i);
move.Card_ids.Remove(id);
data = move;
break;
}
}
}
}
break;
}
case TriggerEvent.Death:
{
OnDeath(room, player, ref data);
break;
}
case TriggerEvent.CardsMoveOneTime:
{
if (data is CardsMoveOneTimeStruct move)
{
if (move.From != null && move.From_places.Contains(Place.PlaceEquip))
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == JadeSeal.ClassName)
{
CheckBigKingdoms(room);
break;
}
}
}
if (move.To != null && move.To_place == Place.PlaceEquip)
{
foreach (int id in move.Card_ids)
{
WrappedCard card = room.GetCard(id);
if (card.Name == JadeSeal.ClassName)
{
CheckBigKingdoms(room);
break;
}
}
}
}
break;
}
default:
break;
}
return(false);
}
public override ScoreStruct GetDamageScore(DamageStruct _damage, DamageStruct.DamageStep step = DamageStruct.DamageStep.Caused)
{
DamageStruct damage = new DamageStruct(_damage.Card, _damage.From, _damage.To, _damage.Damage, _damage.Nature)
{
Reason = _damage.Reason,
Steped = _damage.Steped,
Transfer = _damage.Transfer,
TransferReason = _damage.TransferReason,
Chain = _damage.Chain
};
if (!HasSkill("gangzhi", damage.To))
{
damage.Damage = DamageEffect(damage, step);
}
Player from = damage.From;
Player to = damage.To;
if (damage.Steped < DamageStruct.DamageStep.Caused)
{
damage.Steped = DamageStruct.DamageStep.Caused;
}
ScoreStruct result_score = new ScoreStruct
{
Damage = damage,
DoDamage = true
};
if (!HasSkill("gangzhi", damage.To))
{
damage.Damage = DamageEffect(damage, DamageStruct.DamageStep.Done);
}
damage.Steped = DamageStruct.DamageStep.Done;
result_score.Damage = damage;
List <ScoreStruct> scores = new List <ScoreStruct>();
bool deadly = false;
if (damage.Damage > 0 && !to.Removed)
{
double value = 0;
value = Math.Min(damage.Damage, to.Hp) * 3.5;
if (IsWeak(to))
{
value += 4;
if (damage.Damage > to.Hp)
{
if (!CanSave(to, damage.Damage - to.Hp + 1))
{
int over_damage = damage.Damage - to.Hp;
for (int i = 1; i <= over_damage; i++)
{
double x = HasSkill("buqu", to) ? 1 / Math.Pow(i, 2) : (double)8 / Math.Pow(i, 2);
value += x;
}
}
else
{
deadly = true;
}
}
}
//刚直应该这里就停止计算
if (HasSkill("gangzhi", to))
{
if (IsFriend(to))
{
value = -value;
}
if (priority_enemies.Contains(to) && value > 0)
{
value *= 1.5;
}
if (to.GetRoleEnum() == Player.PlayerRole.Lord)
{
value *= 1.2;
}
result_score.DoDamage = false;
result_score.Score = value;
return(result_score);
}
if (!to.Removed && CanResist(to, damage.Damage))
{
result_score.Score = 3;
}
if (IsFriend(to))
{
value = -value;
if (deadly && damage.From != null && damage.From.Alive)
{
if (RoomLogic.IsFriendWith(room, damage.From, damage.To) && !damage.From.IsNude())
{
value -= 3;
}
else if (!RoomLogic.WillBeFriendWith(room, damage.From, damage.To))
{
value -= 2;
}
}
}
else
{
if (deadly && damage.From != null && damage.From.Alive)
{
if (RoomLogic.IsFriendWith(room, damage.From, damage.To) && !damage.From.IsNude())
{
value += 2.5;
}
else if (IsFriend(damage.From) && !RoomLogic.WillBeFriendWith(room, damage.From, damage.To))
{
value += 4;
}
}
}
foreach (SkillEvent e in skill_events.Values)
{
if (e.Name != damage.Reason)
{
value += e.GetDamageScore(this, damage).Score;
}
}
if (priority_enemies.Contains(to) && value > 0)
{
value *= 1.5;
}
//ai debug log
/*
* if ((RoomLogic.IsFriendWith(room, self, to) || IsFriend(to)) && value > 0)
* {
* string damage_from = damage.From != null ? string.Format("{0},{1} has skills {2}", damage.From.General1Showed ? damage.From.ActualGeneral1 : "hidden head",
* damage.From.General2Showed ? damage.From.ActualGeneral2 : "hidden deputy", string.Join(",", GetKnownSkills(damage.From))) : "no damage from";
* string damage_str = string.Format("nature {0} count {1} reason {2}", damage.Nature == DamageStruct.DamageNature.Normal ? "normal" : damage.Nature == DamageStruct.DamageNature.Fire ?
* "fire" : "thunder", damage.Damage, damage.Card != null ? damage.Card.Name : damage.Reason);
* string damage_to = string.Format("{0},{1} has skills {2}", damage.To.General1Showed ? damage.To.ActualGeneral1 : "hidden head",
* damage.To.General2Showed ? damage.To.ActualGeneral2 : "hidden deputy", string.Join(",", GetKnownSkills(damage.To)));
* string self_str = string.Format("{0},{1}", self.ActualGeneral1, self.ActualGeneral2);
*
* File.AppendAllText("ai_damage_log.txt", string.Format("{0} judge damage {1} against {2} {6} and value is {3} and ai judge target is my {4} and I'm {5}\r\n",
* damage_from, damage_str, damage_to, value, IsFriend(self, to) ? "friend" : "enemy", self_str, to.Chained ? "chained" : string.Empty));
* }
*/
result_score.Score = value;
}
scores.Add(result_score);
if (damage.Card != null && from != null && !damage.Transfer)
{
if (damage.Card.Name.Contains(Slash.ClassName) && from.HasWeapon(IceSword.ClassName) && !to.IsNude())
{
ScoreStruct score = FindCards2Discard(from, to, string.Empty, "he", HandlingMethod.MethodDiscard, 2, true);
scores.Add(score);
}
}
CompareByScore(ref scores);
return(scores[0]);
}
public static AppAttackTypeWithHitChances MapToAppAttackHitChances(string type, DamageStruct damage)
{
decimal totalChance = damage.Destruction.DestructionLevels.Sum(dl => dl.Chance);
List <AppAttackHitChance> hitChances = new List <AppAttackHitChance>();
foreach (DestructionLevel destructionDestructionLevel in damage.Destruction.DestructionLevels)
{
if (destructionDestructionLevel.Chance == 0)
{
continue;
}
int percentChance = Convert.ToInt32(destructionDestructionLevel.Chance / totalChance * 10000); // Round to 2 decimal
hitChances.Add(new AppAttackHitChance
{
Chance = percentChance / 100.0M,
QualityLevel = destructionDestructionLevel.QualityLevel,
});
}
return(new AppAttackTypeWithHitChances
{
Type = type,
HitChances = hitChances.OrderByDescending(hc => hc.Chance).ToList()
});
}
void DrawAnimation()
{
if (mData.AnimationSkillList == null)
{
return;
}
for (int i = 0; i < mData.AnimationSkillList.Count; i++)
{
EditorGUILayout.Space();
AnimationSkillStruct _ass = mData.AnimationSkillList[i];
if (_ass.IsFoldout)
{
EditorGUILayout.BeginVertical(EditorStyles.helpBox);
EditorGUILayout.LabelField(_ass.Type.ToString());
if (GUILayout.Button("Preview"))
{
mASD.PlayAnimaState(_ass.Type);
}
_ass.AnimationClip = (AnimationClip)EditorGUILayout.ObjectField("AnimaitonClip:", _ass.AnimationClip, typeof(AnimationClip), true);
EditorGUILayout.BeginHorizontal();
if (_ass.AnimationClip == null)
{
_ass.fTime = 1f;
}
else
{
_ass.fTime = _ass.AnimationClip.length;
}
EditorGUILayout.LabelField("NextAnima After:", _ass.fTime.ToString());
_ass.NextType = (NFAnimaStateType)EditorGUILayout.EnumPopup(_ass.NextType);
EditorGUILayout.EndHorizontal();
AnimatorController ctl = (AnimatorController)mASD.GetComponent <Animator> ().runtimeAnimatorController;
if (ctl != null)
{
AnimatorStateMachine state_machine = ctl.layers[0].stateMachine;
for (int j = 0; j < state_machine.states.Length; ++j)
{
if (state_machine.states [j].state.name == _ass.Type.ToString())
{
String strPath = AssetDatabase.GetAssetPath(_ass.AnimationClip);
AnimationClip anim = AssetDatabase.LoadAssetAtPath(strPath, typeof(AnimationClip)) as AnimationClip;
state_machine.states [j].state.motion = anim;
break;
}
}
}
mData.AnimationSkillList[i] = _ass;
//添加特效与删除片断
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("ADD EFFECT"))
{
EffectStruct _es = new EffectStruct();
_es.LifeTime = 3;
_es.isFoldout = true;
mData.AnimationSkillList[i].EffectStructList.Add(_es);
}
if (GUILayout.Button("ADD Audio"))
{
AudioStruct _es = new AudioStruct();
_es.LifeTime = 3;
_es.isFoldout = true;
mData.AnimationSkillList[i].AudioStructList.Add(_es);
}
if (GUILayout.Button("ADD Bullet"))
{
BulletStruct _es = new BulletStruct();
_es.isFoldout = true;
mData.AnimationSkillList[i].BulletStructList.Add(_es);
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("ADD Damage"))
{
DamageStruct _es = new DamageStruct();
_es.isFoldout = true;
mData.AnimationSkillList[i].DamageStructList.Add(_es);
}
if (GUILayout.Button("ADD Movement"))
{
MovementStruct _es = new MovementStruct();
_es.isFoldout = true;
mData.AnimationSkillList[i].MovementStructList.Add(_es);
}
if (GUILayout.Button("ADD Camera"))
{
CameraStruct _es = new CameraStruct();
_es.isFoldout = true;
mData.AnimationSkillList[i].CameraStructList.Add(_es);
}
EditorGUILayout.EndHorizontal();
if (mData.AnimationSkillList.Count > 0)
{
DrawEffect(i);
DrawAudio(i);
DrawMovement(i);
DrawDamage(i);
DrawBullet(i);
DrawCamera(i);
}
EditorGUILayout.EndVertical();
}
}
}
public override List <int> OnDiscard(TrustedAI ai, Player player, List <int> cards, int min, int max, bool option)
{
if (!ai.WillShowForAttack())
{
return(new List <int>());
}
Room room = ai.Room;
Player target = room.Current;
List <int> ids = new List <int>();
foreach (int id in player.HandCards)
{
if (RoomLogic.CanDiscard(room, player, player, id))
{
ids.Add(id);
}
}
ai.SortByKeepValue(ref ids, false);
double value = ai.GetKeepValue(ids[0], player);
if (ai.GetOverflow(player) > 1)
{
value /= 3;
}
DamageStruct damage = new DamageStruct(Name, player, target);
if (ai.IsFriend(target))
{
bool range = false;
foreach (Player p in room.GetOtherPlayers(target))
{
if (ai.GetPrioEnemies().Contains(p) && RoomLogic.InMyAttackRange(room, target, p))
{
range = true;
break;
}
}
if (range && target.HandcardNum + target.GetPile("wooden_ox").Count > 3)
{
if (ai.GetDamageScore(damage).Score < -3 && ai.HasSkill("wushuang|jianchu", target) && value < 3)
{
return new List <int> {
ids[0]
}
}
;
}
}
else
{
if (ai.GetDamageScore(damage).Score > 7 && value < 7)
{
return new List <int> {
ids[0]
}
}
;
else if (ai.GetDamageScore(damage).Score > 4 && value < 3)
{
if (ai.IsLackCard(target, Slash.ClassName) || target.HandcardNum + target.GetPile("wooden_ox").Count < 3)
{
return(new List <int> {
ids[0]
});
}
else
{
bool range = false;
foreach (Player p in room.GetOtherPlayers(target))
{
if (ai.IsFriend(p) && RoomLogic.InMyAttackRange(room, target, p))
{
range = true;
break;
}
}
if (!range)
{
return new List <int> {
ids[0]
}
}
;
}
}
}
return(new List <int>());
}
}
public override CardUseStruct OnResponding(TrustedAI ai, Player player, string pattern, string prompt, object data)
{
CardUseStruct result = new CardUseStruct
{
From = player,
To = new List <Player>()
};
Room room = ai.Room;
int sub = -1;
foreach (int id in player.GetPile("sorcery"))
{
WrappedCard card = room.GetCard(id);
if (card.Suit == WrappedCard.CardSuit.Club || card.Suit == WrappedCard.CardSuit.Spade)
{
sub = id;
break;
}
}
if (sub == -1)
{
sub = player.GetPile("sorcery")[0];
}
WrappedCard qianhuan = new WrappedCard("QianhuanCard")
{
Mute = true,
Skill = Name
};
qianhuan.AddSubCard(sub);
if (room.ContainsTag("qianhuan_data") && room.GetTag("qianhuan_data") is CardUseStruct use)
{
if (ai.IsCancelTarget(use.Card, use.To[0], use.From) || !ai.IsCardEffect(use.Card, use.To[0], use.From))
{
return(result);
}
if (use.Card.Name == SupplyShortage.ClassName || use.Card.Name == Indulgence.ClassName || use.Card.Name == Snatch.ClassName)
{
if (use.From != null && ai.IsEnemy(use.From))
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == BurningCamps.ClassName)
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0], 1, DamageStruct.DamageNature.Fire);
if (player.GetPile("sorcery").Count >= 3 && ai.GetDamageScore(damage).Score < 0 || ai.GetDamageScore(damage).Score < -5)
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name.Contains(Slash.ClassName))
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0], 1 + use.Drank);
if (use.Card.Name == FireSlash.ClassName)
{
damage.Nature = DamageStruct.DamageNature.Fire;
}
else if (use.Card.Name == ThunderSlash.ClassName)
{
damage.Nature = DamageStruct.DamageNature.Thunder;
}
double value = ai.GetDamageScore(damage).Score;
if (value < -5 || (ai.IsWeak(use.To[0]) && value < 0) || (value < 0 && player.GetPile("sorcery").Count >= 3))
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == ArcheryAttack.ClassName)
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0]);
double value = ai.GetDamageScore(damage).Score;
if ((value < -5 || (ai.IsWeak(use.To[0]) && value < 0)) && player != use.To[0] ? ai.IsLackCard(use.To[0], Jink.ClassName) : ai.GetKnownCardsNums(Jink.ClassName, "he", use.To[0]) == 0)
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == SavageAssault.ClassName)
{
Player menghuo = ai.FindPlayerBySkill("huoshou");
DamageStruct damage = new DamageStruct(use.Card, menghuo ?? use.From, use.To[0]);
double value = ai.GetDamageScore(damage).Score;
if ((value < -5 || (ai.IsWeak(use.To[0]) && value < 0)) && (player != use.To[0] ? ai.IsLackCard(use.To[0], Slash.ClassName)
: ai.GetKnownCardsNums(Slash.ClassName, "he", use.To[0]) == 0 || RoomLogic.IsHandCardLimited(room, use.To[0], HandlingMethod.MethodResponse)))
{
result.Card = qianhuan;
return(result);
}
}
else if (use.Card.Name == Duel.ClassName)
{
DamageStruct damage = new DamageStruct(use.Card, use.From, use.To[0]);
double value = ai.GetDamageScore(damage).Score;
if (value < -5 || ((ai.IsWeak(use.To[0]) || player.GetPile("sorcery").Count >= 3) && value < 0))
{
result.Card = qianhuan;
return(result);
}
}
}
return(result);
}
public void TakeDamage(DamageStruct aDmgStruct)
{
myDamageVelocity = (transform.position - aDmgStruct.myOrigin).normalized * aDmgStruct.myPushBackStrength;
}
public override NulliResult OnNullification(TrustedAI ai, CardEffectStruct effect, bool positive, bool keep)
{
NulliResult result = new NulliResult();
Room room = ai.Room;
Player from = effect.From, to = effect.To;
WrappedCard trick = effect.Card;
Player player = ai.Self;
if (positive)
{
ScoreStruct score = new ScoreStruct
{
Score = 0
};
if (from.Alive)
{
DamageStruct damage = new DamageStruct(trick, from, to);
score = ai.GetDamageScore(damage);
}
if (to.IsWounded())
{
if (ai.IsFriend(to))
{
score.Score += 1 * to.GetLostHp();
}
else if (ai.IsEnemy(to))
{
score.Score -= 1 * to.GetLostHp();
}
}
if (score.Score <= -4)
{
result.Null = true;
}
}
else
{
ScoreStruct score = new ScoreStruct
{
Score = 0
};
if (from.Alive)
{
DamageStruct damage = new DamageStruct(trick, from, to);
score = ai.GetDamageScore(damage);
}
if (to.IsWounded())
{
if (ai.IsFriend(to))
{
score.Score += 1 * to.GetLostHp();
}
else if (ai.IsEnemy(to))
{
score.Score -= 1 * to.GetLostHp();
}
}
if (score.Score > 4)
{
result.Null = true;
}
}
return(result);
}
public abstract void OnDamaged(Room room, Player target, DamageStruct damage, TriggerStruct info);
public override NulliResult OnNullification(TrustedAI ai, CardEffectStruct effect, bool positive, bool keep)
{
NulliResult result = new NulliResult();
Room room = ai.Room;
Player from = effect.From, to = effect.To;
WrappedCard trick = effect.Card;
Player player = ai.Self;
List <Player> players = new List <Player>();
foreach (Player p in room.GetAlivePlayers())
{
if (p.IsFemale())
{
players.Add(p);
}
}
int count = Math.Min(players.Count, to.HandcardNum);
if (positive)
{
if (ai.IsFriend(to))
{
double value = -count;
if (from.HandcardNum + count < to.HandcardNum)
{
DamageStruct damage = new DamageStruct(trick, from, to);
value += ai.GetDamageScore(damage).Score;
}
if (count <= -2)
{
result.Null = true;
}
}
}
else
{
if (ai.IsFriend(from))
{
double value = count;
if (count > 0)
{
room.SortByActionOrder(ref players);
for (int i = 0; i < count; i++)
{
if (ai.IsFriend(players[i]) && players[i].HandcardNum > 0)
{
value += players[i].HandcardNum / 5;
}
}
}
if (from.HandcardNum + count < to.HandcardNum)
{
DamageStruct damage = new DamageStruct(trick, from, to);
value += ai.GetDamageScore(damage).Score;
}
if (count > 3)
{
result.Null = true;
}
}
}
return(result);
}
