public override void OnUse(Room room, CardUseStruct card_use)
{
Player source = card_use.From;
List <Player> targets = new List <Player>();
if (card_use.To.Count == 0)
{
List <Player> all_players = room.GetOtherPlayers(card_use.From);
foreach (Player player in all_players)
{
Skill skill = RoomLogic.IsProhibited(room, source, player, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.NotifySkillInvoked(player, skill.Name);
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, player, skill.Name);
string genral = gsk.General;
int skin_id = gsk.SkinId;
string skill_name = skill.Name;
int audio = -1;
skill.GetEffectIndex(room, player, card_use.Card, ref audio, ref skill_name, ref genral, ref skin_id);
if (audio >= -1)
{
room.BroadcastSkillInvoke(skill_name, "male", audio, genral, skin_id);
}
}
else
{
int audio = -1;
string skill_name = skill.Name;
string genral = string.Empty;
int skin_id = 0;
skill.GetEffectIndex(room, null, card_use.Card, ref audio, ref skill_name, ref genral, ref skin_id);
}
}
else
{
targets.Add(player);
}
}
}
else
{
targets = card_use.To;
}
card_use.To = targets;
base.OnUse(room, card_use);
}
public override void OnUninstall(Room room, Player player, WrappedCard card)
{
if (!RoomLogic.PlayerHasShownSkill(room, player, "zhiheng"))
{
player.ClearHistory("ZhihengCard");
}
base.OnUninstall(room, player, card);
}
public override void OnUse(Room room, CardUseStruct card_use)
{
if (card_use.To.Count == 0)
{
DoRecast(room, card_use);
}
else
{
Player player = card_use.From;
CardUseStruct use = new CardUseStruct(card_use.Card, player, new List <Player>());
List <Player> targets = new List <Player>();
Game3v3Camp camp = card_use.To[0].Camp;
foreach (Player p in room.GetAlivePlayers())
{
if (player.Camp == camp && p.Camp == camp && p.Chained)
{
targets.Add(p);
}
else if (player.Camp != camp && p.Camp == camp && !p.Chained)
{
targets.Add(p);
}
}
foreach (Player p in targets)
{
Skill skill = Engine.IsProhibited(room, player, p, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.BroadcastSkillInvoke(skill.Name, player);
room.NotifySkillInvoked(player, skill.Name);
}
}
else
{
use.To.Add(p);
}
}
room.SortByActionOrder(ref use);
base.OnUse(room, use);
}
}
public override TriggerStruct Cost(TriggerEvent triggerEvent, Room room, Player player, ref object data, Player ask_who, TriggerStruct info)
{
bool invoke = RoomLogic.PlayerHasShownSkill(room, player, Name) ? true : room.AskForSkillInvoke(player, Name, data, info.SkillPosition);
if (invoke)
{
room.BroadcastSkillInvoke(Name, player, info.SkillPosition);
return(info);
}
return(new TriggerStruct());
}
public override bool OnSkillInvoke(TrustedAI ai, Player player, object data)
{
if (ai.WillShowForAttack())
{
Room room = ai.Room;
int adjust = RoomLogic.PlayerHasShownSkill(room, player, "mashu_madai") ? 0 : -1;
foreach (Player p in room.GetOtherPlayers(player))
{
if (!ai.IsFriend(p) && RoomLogic.DistanceTo(room, player, p) + adjust <= 1)
{
return(true);
}
}
}
return(false);
}
public override void OnUse(Room room, CardUseStruct card_use)
{
Player source = card_use.From;
List <Player> targets = new List <Player>();
if (card_use.To.Count == 0)
{
List <Player> all_players = room.GetOtherPlayers(card_use.From);
foreach (Player player in all_players)
{
Skill skill = RoomLogic.IsProhibited(room, source, player, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.BroadcastSkillInvoke(skill.Name, player);
room.NotifySkillInvoked(player, skill.Name);
}
}
else
{
targets.Add(player);
}
}
}
else
{
targets = card_use.To;
}
card_use.To = targets;
base.OnUse(room, card_use);
}
public virtual TriggerStruct Cost(Room room, ref object data, TriggerStruct info)
{
Player target = room.FindPlayer(info.Invoker, true);
if (RoomLogic.HasArmorEffect(room, target, Name, false) &&
(frequency == Frequency.Compulsory || room.AskForSkillInvoke(target, Name, data)))
{
return(info);
}
List <string> all = new List <string>();
bool show = false;
bool protect = true;
foreach (ViewHasSkill vhskill in Engine.ViewHas(room, target, Name, "armor"))
{
Skill mskill = Engine.GetMainSkill(vhskill.Name);
if (RoomLogic.PlayerHasShownSkill(room, target, mskill))
{
protect = false;
if (frequency == Frequency.Compulsory)
{
show = true;
}
}
all.Add(mskill.Name);
}
if (protect)
{
target.SetFlags("Global_askForSkillCost");
}
if (all.Count > 0)
{
List <TriggerStruct> skills = new List <TriggerStruct>();
foreach (string sk in all)
{
TriggerStruct skill = new TriggerStruct(sk, target)
{
ResultTarget = info.ResultTarget
};
skills.Add(skill);
}
TriggerStruct result = room.AskForSkillTrigger(target, "armorskill", skills, !show, data);
if (string.IsNullOrEmpty(result.SkillName))
{
return(result);
}
else
{
TriggerSkill result_skill = Engine.GetTriggerSkill(result.SkillName);
if (result_skill != null)
{
if (show || all.Count > 1 || room.AskForSkillInvoke(target, result_skill.Name, data, result.SkillPosition))
{
return(result);
}
}
else if (show || all.Count > 1 || room.AskForSkillInvoke(target, result_skill.Name, data, result.SkillPosition))
{
return(info);
}
}
}
return(new TriggerStruct());
}
public bool Trigger(TriggerEvent triggerEvent, Room room, Player target, ref object data)
{
// push it to event stack
if (!string.IsNullOrEmpty(room.PreWinner))
{
return(true);
}
_m_trigger_id++;
int trigger_id = _m_trigger_id;
trigger_count.Add(trigger_id, new Dictionary <string, int>());
bool broken = false;
List <TriggerSkill> will_trigger = new List <TriggerSkill>();
List <TriggerSkill> triggerable_tested = new List <TriggerSkill>();
List <TriggerSkill> rules = new List <TriggerSkill>(); // we can't get a GameRule with Engine::getTriggerSkill() :(
Dictionary <Player, List <TriggerStruct> > trigger_who = new Dictionary <Player, List <TriggerStruct> >();
List <TriggerSkill> triggered = new List <TriggerSkill>();
Dictionary <Player, List <TriggerStruct> > already_triggered = new Dictionary <Player, List <TriggerStruct> >();
do
{
List <TriggerSkill> skills = skill_table.ContainsKey(triggerEvent) ? new List <TriggerSkill>(skill_table[triggerEvent]) : new List <TriggerSkill>();
trigger_who.Clear();
foreach (TriggerSkill skill in skills)
{
if (!triggered.Contains(skill))
{
if (skill is GameRule)
{
if (will_trigger.Count == 0 ||
skill.GetDynamicPriority(triggerEvent) == will_trigger[will_trigger.Count - 1].GetDynamicPriority(triggerEvent))
{
will_trigger.Add(skill);
if (trigger_who.ContainsKey(rule_player))
{
trigger_who[rule_player].Add(new TriggerStruct(skill.Name)); // Don't assign game rule to some player.
}
else
{
trigger_who[rule_player] = new List <TriggerStruct> {
new TriggerStruct(skill.Name)
}
};
rules.Add(skill);
}
else if (skill.GetDynamicPriority(triggerEvent) != will_trigger[will_trigger.Count - 1].GetDynamicPriority(triggerEvent))
{
break;
}
triggered.Insert(0, skill);
}
else
{
if (will_trigger.Count == 0 ||
skill.GetDynamicPriority(triggerEvent) == will_trigger[will_trigger.Count - 1].GetDynamicPriority(triggerEvent))
{
skill.Record(triggerEvent, room, target, ref data); //to record something for next.
List <TriggerStruct> triggerSkillList = skill.Triggerable(triggerEvent, room, target, ref data);
foreach (TriggerStruct skill_struct in triggerSkillList)
{
TriggerStruct tskill = skill_struct;
if (tskill.Times != 1)
{
tskill.Times = 1; //make sure times == 1
}
TriggerSkill trskill = Engine.GetTriggerSkill(tskill.SkillName);
Player p = room.FindPlayer(tskill.Invoker, true);
if (trskill != null)
{
will_trigger.Add(trskill);
if (trigger_who.ContainsKey(p))
{
trigger_who[p].Add(tskill);
}
else
{
trigger_who[p] = new List <TriggerStruct> {
tskill
}
};
}
}
}
else if (skill.GetDynamicPriority(triggerEvent) != will_trigger[will_trigger.Count - 1].GetDynamicPriority(triggerEvent))
{
break;
}
triggered.Insert(0, skill);
}
}
if (!triggerable_tested.Contains(skill))
{
triggerable_tested.Add(skill);
}
}
if (will_trigger.Count > 0)
{
will_trigger.Clear();
foreach (Player p in room.GetAllPlayers(true))
{
if (!trigger_who.ContainsKey(p))
{
continue;
}
//List<TriggerStruct> already_triggered = new List<TriggerStruct>();
Dictionary <Player, List <TriggerStruct> > refuse = new Dictionary <Player, List <TriggerStruct> >();
while (true)
{
List <TriggerStruct> who_skills = trigger_who.ContainsKey(p) ? new List <TriggerStruct>(trigger_who[p]) : new List <TriggerStruct>();
if (who_skills.Count == 0)
{
break;
}
TriggerStruct name = new TriggerStruct();
foreach (TriggerStruct skill in who_skills)
{
TriggerSkill tskill = Engine.GetTriggerSkill(skill.SkillName);
if (tskill != null && tskill.Global && tskill.SkillFrequency == Skill.Frequency.Compulsory)
{
TriggerStruct name_copy = skill;
if (skill.Targets.Count > 0)
{
name_copy.ResultTarget = skill.Targets[0];
}
name = name_copy; // a new trick to deal with all "record-skill" or "compulsory-global",
// they should always be triggered first.
break;
}
}
if (string.IsNullOrEmpty(name.SkillName))
{
if (p != null && !p.HasShownAllGenerals())
{
p.SetFlags("Global_askForSkillCost"); // TriggerOrder need protect
}
if (who_skills.Count == 1 && (p == null || who_skills[0].SkillName.Contains("global-fake-move")))
{
TriggerStruct name_copy = who_skills[0];
if (who_skills[0].Targets.Count > 0)
{
name_copy.ResultTarget = who_skills[0].Targets[0];
}
name = name_copy;
}
else if (p != null)
{
string reason = "GameRule:TriggerOrder";
foreach (TriggerStruct skill in who_skills)
{
if (triggerEvent == TriggerEvent.EventPhaseStart && skill.SkillName.Contains("GameRule_AskForGeneralShow"))
{
reason = "GameRule:TurnStart";
break;
}
}
name = room.AskForSkillTrigger(p, reason, who_skills, true, data);
}
else
{
name = who_skills[who_skills.Count - 1];
}
if (p != null && p.HasFlag("Global_askForSkillCost"))
{
p.SetFlags("-Global_askForSkillCost");
}
}
if (string.IsNullOrEmpty(name.SkillName))
{
break;
}
TriggerSkill result_skill = Engine.GetTriggerSkill(name.SkillName);
Player skill_target = room.FindPlayer(name.ResultTarget, true);
if (skill_target == null && target != null)
{
skill_target = target;
name.ResultTarget = target.Name;
}
if (name.Targets.Count > 0)
{
bool deplicated = false;
List <TriggerStruct> already = already_triggered.ContainsKey(p) ? new List <TriggerStruct>(already_triggered[p]) : new List <TriggerStruct>();
foreach (TriggerStruct already_s in already) //类似铁骑对多目标发动的触发技
{ //若先选择了对后位角色发动，则直接跳过前位的其他角色
if (already_s.Equals(name) && already_s.Targets.Count > 0)
{
Player triggered_target = room.FindPlayer(already_s.ResultTarget, true);
Player _target = room.FindPlayer(name.ResultTarget, true);
List <Player> all = room.GetAllPlayers(true);
if (all.IndexOf(_target) > all.IndexOf(triggered_target))
{
already_triggered[p][already.IndexOf(already_s)] = name;
deplicated = true;
break;
}
}
}
if (!deplicated)
{
if (already_triggered.ContainsKey(p))
{
already_triggered[p].Add(name);
}
else
{
already_triggered[p] = new List <TriggerStruct> {
name
}
};
}
}
else
{
if (already_triggered.ContainsKey(p))
{
already_triggered[p].Add(name);
}
else
{
already_triggered[p] = new List <TriggerStruct> {
name
}
};
}
//----------------------------------------------- TriggerSkill::cost
bool do_effect = false;
if (p != null && !RoomLogic.PlayerHasShownSkill(room, p, result_skill))
{
p.SetFlags("Global_askForSkillCost"); // SkillCost need protect
}
string mark = string.Format("{0}_{1}_{2}", name.SkillName, p.Name, skill_target != null ? skill_target.Name : "null");
if (!trigger_count[trigger_id].ContainsKey(mark))
{
trigger_count[trigger_id][mark] = 1;
}
else
{
trigger_count[trigger_id][mark]++;
}
TriggerStruct cost = name;
cost.Times = trigger_count[trigger_id][mark];
TriggerStruct cost_str = result_skill.Cost(triggerEvent, room, skill_target, ref data, p, cost);
result_skill = Engine.GetTriggerSkill(cost_str.SkillName);
if (result_skill != null)
{
do_effect = true;
if (p != null)
{
bool compulsory_shown = false;
if (result_skill.SkillFrequency == Skill.Frequency.Compulsory && RoomLogic.PlayerHasShownSkill(room, p, result_skill))
{
compulsory_shown = true;
}
bool show = room.ShowSkill(p, result_skill.Name, cost_str.SkillPosition);
if (!compulsory_shown && show)
{
p.SetTag("JustShownSkill", result_skill.Name);
}
}
}
if (p != null && p.HasFlag("Global_askForSkillCost")) // for next time
{
p.SetFlags("-Global_askForSkillCost");
}
//----------------------------------------------- TriggerSkill::effect
if (do_effect)
{
Player invoker = room.FindPlayer(cost_str.Invoker, true); //it may point to another skill, such as EightDiagram to bazhen
skill_target = room.FindPlayer(cost_str.ResultTarget, true);
broken = result_skill.Effect(triggerEvent, room, skill_target, ref data, invoker, cost_str);
if (broken)
{
//if (room.Setting.GameMode == "Hegemony")
// room.Debug(string.Format("{0}-{1}", triggerEvent, result_skill.Name));
p.RemoveTag("JustShownSkill");
break;
}
}
else
{
if (refuse.ContainsKey(p))
{
refuse[p].Add(name);
}
else
{
refuse[p] = new List <TriggerStruct> {
name
}
};
}
//-----------------------------------------------
p.RemoveTag("JustShownSkill");
trigger_who.Clear();
foreach (TriggerSkill skill in triggered)
{
if (skill is GameRule)
{
//room->tryPause();
continue; // dont assign them to some person.
}
else
{
//room->tryPause();
if (skill.GetDynamicPriority(triggerEvent) == triggered[0].GetDynamicPriority(triggerEvent))
{
List <TriggerStruct> triggerSkillList = skill.Triggerable(triggerEvent, room, target, ref data);
foreach (Player _p in room.Players)
{
foreach (TriggerStruct _skill in triggerSkillList)
{
if (_p.Name != _skill.Invoker)
{
continue;
}
bool refuse_before = false;
if (refuse.ContainsKey(_p))
{
foreach (TriggerStruct refused in refuse[_p])
{
if (_skill.Equals(refused) && _skill.Targets.Count == 0)
{
refuse_before = true;
break;
}
}
}
if (refuse_before)
{
break;
}
TriggerStruct tskill = _skill;
if (tskill.Times != 1)
{
tskill.Times = 1; //make sure times == 1
}
TriggerSkill trskill = Engine.GetTriggerSkill(tskill.SkillName);
if (trskill != null)
{
if (trigger_who.ContainsKey(_p))
{
trigger_who[_p].Add(tskill);
}
else
{
trigger_who[_p] = new List <TriggerStruct> {
tskill
}
};
}
}
}
}
else
{
break;
}
}
}
foreach (TriggerStruct already_s in already_triggered[p])
{
List <TriggerStruct> who_skills_q = trigger_who.ContainsKey(p) ? new List <TriggerStruct>(trigger_who[p]) : new List <TriggerStruct>();
foreach (TriggerStruct re_skill in who_skills_q)
{
if (already_s.Equals(re_skill)) //类似铁骑、烈弓多目标的触发技
{ //筛选剩余未发动的目标
if (already_s.Targets.Count > 0 && re_skill.Targets.Count > 0 && re_skill.Targets.Contains(already_s.ResultTarget))
{
List <string> targets = new List <string>(re_skill.Targets);
for (int i = 0; i <= targets.IndexOf(already_s.ResultTarget); i++)
{
re_skill.Targets.Remove(targets[i]);
}
if (re_skill.Targets.Count > 0)
{
TriggerStruct re_skill2 = already_s;
re_skill2.Targets = re_skill.Targets;
re_skill2.ResultTarget = null;
trigger_who[p][trigger_who[p].IndexOf(re_skill)] = re_skill2;
break;
}
}
trigger_who[p].Remove(re_skill);
break;
}
}
}
}
if (broken)
{
break;
}
}
}
if (broken)
{
break;
}
} while (skill_table.ContainsKey(triggerEvent) && skill_table[triggerEvent].Count != triggerable_tested.Count && string.IsNullOrEmpty(room.PreWinner));
// @todo_Slob: for drawing cards when game starts -- stupid design of triggering no player!
if (!broken && trigger_who.ContainsKey(rule_player) && trigger_who[rule_player].Count > 0)
{
List <TriggerStruct> triggers = new List <TriggerStruct>(trigger_who[rule_player]);
foreach (TriggerStruct s in triggers)
{
if (!string.IsNullOrEmpty(room.PreWinner))
{
break;
}
TriggerSkill skill = null;
foreach (TriggerSkill rule in rules)
{ // because we cannot get a GameRule with Engine::getTriggerSkill()
if (rule.Name == s.SkillName)
{
skill = rule;
break;
}
}
TriggerStruct skill_cost = skill.Cost(triggerEvent, room, target, ref data, null, s);
if (!string.IsNullOrEmpty(skill_cost.SkillName))
{
broken = skill.Effect(triggerEvent, room, target, ref data, null, skill_cost);
if (broken)
{
break;
}
}
}
}
foreach (TrustedAI ai in room.AIs)
{
ai.Event(triggerEvent, target, data);
}
//Bot聊天
Bot.BotChat(triggerEvent, room, target, data);
//成就
AchieveCollector.Event(triggerEvent, room, target, data);
// pop event stack
//event_stack.pop_back();
//room->tryPause();
trigger_count.Remove(trigger_id);
return(broken);
}
public override bool IsEnabledAtPlay(Room room, Player player)
{
return(RoomLogic.CanDiscard(room, player, player, "he") && !player.HasUsed("ZhihengCard") &&
!RoomLogic.PlayerHasShownSkill(room, player, "zhiheng"));
}
public override void OnUse(Room room, CardUseStruct card_use)
{
if (card_use.To.Count == 0)
{
DoRecast(room, card_use);
}
else
{
Player player = card_use.From;
CardUseStruct use = new CardUseStruct(card_use.Card, player, new List <Player>());
List <Player> targets = new List <Player>();
Game3v3Camp camp = card_use.To[0].Camp;
foreach (Player p in room.GetAlivePlayers())
{
if (player.Camp == camp && p.Camp == camp && p.Chained)
{
targets.Add(p);
}
else if (player.Camp != camp && p.Camp == camp && !p.Chained)
{
targets.Add(p);
}
}
foreach (Player p in targets)
{
Skill skill = Engine.IsProhibited(room, player, p, card_use.Card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = p.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, p, skill))
{
room.NotifySkillInvoked(p, skill.Name);
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, p, skill.Name);
string genral = gsk.General;
int skin_id = gsk.SkinId;
string skill_name = skill.Name;
int audio = -1;
skill.GetEffectIndex(room, p, card_use.Card, ref audio, ref skill_name, ref genral, ref skin_id);
if (audio >= -1)
{
room.BroadcastSkillInvoke(skill_name, "male", audio, genral, skin_id);
}
}
}
else
{
use.To.Add(p);
}
}
room.SortByActionOrder(ref use);
base.OnUse(room, use);
}
}
public static void OnPlayStart(Room room, Player player)
{
List <Client> ais = new List <Client>();
foreach (Client client in room.Clients)
{
if (client.UserID < 0)
{
ais.Add(client);
}
}
if (ais.Count == 0)
{
return;
}
DataRow[] rows = Engine.GetStarPlayLines();
foreach (DataRow row in rows)
{
string str = row["skills"].ToString();
bool check = false;
string[] skills = str.Split('|');
foreach (string skill in skills)
{
bool _check = true;
foreach (string _skill in skill.Split('+'))
{
if (!RoomLogic.PlayerHasShownSkill(room, player, _skill))
{
_check = false;
break;
}
}
if (_check)
{
check = true;
break;
}
}
if (check)
{
foreach (Client ai in ais)
{
//几率1/3聊天
if (Shuffle.random(1, 3))
{
//50%随机是发言还是表情
bool speak = Shuffle.random(1, 2);
if (room.Setting.SpeakForbidden)
{
speak = false;
}
//50%随机
int num = Shuffle.random(1, 2) ? 1 : 2;
if (room.GetClient(player) == ai)
{
if (speak)
{
string message = row[string.Format("self_lines{0}", num)].ToString();
if (!string.IsNullOrEmpty(message))
{
room.Speak(ai, message);
}
}
else
{
string messages = row[string.Format("self_emotion{0}", num)].ToString();
if (!string.IsNullOrEmpty(messages))
{
string[] ms = messages.Split('/');
room.Emotion(ai, ms[0], ms[1]);
}
}
}
else
{
if (speak)
{
string message = row[string.Format("lines{0}", num)].ToString();
if (!string.IsNullOrEmpty(message))
{
room.Speak(ai, message);
}
}
else
{
string messages = row[string.Format("emotion{0}", num)].ToString();
if (!string.IsNullOrEmpty(messages))
{
string[] ms = messages.Split('/');
room.Emotion(ai, ms[0], ms[1]);
}
}
}
}
}
}
}
}
public override void OnNullified(Room room, Player target, WrappedCard card)
{
RoomThread thread = room.RoomThread;
string card_str = RoomLogic.CardToString(room, card);
bool move = false;
Player p = null;
if (movable)
{
List <Player> players = new List <Player>();
List <Player> count_players = new List <Player>(room.Players);
Player starter = target;
int index = count_players.IndexOf(starter);
for (int i = index + 1; i < count_players.Count; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
for (int i = 0; i <= index; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
foreach (Player player in players)
{
if (RoomLogic.PlayerContainsTrick(room, player, Name) || !player.JudgingAreaAvailable)
{
continue;
}
Skill skill = RoomLogic.IsProhibited(room, null, player, card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.NotifySkillInvoked(player, skill.Name);
GeneralSkin gsk = RoomLogic.GetGeneralSkin(room, player, skill.Name);
string genral = gsk.General;
int skin_id = gsk.SkinId;
string skill_name = skill.Name;
int audio = -1;
skill.GetEffectIndex(room, player, card, ref audio, ref skill_name, ref genral, ref skin_id);
if (audio >= -1)
{
room.BroadcastSkillInvoke(skill_name, "male", audio, genral, skin_id);
}
}
continue;
}
//if (player.HasFlag(card_str + "_delay_trick_cancel")) continue;
/*
* CardUseStruct use = new CardUseStruct(room.GetCard(card.GetEffectiveId()), null, player)
* {
* EffectCount = new List<CardBasicEffect> { FillCardBasicEffct(room, player) }
* };
* object data = use;
* thread.Trigger(TriggerEvent.TargetConfirming, room, player, ref data);
* CardUseStruct new_use = (CardUseStruct)data;
* if (new_use.To.Count == 0)
* {
* p = player;
* player.SetFlags(card_str + "_delay_trick_cancel");
* break;
* }
*
* thread.Trigger(TriggerEvent.TargetChosen, room, null, ref data);
* thread.Trigger(TriggerEvent.TargetConfirmed, room, player, ref data);
*/
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_TRANSFER, string.Empty)
{
Card = card
};
room.MoveCardTo(card, null, player, Place.PlaceDelayedTrick, reason, true);
move = true;
break;
}
}
if (p != null)
{
OnNullified(room, p, card);
}
else if (!move)
{
//foreach (Player player in room.GetAllPlayers())
//if (player.HasFlag(RoomLogic.CardToString(room, card) + "_delay_trick_cancel"))
//player.SetFlags(string.Format("-{0}{1}", card_str, "_delay_trick_cancel"));
CardMoveReason reason = new CardMoveReason(MoveReason.S_REASON_NATURAL_ENTER, string.Empty);
room.MoveCardTo(card, null, Place.DiscardPile, reason, true);
}
}
public override void Use(TrustedAI ai, Player player, ref CardUseStruct use, WrappedCard card)
{
Room room = ai.Room;
List <ScoreStruct> scores = new List <ScoreStruct>();
foreach (Player p in room.GetOtherPlayers(player))
{
if (!RoomLogic.InMyAttackRange(room, p, player) || p.IsNude())
{
continue;
}
ScoreStruct score = ai.FindCards2Discard(player, p, "he", HandlingMethod.MethodDiscard);
score.Players = new List <Player> {
p
};
if (ai.IsEnemy(p))
{
if (p.HandcardNum + p.GetPile("wooden_ox").Count < 3 || ai.IsLackCard(p, Slash.ClassName))
{
score.Score += 3;
}
else
{
bool armor_ignore = false;
if (p.HasWeapon(QinggangSword.ClassName) || ai.HasSkill("jianchu", p))
{
armor_ignore = true;
}
else if (ai.HasSkill("paoxiao|paoxiao_fz", p))
{
Player lord = ai.FindPlayerBySkill("shouyue");
if (lord != null && RoomLogic.PlayerHasShownSkill(room, lord, "shouyue") && RoomLogic.WillBeFriendWith(room, p, lord))
{
armor_ignore = true;
}
}
if (!armor_ignore && ai.HasArmorEffect(player, RenwangShield.ClassName))
{
score.Score += 0.5;
}
if (!armor_ignore && ai.HasArmorEffect(player, EightDiagram.ClassName))
{
score.Score += 0.5;
}
if (ai.HasSkill("wushang", p))
{
score.Score -= 0.5;
}
if (p.HasWeapon(DragonPhoenix.ClassName))
{
score.Score -= 0.5;
}
if (ai.HasSkill("jianchu", p))
{
score.Score = -0.5;
}
if (ai.HasSkill("tieqi|tieqi_fz", p))
{
score.Score = 1;
}
if (ai.GetKnownCardsNums(Jink.ClassName, "he", player) == 0)
{
score.Score -= 2;
}
}
}
scores.Add(score);
}
if (scores.Count > 0)
{
ai.CompareByScore(ref scores);
if (scores[0].Score > 2)
{
use.Card = card;
use.To = new List <Player>(scores[0].Players);
}
}
}
public override void OnNullified(Room room, Player target, WrappedCard card)
{
RoomThread thread = room.RoomThread;
string card_str = RoomLogic.CardToString(room, card);
bool move = false;
Player p = null;
if (movable)
{
List <Player> players = new List <Player>();
List <Player> count_players = new List <Player>(room.Players);
Player starter = target;
int index = count_players.IndexOf(starter);
for (int i = index + 1; i < count_players.Count; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
for (int i = 0; i <= index; i++)
{
if (count_players[i].Alive)
{
players.Add(count_players[i]);
}
}
foreach (Player player in players)
{
if (RoomLogic.PlayerContainsTrick(room, player, Name))
{
continue;
}
Skill skill = RoomLogic.IsProhibited(room, null, player, card);
if (skill != null)
{
skill = Engine.GetMainSkill(skill.Name);
LogMessage log = new LogMessage
{
Type = "#SkillAvoid",
From = player.Name,
Arg = skill.Name,
Arg2 = Name
};
room.SendLog(log);
if (RoomLogic.PlayerHasShownSkill(room, player, skill))
{
room.BroadcastSkillInvoke(skill.Name, player);
room.NotifySkillInvoked(player, skill.Name);
}
continue;
}
if (player.HasFlag(card_str + "_delay_trick_cancel"))
{
continue;
}
CardUseStruct use = new CardUseStruct(room.GetCard(card.GetEffectiveId()), null, player);
object data = use;
thread.Trigger(TriggerEvent.TargetConfirming, room, player, ref data);
CardUseStruct new_use = (CardUseStruct)data;
if (new_use.To.Count == 0)
{
p = player;
player.SetFlags(card_str + "_delay_trick_cancel");
break;
}
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_TRANSFER, string.Empty)
{
CardString = RoomLogic.CardToString(room, card)
};
room.MoveCardTo(card, null, player, Place.PlaceDelayedTrick, reason, true);
move = true;
foreach (Player p2 in room.GetAllPlayers())
{
thread.Trigger(TriggerEvent.TargetChosen, room, p2, ref data);
}
foreach (Player p2 in room.GetAllPlayers())
{
thread.Trigger(TriggerEvent.TargetConfirmed, room, p2, ref data);
}
break;
}
}
if (p != null)
{
OnNullified(room, p, card);
}
else if (!move)
{
foreach (Player player in room.GetAllPlayers())
{
if (player.HasFlag(RoomLogic.CardToString(room, card) + "_delay_trick_cancel"))
{
player.SetFlags(string.Format("-{0}{1}", card_str, "_delay_trick_cancel"));
}
}
CardMoveReason reason = new CardMoveReason(CardMoveReason.MoveReason.S_REASON_NATURAL_ENTER, string.Empty);
room.MoveCardTo(card, null, Place.DiscardPile, reason, true);
}
}
