public Major(CardSelector cardSelector, GameState gameState)
{
_cardSelector = cardSelector;
_simpleAttackStrategy = new SimpleAttackStrategy(gameState);
_finishHimStrategy = new FinishHimStrategy(gameState);
_gameState = gameState;
}
public ApplyModifiersToPermanents(
CardSelector selector,
params CardModifierFactory[] modifiers)
{
_selector = selector ?? delegate { return(true); };
_modifiers.AddRange(modifiers);
}
private static void Mixed()
{
Killsteal();
if (CardSelector.Status == SelectStatus.Selected)
{
Orbwalker.ForceTarget(Target);
}
if (Target == null || !W.IsInRange(Target))
{
var allMinions = MinionManager.GetMinions(Player.Position, Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
if (allMinions.Count < 1) return;
foreach (var minion in allMinions)
{
if (Damage.GetAutoAttackDamage(Player, Target, true) > minion.Health && Orbwalker.InAutoAttackRange(minion))
{
Orbwalker.ForceTarget(minion);
}
}
}
else
{
if (IsInvul(Target))
{
CardSelector.StartSelecting(Cards.Yellow);
}
if (Q.IsReady() && Player.Mana >= 160) {
Q.CastOnBestTarget(0f, false, true);
}
Orbwalker.ForceTarget(Target);
}
}
public OnZoneChanged(Zone @from = Zone.None, Zone to = Zone.None,
CardSelector selector = null)
{
_from = from;
_to = to;
_selector = selector ?? ((card, ctx) => ctx.OwningCard == card);
}
/// <summary>
/// Called when the AI has to select one or more cards.
/// </summary>
/// <param name="cards">List of available cards.</param>
/// <param name="min">Minimal quantity.</param>
/// <param name="max">Maximal quantity.</param>
/// <param name="cancelable">True if you can return an empty list.</param>
/// <returns>A new list containing the selected cards.</returns>
public IList <ClientCard> OnSelectCard(IList <ClientCard> cards, int min, int max, bool cancelable)
{
// Check for the executor.
IList <ClientCard> result = Executor.OnSelectCard(cards, min, max, cancelable);
if (result != null)
{
return(result);
}
// Update the next selector.
CardSelector selector = GetSelectedCards();
// If we selected a card, use this card.
if (selector != null)
{
return(selector.Select(cards, min, max));
}
// Always select the first available cards and choose the minimum.
IList <ClientCard> selected = new List <ClientCard>();
for (int i = 0; i < min; ++i)
{
selected.Add(cards[i]);
}
return(selected);
}
public ApplyModifiersToPermanents(
CardSelector selector,
CardModifierFactory modifier)
{
_selector = selector ?? delegate { return(true); };
_modifiers.Add(modifier);
}
internal static void Execute()
{
var wMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).SData.Mana;
if (ObjectManager.Player.Mana >= wMana)
{
if (Config.IsKeyPressed("csYellow") &&
(!Keyboard.IsKeyDown(Key.LeftShift) && !Keyboard.IsKeyDown(Key.LeftCtrl) &&
!Keyboard.IsKeyDown(Key.LeftAlt)))
{
CardSelector.StartSelecting(Cards.Yellow);
}
if (Config.IsKeyPressed("csBlue") &&
(!Keyboard.IsKeyDown(Key.LeftShift) && !Keyboard.IsKeyDown(Key.LeftCtrl) &&
!Keyboard.IsKeyDown(Key.LeftAlt)))
{
CardSelector.StartSelecting(Cards.Blue);
}
if (Config.IsKeyPressed("csRed") &&
(!Keyboard.IsKeyDown(Key.LeftShift) && !Keyboard.IsKeyDown(Key.LeftCtrl) &&
!Keyboard.IsKeyDown(Key.LeftAlt)))
{
CardSelector.StartSelecting(Cards.Red);
}
}
}
public void ServerStartCardSelection(PlayerController src, int seed1, int seed2, int seed3, CardGenerationFlags flags)
{
CardSelector cardSelector = GameUtils.GetCardSelector();
cardSelector.SetCardSelection(this, src, seed1, seed2, seed3, flags);
cardSelector.ShowSelections(this);
RpcStartCardSelection(src.netIdentity, seed1, seed2, seed3, flags);
}
public void RpcStartCardSelection(NetworkIdentity src, int seed1, int seed2, int seed3, CardGenerationFlags flags)
{
if (!isServerOnly)
{
CardSelector cardSelector = GameUtils.GetCardSelector();
cardSelector.SetCardSelection(this, src.GetComponent <PlayerController>(), seed1, seed2, seed3, flags);
cardSelector.ShowSelections(this);
}
}
private void Awake()
{
playerController = FindObjectOfType <PlayerController>();
aiControl = FindObjectOfType <AIControl>();
cardHand = FindObjectOfType <CardHand>();
cardCreator = FindObjectOfType <CardSelector>();
powerCounter = FindObjectOfType <PowerCounter>();
winScreen = FindObjectOfType <WinScreen>();
}
private void Init()
{
if (s_Instance == null)
{
s_Instance = this;
}
else
{
Destroy(gameObject);
}
}
public CardSelector GetSelectedCards()
{
CardSelector selected = null;
if (this.selector.Count > 0)
{
selected = this.selector[this.selector.Count - 1];
this.selector.RemoveAt(this.selector.Count - 1);
}
return(selected);
}
public ModifyPowerToughnessForEachPermanent(int?power, int?toughness, CardSelector filter,
Func <IntegerModifier> modifier, ControlledBy controlledBy = ControlledBy.SpellOwner)
{
_modifyPower = power;
_modifyToughness = toughness;
_filter = filter;
_controlledBy = controlledBy;
_toughnessModifier = modifier();
_powerModifier = modifier();
}
public CardSelector GetSelectedCards()
{
CardSelector selected = null;
if (m_selector.Count > 0)
{
selected = m_selector[m_selector.Count - 1];
m_selector.RemoveAt(m_selector.Count - 1);
}
return(selected);
}
void Start()
{
selectionTool = FindObjectOfType <SelectionTool>();
cardCreator = FindObjectOfType <CardSelector>();
selectionPanel = FindObjectOfType <SelectionPanel>();
selectionPanel.gameObject.SetActive(false);
cameraRaycaster = FindObjectOfType <CameraRaycaster>();
cameraRaycaster.layerChangeObservers += OnPathChange;
Orange = new Color(1, 0.5f, 0, 1);
pauseScreen = FindObjectOfType <PauseScreen>();
pauseScreen.gameObject.SetActive(false);
}
public DestroyAllPermanents(
CardSelector filter = null,
bool allowToRegenerate = true)
{
_allowToRegenerate = allowToRegenerate;
_filter = filter;
SetTags(EffectTag.Destroy);
if (!allowToRegenerate)
{
SetTags(EffectTag.CannotRegenerate);
}
}
void Awake()
{
if (gm != null)
{
Debug.Log("Failed Singleton Design");
}
else
{
gm = this;
}
mainCamera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();
cardSelector = GameObject.FindGameObjectWithTag("CardSelector").GetComponent <CardSelector>();
}
internal static void Execute()
{
var target = TargetSelector.GetTarget(Spells.Q.Range, TargetSelector.DamageType.Magical);
if (target == null || !target.IsValidTarget(Spells.Q.Range) ||
ObjectManager.Player.ManaPercent < Config.GetSliderValue("manaToHarass"))
{
return;
}
var qMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).SData.Mana;
var wMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).SData.Mana;
var wManaP = wMana / ObjectManager.Player.Mana;
if (target.Distance(ObjectManager.Player) <= ObjectManager.Player.AttackRange + 100 &&
ObjectManager.Player.Mana >= wMana && Spells.W.IsReady() && Config.IsChecked("useWHarass"))
{
switch (Config.GetStringListValue("wModeH"))
{
case 0:
CardSelector.StartSelecting(
ObjectManager.Player.ManaPercent < Config.GetSliderValue("manaToHarass") + 10 + wManaP
? Cards.Blue
: Cards.Yellow);
break;
case 1:
CardSelector.StartSelecting(Cards.Yellow);
break;
case 2:
CardSelector.StartSelecting(Cards.Blue);
break;
case 3:
CardSelector.StartSelecting(Cards.Red);
break;
}
}
if (Config.IsChecked("useQHarass") && Spells.Q.IsReady())
{
var qPred = Spells.Q.GetPrediction(target);
if (ObjectManager.Player.Mana >= qMana && qPred.Hitchance >= HitChance.High)
{
Spells.Q.Cast(qPred.CastPosition);
}
}
}
public CardSelector GetSelectedCards()
{
CardSelector selected = m_selector;
if (m_nextSelector != null)
{
m_selector = m_nextSelector;
m_nextSelector = null;
}
else
{
m_selector = null;
}
return(selected);
}
internal static void Execute()
{
var wMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).ManaCost;
switch (CardSelector.Status)
{
case SelectStatus.Ready:
{
if (ObjectManager.Player.Mana >= wMana)
{
if (Config.GoldKey)
{
CardSelector.StartSelecting(Cards.Yellow);
}
else if (Config.BlueKey)
{
CardSelector.StartSelecting(Cards.Blue);
}
else if (Config.RedKey)
{
CardSelector.StartSelecting(Cards.Red);
}
}
break;
}
case SelectStatus.Selecting:
{
if (Config.GoldKey)
{
CardSelector.JumpToCard(Cards.Yellow);
}
else if (Config.BlueKey)
{
CardSelector.JumpToCard(Cards.Blue);
}
else if (Config.RedKey)
{
CardSelector.JumpToCard(Cards.Red);
}
break;
}
}
}
public GUI(GraphicsDevice g, ContentManager c)
{
this.g = g;
this.c = c;
waveInfo = new WaveInfo("waveInfo", Rectangle.Empty);
cardSelector = new CardSelector("cardSel", new Rectangle(1000, 1000, 0, 0));
worldSelector = new WorldSelector("select", Rectangle.Empty);
manaHandler = new ManaHandler("manaHandler", Rectangle.Empty);
addGuiItem(manaHandler);
addGuiItem(waveInfo);
addGuiItem(cardSelector);
addGuiItem(worldSelector);
}
public SearchLibraryPutToZone(Zone zone, EffectAction <Card> afterPutToZone = null,
int maxCount = 1, int minCount = 0, CardSelector validator = null,
string text = null, bool revealCards = true, DynParam <Player> player = null,
CardOrder rankingAlgorithm = null)
{
_validator = validator ?? delegate { return(true); };
_player = player ?? new DynParam <Player>((e, g) => e.Controller, EvaluateAt.OnResolve);
_text = text ?? "Search your library for a card.";
_zone = zone;
_afterPutToZone = afterPutToZone ?? delegate { };
_revealCards = revealCards;
_rankingAlgorithm = rankingAlgorithm ?? ((c, ctx) => - c.Score);
_maxCount = maxCount;
_minCount = minCount;
RegisterDynamicParameters(_player);
}
private static void LaneClear()
{
Killsteal();
Orbwalker.ActiveMode = Orbwalking.OrbwalkingMode.LaneClear;
var allMinions = MinionManager.GetMinions(Player.Position, Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
var lowHealtMinis = ObjectManager.Get<Obj_AI_Base>().Where(mini => mini.IsMinion && mini.IsEnemy && mini.Health < Q.GetDamage(mini));
var bestPosition = Q.GetLineFarmLocation(lowHealtMinis.ToList()); //Get the location of the highest hit
if (allMinions.Count < 1) return;
foreach (var minion in allMinions)
{
if (CardSelector.Status == SelectStatus.Selected)
{
Orbwalker.ForceTarget(minion);
}
if (Q.IsReady() && Player.Mana >= 160)
{
if (bestPosition.Position.IsValid())
{
if (bestPosition.MinionsHit >= 2)
{
Q.Cast(bestPosition.Position, false);
}
}
}
else if(Player.Mana > 100 && W.IsInRange(minion) && W.IsReady())
{
Console.WriteLine("Red card minion");
CardSelector.StartSelecting(Cards.Red);
}
else if (Player.Mana <= 100 && W.IsInRange(minion) && W.IsReady())
{
Console.WriteLine("Blue card minion");
CardSelector.StartSelecting(Cards.Blue);
}
else
{
Orbwalker.ForceTarget(minion);
}
}
}
private static void Combo()
{
if (Target == null || !detectCollision(Target))
{
Console.WriteLine("Noone in range");
return;
}
Killsteal();
if (CardSelector.Status == SelectStatus.Selected)
{
Orbwalker.ForceTarget(Target);
}
if (IsInvul(Target) && W.IsInRange(Target))
{
Console.WriteLine("use yellow");
CardSelector.StartSelecting(Cards.Yellow);
}
if (GetBool("UseIgnite") && CanIgnite() && GetDistance(Target) <= 300 && GetComboDamage(Target) >= (double)Target.Health)
{
Player.Spellbook.CastSpell(IgniteSlot, Target);
}
if (Q.IsReady() && Q.CastIfHitchanceEquals(Target, Q.MinHitChance))
{
Console.WriteLine("throw Q");
Q.CastOnBestTarget(0f, false, true;
}
else if (W.IsInRange(Target) && W.IsReady())
{
Console.WriteLine("use yellow");
CardSelector.StartSelecting(Cards.Yellow);
}
else
{
Console.WriteLine("AA");
Orbwalker.ForceTarget(Target);
}
}
static void Main(string[] args)
{
string[] inputs;
_turnCount = 0;
_cardSelector = new CardSelector();
// game loop
while (true)
{
for (int i = 0; i < 2; i++)
{
inputs = Console.ReadLine().Split(' ');
if (i == 0)
{
_playerStats = new PlayerStats(inputs);
}
else
{
_enemyStats = new PlayerStats(inputs);
}
}
int opponentHand = int.Parse(Console.ReadLine());
int cardCount = int.Parse(Console.ReadLine());
var cards = new Deck(_playerStats);
for (int i = 0; i < cardCount; i++)
{
inputs = Console.ReadLine().Split(' ');
cards.Add(new Card(inputs, i));
}
var gameState = new GameState(cards, _playerStats, _enemyStats);
var major = new Major(_cardSelector, gameState);
major.Play(_turnCount);
_turnCount++;
}
}
internal static void Execute()
{
var wMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).SData.Mana;
foreach (var enemy in HeroManager.Enemies.Where(e => !e.IsDead))
{
if (Config.CanKillW && enemy.IsKillableAndValidTarget(Spells._w.GetDamage(enemy), Spells._w.DamageType, Orbwalking.GetRealAutoAttackRange(ObjectManager.Player) + 200))
{
if (Spells._w.IsReadyPerfectly())
{
if (CardSelector.Status == SelectStatus.Ready)
{
CardSelector.StartSelecting(Cards.First);
}
}
if (CardSelector.Status == SelectStatus.Selecting)
{
CardSelector.JumpToCard(Cards.First);
}
}
else if (Config.UseGoldCombo)
{
if (Spells._w.IsReadyPerfectly())
{
if (CardSelector.Status == SelectStatus.Ready)
{
CardSelector.StartSelecting(Cards.Yellow);
}
}
if (CardSelector.Status == SelectStatus.Selecting)
{
CardSelector.JumpToCard(Cards.Yellow);
}
}
}
}
private static void Killsteal()
{
if (Target == null) return;
if(CardSelector.Status == SelectStatus.Selected && W.IsKillable(Target)){
Orbwalker.ForceTarget(Target);
}
if (Orbwalker.InAutoAttackRange(Target) && Target.Health <= Damage.GetAutoAttackDamage(Player, Target, true) && Orbwalker.InAutoAttackRange(Target))
{
Console.WriteLine("KS");
Orbwalker.SetAttack(true);
}
else if (Q.IsKillable(Target) && Q.IsReady())
{
Console.WriteLine("KS");
Q.SetSkillshot(Q.Delay, Q.Width, Q.Speed, false, SkillshotType.SkillshotLine, Q.From, Q.RangeCheckFrom);
Q.CastOnBestTarget(0f, false, true);
}
else if (W.IsKillable(Target) && W.IsReady() && W.IsInRange(Target))
{
CardSelector.StartSelecting(Cards.Blue);
}
}
public override void Game_OnUpdate(EventArgs args)
{
base.Game_OnUpdate(args);
if (Player.ManaPercentage() > 20)
{
CastSpell(Q, qData);
}
TargetSelector.Mode = TargetSelector.TargetingMode.Closest;
target = TargetSelector.GetTarget(Orbwalking.GetRealAutoAttackRange(Player), TargetSelector.DamageType.Physical);
if (target != null)
{
if (Player.ManaPercentage() <= 20)
{
CardSelector.StartSelecting(Cards.Blue);
}
else
{
CardSelector.StartSelecting(Cards.Yellow);
}
}
}
internal static void Execute()
{
if (ObjectManager.Player.ManaPercent < Config.GetSliderValue("manaToLC"))
{
return;
}
if (Config.IsChecked("useWinLC") && Spells.W.IsReady())
{
var targetMinion = Mainframe.Orbwalker.GetTarget() as Obj_AI_Minion;
if (targetMinion != null)
{
switch (Config.GetStringListValue("wModeLC"))
{
case 0:
var combinedManaPercent = ObjectManager.Player.MaxMana
/ (ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).SData.Mana
+ ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).SData.Mana);
if (ObjectManager.Player.ManaPercent
>= Math.Max(45, Config.GetSliderValue("manaToLC") + 10 + combinedManaPercent))
{
/*var targetAoE =
* ObjectManager.Get<Obj_AI_Minion>()
* .Where(x => x.IsEnemy)
* .Count(x => x.Distance(targetMinion) <= 250);*/
var targetAoE = MinionManager.GetMinions(targetMinion.Position, 250).Count;
if (targetAoE > 2)
{
CardSelector.StartSelecting(Cards.Red);
}
}
else
{
CardSelector.StartSelecting(Cards.Blue);
}
break;
case 1:
CardSelector.StartSelecting(Cards.Yellow);
break;
case 2:
CardSelector.StartSelecting(Cards.Blue);
break;
case 3:
CardSelector.StartSelecting(Cards.Red);
break;
}
}
}
if (Config.IsChecked("useQinLC") && Spells.Q.IsReady())
{
var minions = MinionManager.GetMinions(ObjectManager.Player.Position, Spells.Q.Range).Where(x => x.Type == GameObjectType.obj_AI_Minion && x.Team != ObjectManager.Player.Team).ToList();
if (!minions.Any() || minions.Count < 1)
{
return;
}
var minionPos = minions.Select(x => x.Position.To2D()).ToList();
var farm = MinionManager.GetBestLineFarmLocation(minionPos, Spells.Q.Width, Spells.Q.Range);
if (farm.MinionsHit >= Config.GetSliderValue("qTargetsLC"))
{
Spells.Q.Cast(farm.Position);
}
}
}
internal static void Execute()
{
var wName = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).Name;
var wMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.W).SData.Mana;
var qMana = ObjectManager.Player.Spellbook.GetSpell(SpellSlot.Q).SData.Mana;
//CardsLock
var blueLock = wName.Equals("BlueCardLock", StringComparison.InvariantCultureIgnoreCase);
var redLock = wName.Equals("RedCardLock", StringComparison.InvariantCultureIgnoreCase);
var goldLock = wName.Equals("GoldCardLock", StringComparison.InvariantCultureIgnoreCase);
if (!Config.Rotate)
{
return;
}
foreach (var enemy in HeroManager.Enemies.Where(e => e.IsValidTarget(Spells._q.Range) && !e.IsDead))
{
if (Spells._w.IsReadyPerfectly())
{
if (enemy.Distance(ObjectManager.Player) <= (ObjectManager.Player.AttackRange + Config.RotateRange))
{
if (ObjectManager.Player.ManaPercent >= Config.RotateMana)
{
CardSelector.RotateCards();
}
}
}
if (enemy.Distance(ObjectManager.Player) <= (ObjectManager.Player.AttackRange + Config.RotateLock))
{
if (CardSelector.Status == SelectStatus.Selecting)
{
switch (Config.Prioritize)
{
case 0:
{
//Smart (W->Q)
if (ObjectManager.Player.Mana - wMana - qMana >= wMana)
{
if (Spells._q.IsReadyPerfectly())
{
if (blueLock)
{
CardSelector.JumpToCard(Cards.Red);
}
else if (goldLock)
{
CardSelector.LockCard();
}
else if (redLock)
{
CardSelector.LockCard();
}
}
CardSelector.LockCard();
}
CardSelector.LockCard();
break;
}
case 1:
{
//Prioritize BLUE-GOLD-RED;
if (blueLock)
{
CardSelector.LockCard();
}
else if (goldLock)
{
CardSelector.JumpToCard(Cards.Blue);
}
else if (redLock)
{
CardSelector.LockCard();
}
break;
}
case 2:
{
//Prioritize RED-BLUE-GOLD;
if (blueLock)
{
CardSelector.LockCard();
}
else if (goldLock)
{
CardSelector.JumpToCard(Cards.Red);
}
else if (redLock)
{
CardSelector.LockCard();
}
break;
}
case 3:
{
//Prioritize GOLD-BLUE-RED;
if (blueLock)
{
CardSelector.LockCard();
}
else if (goldLock)
{
CardSelector.LockCard();
}
else if (redLock)
{
CardSelector.JumpToCard(Cards.Yellow);
}
break;
}
case 4:
{
//Prioritize GOLD-RED-BLUE;
if (blueLock)
{
CardSelector.JumpToCard(Cards.Red);
}
else if (goldLock)
{
CardSelector.LockCard();
}
else if (redLock)
{
CardSelector.LockCard();
}
break;
}
}
}
}
}
}
