public override void Apply(string guid)
{
Minion tug = GameState.SummonMinion(guid, Attack(), Durability(), Name, null);
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Random | (int)TargetTypeFlag.Friendly | (int)TargetTypeFlag.Minion,
global::TargetingType.Single
);
Action<string> onEndTurn = (string morphidGuid) => {
if (morphidGuid == tug.MorphidGUID) {
foreach (string minionGuid in req.ChosenTargets(null)) {
GameState.RepairGuid(minionGuid, Repair());
}
}
};
Action<Minion> onDeath = null;
onDeath = (Minion minion) => {
if (minion.GUID == tug.GUID) {
GameStateWatcher.OnEndTurn -= onEndTurn;
GameStateWatcher.OnMinionDeath -= onDeath;
}
};
GameStateWatcher.OnEndTurn += onEndTurn;
GameStateWatcher.OnMinionDeath += onDeath;
}
public override void GlobalApply()
{
TargetingRequirements req = new TargetingRequirements(this);
foreach (string randomGuid in req.AllowedTargets().OrderBy(x => Random.Range(0f, 1f)).Take(3)) {
GameState.FireSetGuid(randomGuid);
}
}
public IEnumerable<string> ChosenTargets(string guid)
{
if (HasFlag(TargetTypeFlag.Random)) {
TargetingRequirements PotentialTargets = new TargetingRequirements(null);
PotentialTargets.TargetFlags = TargetFlags & (~((int)TargetTypeFlag.Random));
PotentialTargets.TargetingType = TargetingType.All;
PotentialTargets.TargetScanner = TargetScanner;
IEnumerable<string> orderedTargets = PotentialTargets.ChosenTargets(guid).OrderBy(x => Random.Range(0f, 1f));
if (orderedTargets.Any()) {
yield return orderedTargets.First();
}
yield break;
}
foreach (Lane lane in GameState.Singleton.Lanes) {
if (LaneAllowed(lane) &&
(TargetingType == TargetingType.All || lane.GUID == guid)
) {
yield return lane.GUID;
}
foreach (Minion minion in lane.Minions) {
if (MinionAllowed(minion) &&
(TargetingType == TargetingType.All || minion.GUID == guid)
) {
yield return minion.GUID;
}
}
}
foreach (Morphid morphid in GameState.Singleton.Morphids) {
if (MorphidAllowed(morphid) &&
(TargetingType == TargetingType.All || morphid.GUID == guid)
) {
yield return morphid.GUID;
}
}
}
public override void GlobalApply()
{
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Friendly | (int)TargetTypeFlag.Minion | (int)TargetTypeFlag.Morphid,
global::TargetingType.All
);
foreach (string guid in req.ChosenTargets(null)) {
GameState.FireSetGuid(guid, false);
}
}
public override void Apply(string guid)
{
TargetingRequirements friendlyMinions = new TargetingRequirements(
(int)TargetTypeFlag.Friendly | (int)TargetTypeFlag.Minion,
global::TargetingType.All
);
GameState.AddEngineSequence(guid, () => {
foreach (string minionGuid in friendlyMinions.AllowedTargets()) {
GameState.BuffMinion(minionGuid, AttackBuff(), 0);
}
});
}
public override void Apply(string guid)
{
TargetingRequirements subReq = new TargetingRequirements(
(int)TargetTypeFlag.Friendly | (int)TargetTypeFlag.Minion,
global::TargetingType.All
);
GameState.AddEngineSequence(guid, () => {
foreach (string minionGuid in subReq.AllowedTargets()) {
GameState.BuffMinion(minionGuid, BuffAttack(), BuffDefense());
}
});
}
public override void Apply(string guid)
{
GameState.AddEngineSequence(guid, () => {
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Friendly | (int)TargetTypeFlag.Minion,
global::TargetingType.All
);
foreach (string minionGuid in req.ChosenTargets(null)) {
GameState.BuffMinion(minionGuid, BuffAttack(), 0);
}
});
}
public override void Apply(string guid)
{
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Random | (int)TargetTypeFlag.Enemy | (int)TargetTypeFlag.Minion,
global::TargetingType.Single
);
GameState.SetResearch(guid, () => {
foreach (string target in req.ChosenTargets(null)) {
GameState.BuffMinion(target, -GameState.ActiveMorphid.Morphium, 0);
}
});
}
public override void Apply(string guid)
{
GameState.SetResearch(guid, () => {
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Random | (int)TargetTypeFlag.Empty | (int)TargetTypeFlag.Lane,
global::TargetingType.Single
);
foreach (string lane in req.ChosenTargets(null))
{
GameState.SummonMinion(lane, AttackMag(), DefenseMag(), Name, new MinionBuilder());
}
});
}
public override void Apply(string guid)
{
GameState.AddEngine(guid, EngineMag());
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Enemy | (int)TargetTypeFlag.Minion,
global::TargetingType.All
);
foreach (string minionGuid in req.ChosenTargets(null))
{
GameState.DestroyMinion(minionGuid);
}
}
public override void Apply(string guid)
{
GameState.SetResearch(guid, () =>
{
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Enemy | (int)TargetTypeFlag.Morphid,
global::TargetingType.All
);
foreach (string morphid in req.ChosenTargets(null))
{
DamageMag.Apply(morphid);
}
});
}
public override void Apply(string guid)
{
Minion minion = GameState.GetMinion(guid);
if (minion != null) {
DamageProvider damage = new DamageProvider(minion.Durability);
TargetingRequirements allMinions = new TargetingRequirements(
(int)TargetTypeFlag.Friendly | (int)TargetTypeFlag.Enemy | (int)TargetTypeFlag.Minion,
global::TargetingType.All
);
foreach (string targetGuid in allMinions.AllowedTargets()) {
damage.Apply(targetGuid, minion.GUID);
}
}
}
public void Process(string pickedGuid)
{
Morphid self = GameState.ActiveMorphid;
if (self.Morphium >= Cost) {
self.Morphium -= Cost;
TargetingRequirements req = new TargetingRequirements(Effect);
IEnumerable<string> targets = req.ChosenTargets(pickedGuid);
if (!targets.Any()) {
throw new TargetingException("Client picked no valid targets for effect: " + Effect.ToString());
}
foreach (string guid in targets) {
Effect.Apply(guid);
}
Effect.GlobalApply();
}
}
public override void Apply(string guid)
{
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Empty | (int)TargetTypeFlag.Random | (int)TargetTypeFlag.Lane,
global::TargetingType.Single
);
Action<string> onEndTurn = (string morphidGuid) => {
if (morphidGuid == guid) {
foreach (string laneGuid in req.ChosenTargets(null)) {
GameState.SummonMinion(laneGuid, Attack(), Defense(), Name, null);
}
}
};
GameStateWatcher.OnEndTurn += onEndTurn;
GameState.Attach(guid, new Attachment() {
Effect = this,
RemainingHealth = Durability(),
OnDestroy = () => {
GameStateWatcher.OnEndTurn -= onEndTurn;
}
}, Slot.Leg);
}
public override void Apply(string guid)
{
Minion waspFactory = GameState.SummonMinion(guid, Attack(), Defense(), Name, null);
TargetingRequirements req = new TargetingRequirements(
(int)TargetTypeFlag.Random | (int)TargetTypeFlag.Empty | (int)TargetTypeFlag.Lane,
global::TargetingType.Single
);
Action<string> onEndTurn = (string morphidGuid) => {
if (morphidGuid == waspFactory.MorphidGUID) {
foreach (string laneGuid in req.ChosenTargets(null)) {
GameState.SummonMinion(laneGuid, WaspAttack(), WaspDefense(), Wasp.NAME, new MinionBuilder() {
Scrounge = true
});
}
}
};
waspFactory.OnDeath += () => {
GameStateWatcher.OnEndTurn -= onEndTurn;
};
GameStateWatcher.OnEndTurn += onEndTurn;
}
public static void Reload(string morphidGuid, Slot slot, string targetGuid)
{
Morphid morphid = GetMorphid(morphidGuid);
if (morphid != null) {
Card comboCard = morphid.CardContainer.GetCard(slot);
if (comboCard != null) {
TargetingRequirements req = new TargetingRequirements(comboCard.Effect);
if (comboCard.Cost > morphid.Morphium || !req.AllowedTargets().Contains(targetGuid)) {
return;
}
morphid.PlayCard(comboCard.GUID, targetGuid);
}
}
}
public void Template()
{
TemplateStatus.Templating = true;
this.Cost = Effect.Cost();
this.Text = Effect.Text;
TargetingRequirements req = new TargetingRequirements(Effect);
this.TargetableGuids = req.AllowedTargets().ToArray();
this.TargetingType = Effect.TargetingType();
TemplateStatus.Templating = false;
}
