public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int count = player.BattleGroundManager.MechCount + player.MyEnemyPlayer.BattleGroundManager.MechCount;
player.Damage(count * M_SideEffectParam.GetParam_ConstInt("Damage"));
List <int> killMechIds = new List <int>();
foreach (ModuleMech mech in player.BattleGroundManager.Mechs)
{
killMechIds.Add(mech.M_MechID);
}
foreach (ModuleMech mech in player.MyEnemyPlayer.BattleGroundManager.Mechs)
{
killMechIds.Add(mech.M_MechID);
}
player.GameManager.KillMechs(killMechIds);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int healPercent = M_SideEffectParam.GetParam_MultipliedInt("Percent");
if (TargetRange == TargetRange.Self) // 对自身
{
ModuleMech mech = player.BattleGroundManager.GetMech(executorInfo.MechId);
int healValue = (int)Math.Ceiling((float)healPercent * mech.M_MechTotalLife / 100);
player.BattleGroundManager.GetMech(executorInfo.MechId).Heal(healValue);
}
else
{
player.GameManager.SideEffect_ILifeAction(
delegate(ILife life)
{
int healValue = (int)Math.Ceiling((float)healPercent * life.GetTotalLife() / 100);
life.Heal(healValue);
},
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds,
executorInfo.TargetMechIds
);
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int value = M_SideEffectParam.GetParam_MultipliedInt("Damage");
int times = M_SideEffectParam.GetParam_ConstInt("DamageTimes");
player.GameManager.SideEffect_ILifeAction(
delegate(ILife life)
{
for (int i = 0; i < times; i++)
{
life.Damage(value);
}
},
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds,
executorInfo.TargetMechIds
);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int value = M_SideEffectParam.GetParam_MultipliedInt("HealValue");
if (TargetRange == TargetRange.Self) // 对自身
{
player.BattleGroundManager.GetMech(executorInfo.MechId).Heal(value);
}
else
{
player.GameManager.SideEffect_ILifeAction(
delegate(ILife life) { life.Heal(value); },
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds,
executorInfo.TargetMechIds
);
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.SideEffect_ShipAction(
delegate(BattlePlayer sp)
{
int cardCount = M_SideEffectParam.GetParam_ConstInt("CardCount");
int copyCount = M_SideEffectParam.GetParam_MultipliedInt("CopyCount");
if (executorInfo.CardInstanceId != ExecutorInfo.EXECUTE_INFO_NONE)
{
List <int> cardIds = player.HandManager.GetRandomHandCardIds(cardCount, new HashSet <int> {
executorInfo.CardInstanceId
});
foreach (int cardId in cardIds)
{
player.HandManager.GetTempCardsByID(cardId, copyCount);
}
}
},
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int value = M_SideEffectParam.GetParam_MultipliedInt("Energy");
int times = M_SideEffectParam.GetParam_ConstInt("Times");
player.GameManager.SideEffect_ShipAction(
delegate(BattlePlayer sp)
{
for (int i = 0; i < times; i++)
{
sp.AddEnergy(value);
}
},
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds);
return(true);
}
public ExecutorSummary(ExecutorInfo executor_info, string component_id, string host, int port, int uptime_secs) : this() {
this.Executor_info = executor_info;
this.Component_id = component_id;
this.Host = host;
this.Port = port;
this.Uptime_secs = uptime_secs;
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int value = M_SideEffectParam.GetParam_MultipliedInt("AttackValue");
if (value < 0)
{
return(true);
}
if (TargetRange == TargetRange.Self) // 对自身
{
player.GameManager.GetMech(executorInfo.MechId).M_MechAttack += value;
}
else
{
player.GameManager.SideEffect_MechAction(
delegate(ModuleMech mech) { mech.M_MechAttack += value; },
player,
0,
executorInfo.TargetMechIds,
TargetRange,
TargetSelect,
-1
);
}
return(true);
}
public override void Deserialize(DataStream reader)
{
base.Deserialize(reader);
ExecutorInfo = ExecutorInfo.Deserialize(reader);
TriggerTime = (SideEffectExecute.TriggerTime)reader.ReadSInt32();
TriggerRange = (SideEffectExecute.TriggerRange)reader.ReadSInt32();
}
public override bool IsTrigger(ExecutorInfo ei)
{
BattlePlayer player = (BattlePlayer)Player;
if (ei.CardInstanceId != ExecutorInfo.EXECUTE_INFO_NONE)
{
CardBase card = player.HandManager.GetCardByCardInstanceId(ei.CardInstanceId);
if (card != null)
{
if (card.CardInfo.BaseInfo.CardType != CardTypes.Spell && card.CardInfo.BaseInfo.CardType != CardTypes.Energy)
{
return(false);
}
}
}
foreach (SideEffectBase se in PeekSEE.SideEffectBases)
{
if (se is IDamage)
{
if (se.M_SideEffectParam.HasParamCanBeMultiplied())
{
return(true);
}
}
}
return(false);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.SideEffect_ShipAction(
delegate(BattlePlayer sp)
{
CardInfo_Base ci = sp.CardDeckManager.CardDeck.GetFirstCardInfo();
if (ci != null)
{
sp.HandManager.DrawCards(1);
for (int i = 0; i < M_SideEffectParam.GetParam_MultipliedInt("CardCount"); i++)
{
sp.HandManager.GetACardByID(ci.CardID);
}
}
},
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds);
return(true);
}
public void AddMech(CardInfo_Mech mechCardInfo, int mechPlaceIndex, List <int> targetMechIds, int clientMechTempId, int handCardInstanceId)
{
if (BattleGroundIsFull)
{
return;
}
int mechId = BattlePlayer.GameManager.GenerateNewMechId();
BattleGroundAddMechRequest request = new BattleGroundAddMechRequest(BattlePlayer.ClientId, mechCardInfo, mechPlaceIndex, mechId, clientMechTempId);
BattlePlayer.MyClientProxy.BattleGameManager.Broadcast_AddRequestToOperationResponse(request);
ModuleMech mech = new ModuleMech();
mech.M_MechID = mechId;
mech.M_ClientTempMechID = clientMechTempId;
mech.OriginCardInstanceId = handCardInstanceId;
mech.Initiate(mechCardInfo, BattlePlayer);
BattlePlayer.CardDeckManager.CardDeck.AddCardInstanceId(mechCardInfo.CardID, handCardInstanceId);
BattleGroundAddMech(mechPlaceIndex, mech);
ExecutorInfo info = new ExecutorInfo(clientId: BattlePlayer.ClientId, mechId: mechId, targetMechIds: targetMechIds);
if (mechCardInfo.MechInfo.IsSoldier)
{
BattlePlayer.GameManager.EventManager.Invoke(SideEffectExecute.TriggerTime.OnSoldierSummon, info);
}
else
{
BattlePlayer.GameManager.EventManager.Invoke(SideEffectExecute.TriggerTime.OnHeroSummon, info);
}
}
public ExecutorSummary(ExecutorInfo executor_info, string component_id, string host, int port, int uptime_secs) : this()
{
this.Executor_info = executor_info;
this.Component_id = component_id;
this.Host = host;
this.Port = port;
this.Uptime_secs = uptime_secs;
}
public virtual bool Execute(ExecutorInfo eventTriggerInfo)
{
int chance = M_SideEffectParam.GetParam_ConstInt("Chance");
Random r = new Random();
int next = r.Next(0, 100);
return(next < chance);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.ExtraRounds++;
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.KillMechs(ChoiceCount, executorInfo.TargetMechIds, player, TargetRange, TargetSelect, -1);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.RemoveEquipByEquipID(executorInfo.TargetEquipIds[0]);
return(true);
}
public void Read (TProtocol iprot)
{
bool isset_topology_id = false;
bool isset_executors = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Topology_id = iprot.ReadString();
isset_topology_id = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.List) {
{
Executors = new List<ExecutorInfo>();
TList _list223 = iprot.ReadListBegin();
for( int _i224 = 0; _i224 < _list223.Count; ++_i224)
{
ExecutorInfo _elem225;
_elem225 = new ExecutorInfo();
_elem225.Read(iprot);
Executors.Add(_elem225);
}
iprot.ReadListEnd();
}
isset_executors = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_topology_id)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_executors)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
CardBase card = player.HandManager.GetCardByCardInstanceId(executorInfo.CardInstanceId);
if (card != null)
{
card.CardInfo.BaseInfo.IsTemp = true;
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int energyValue = M_SideEffectParam.GetParam_MultipliedInt("Energy");
int finalValue = energyValue * player.GameManager.CountMechsByTargetRange(TargetRange, player);
finalValue = Math.Min(finalValue, player.MyEnemyPlayer.EnergyLeft);
player.AddEnergy(finalValue);
player.MyEnemyPlayer.UseEnergy(finalValue);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
int value = M_SideEffectParam.GetParam_MultipliedInt("Energy");
player.GameManager.SideEffect_ForeachMech(
delegate(int validTargetCount) { player.AddEnergy(value * validTargetCount); },
player,
TargetRange);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer sp = (BattlePlayer)Player;
CardBase ci = sp.HandManager.GetCardByCardInstanceId(executorInfo.CardInstanceId);
if (ci.CardInfo.BaseInfo.Energy >= M_SideEffectParam.GetParam_MultipliedInt("DecValue"))
{
ci.M_Energy -= M_SideEffectParam.GetParam_MultipliedInt("DecValue");
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.MyEnemyPlayer.Damage(M_SideEffectParam.GetParam_MultipliedInt("Value"));
int plus_damage = player.EnergyLeft;
player.UseAllEnergy();
player.MyEnemyPlayer.Damage(plus_damage * M_SideEffectParam.GetParam_MultipliedInt("ValuePlus"));
return(true);
}
public override bool IsTrigger(ExecutorInfo ei)
{
BattlePlayer player = (BattlePlayer)Player;
if (ei.CardInstanceId != ExecutorInfo.EXECUTE_INFO_NONE)
{
CardBase card = player.HandManager.GetCardByCardInstanceId(ei.CardInstanceId);
if (card != null)
{
return(card.CardInfo.BaseInfo.CardType == CardTypes.Spell || card.CardInfo.BaseInfo.CardType == CardTypes.Energy);
}
}
return(false);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
foreach (SideEffectBase se in PeekSEE.SideEffectBases)
{
if (se is IDamage)
{
se.M_SideEffectParam.Factor *= 2;
}
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
ModuleMech mech = player.GameManager.GetMechOnBattleGround(M_SideEffectExecute.M_ExecutorInfo.MechId);
if (mech?.M_Weapon != null)
{
int increase = Math.Min(mech.M_MechWeaponEnergyMax - mech.M_MechWeaponEnergy, M_SideEffectParam.GetParam_MultipliedInt("Energy"));
mech.M_MechWeaponEnergy += increase;
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.PlayerBuffTrigger(M_SideEffectExecute.M_ExecutorInfo.SideEffectExecutorID, this);
foreach (SideEffectBase se in Sub_SideEffect)
{
se.Player = player;
se.M_SideEffectExecute = M_SideEffectExecute;
se.Execute(executorInfo);
}
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.SideEffect_ShipAction(
delegate(BattlePlayer sp) { sp.HandManager.DrawCardsByType((CardTypes)M_SideEffectParam.GetParam_ConstInt("DrawCardType"), M_SideEffectParam.GetParam_MultipliedInt("CardCount")); },
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.SideEffect_ShipAction(
delegate(BattlePlayer sp) { sp.CardDeckManager.RandomInsertTempCard(M_SideEffectParam.GetParam_ConstInt("CardID"), M_SideEffectParam.GetParam_MultipliedInt("CardCount")); },
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
player.GameManager.SideEffect_ShipAction(
delegate(BattlePlayer sp) { sp.AddEnergy(sp.EnergyLeft); },
player,
ChoiceCount,
TargetRange,
TargetSelect,
executorInfo.TargetClientIds);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
BattlePlayer player = (BattlePlayer)Player;
CardFilterTypes dropCardType = (CardFilterTypes)M_SideEffectParam.GetParam_ConstInt("DropCardType");
CardFilterTypes drawCardType = (CardFilterTypes)M_SideEffectParam.GetParam_ConstInt("DrawCardType");
int dropCardCount = player.HandManager.DropCardType(dropCardType, new HashSet <int> {
executorInfo.CardInstanceId
});
player.HandManager.GetTempCardByCardTypes(drawCardType, dropCardCount);
return(true);
}
public override bool Execute(ExecutorInfo executorInfo)
{
if (!base.Execute(executorInfo))
{
return(false);
}
foreach (SideEffectBase se in PeekSEE.SideEffectBases)
{
try
{
se.Execute(executorInfo);
}
catch (Exception e)
{
}
}
return(true);
}
public void Read (TProtocol iprot)
{
bool isset_executor_info = false;
bool isset_component_id = false;
bool isset_host = false;
bool isset_port = false;
bool isset_uptime_secs = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct) {
Executor_info = new ExecutorInfo();
Executor_info.Read(iprot);
isset_executor_info = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.String) {
Component_id = iprot.ReadString();
isset_component_id = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String) {
Host = iprot.ReadString();
isset_host = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Port = iprot.ReadI32();
isset_port = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.I32) {
Uptime_secs = iprot.ReadI32();
isset_uptime_secs = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct) {
Stats = new ExecutorStats();
Stats.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_executor_info)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_component_id)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_host)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_port)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_uptime_secs)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
public void Read (TProtocol iprot)
{
bool isset_storm_id = false;
bool isset_executor_stats = false;
bool isset_time_secs = false;
bool isset_uptime_secs = false;
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Storm_id = iprot.ReadString();
isset_storm_id = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Map) {
{
Executor_stats = new Dictionary<ExecutorInfo, ExecutorStats>();
TMap _map213 = iprot.ReadMapBegin();
for( int _i214 = 0; _i214 < _map213.Count; ++_i214)
{
ExecutorInfo _key215;
ExecutorStats _val216;
_key215 = new ExecutorInfo();
_key215.Read(iprot);
_val216 = new ExecutorStats();
_val216.Read(iprot);
Executor_stats[_key215] = _val216;
}
iprot.ReadMapEnd();
}
isset_executor_stats = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Time_secs = iprot.ReadI32();
isset_time_secs = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.I32) {
Uptime_secs = iprot.ReadI32();
isset_uptime_secs = true;
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
if (!isset_storm_id)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_executor_stats)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_time_secs)
throw new TProtocolException(TProtocolException.INVALID_DATA);
if (!isset_uptime_secs)
throw new TProtocolException(TProtocolException.INVALID_DATA);
}
/// <summary>
/// Gets a proxy to the next executor, using round-robin scheduling.
/// </summary>
/// <param name="executorInfo">[out] executorInfo of the next executor.</param>
/// <returns>Next executor to use.</returns>
/// <exception cref="NoExecutorsAvailableException"/>
/// <exception cref="RemotingException" />
private static IExecutor GetNextExecutor(out ExecutorInfo executorInfo)
{
// Get a snapshot of the current list of Executors
var snapshot = Executors.ToArray(); // Thread-safe
if (snapshot.Length == 0)
throw new NoExecutorsAvailableException();
int order = Interlocked.Increment(ref _orderNumber);
executorInfo = snapshot[order % snapshot.Length].Value;
var executor = (IExecutor)Activator.GetObject(typeof(IExecutor), executorInfo.Uri);
Debug.Assert(RemotingServices.IsTransparentProxy(executor));
return executor;
}
