bool TrySetTarget(HeroPower hero_power, IEntity target)
{
if (!target.CanBeTargeted(hero_power))
{
return(false);
}
return(hero_power.SetTarget(target));
}
bool TryUseHeroPower(HeroPower power)
{
if (power.controller.can_use_hero_power && power.controller.SpendMana(power.mana_cost))
{
return(true);
}
return(false);
}
void Awake()
{
hero_power = GetComponent <HeroPower>();
if (art != null)
{
art.sprite = hero_power.art;
}
}
public HeroPower createHeroPower(string classname, Player p)
{
HeroPower newHeroPower = Instantiate(baseHeroPower) as HeroPower;
HeroPowerCard heroPowerCard = getHeroPowerCardByClassname(classname);
newHeroPower.player = p;
newHeroPower.SetCard(heroPowerCard);
return(newHeroPower);
}
public async Task DeletePowerById(int id)
{
HeroPower power = await _context.HeroPowers.Where(p => p.Id == id).FirstOrDefaultAsync();
int heroId = power.HeroId;
if (power == null)
{
throw new EntityNotFoundException($"There is no Hero Power with id: {id}");
}
_context.HeroPowers.Remove(power);
await _context.SaveChangesAsync();
_heroService.ChangeOverallStrength(heroId);
}
public void LoadHeroPowerFromPrefab(HeroPower prefab)
{
if (prefab == null)
{
return;
}
HeroPower power = Instantiate(prefab);
power.transform.SetParent(hero_power.transform.parent);
power.transform.position = hero_power.transform.position;
power.transform.localScale = hero_power.transform.localScale;
Destroy(hero_power.gameObject);
_hero_power = power;
power.SetController(player);
}
private void addCardToZone(IZone zone, Card card, Controller player)
{
var tags = new Dictionary <GameTag, int>
{
[GameTag.ENTITY_ID] = _game.NextId,
[GameTag.CONTROLLER] = player.PlayerId,
[GameTag.ZONE] = (int)zone.Type
};
IPlayable playable = null;
switch (card.Type)
{
case CardType.MINION:
playable = new Minion(player, card, tags);
break;
case CardType.SPELL:
playable = new Spell(player, card, tags);
break;
case CardType.WEAPON:
playable = new Weapon(player, card, tags);
break;
case CardType.HERO:
tags[GameTag.ZONE] = (int)SabberStoneCore.Enums.Zone.PLAY;
tags[GameTag.CARDTYPE] = card[GameTag.CARDTYPE];
playable = new Hero(player, card, tags);
break;
case CardType.HERO_POWER:
tags[GameTag.COST] = card[GameTag.COST];
tags[GameTag.ZONE] = (int)SabberStoneCore.Enums.Zone.PLAY;
tags[GameTag.CARDTYPE] = card[GameTag.CARDTYPE];
playable = new HeroPower(player, card, tags);
break;
default:
throw new EntityException($"Couldn't create entity, because of an unknown cardType {card.Type}.");
}
zone?.Add(playable);
}
//creates a list of Cards for the CardController to turn into HandCards
//First card is hero
public bool processDecklist(string fileName)
{
try
{
string line;
StreamReader theReader = new StreamReader(fileName, Encoding.Default);
using (theReader)
{
int count = 0;
do
{
line = theReader.ReadLine();
if (line != null)
{
if (count == 0)
{
hero = playerInput.controller.createHero(line, this);
heroPower = playerInput.controller.createHeroPower(hero.card.heroClass, this);
hero.Player = this;
heroPower.player = this;
}
else
{
decklist[count - 1] = CardController.getCardByFilename(line);
}
}
count++;
}while (line != null);
theReader.Close();
return(true);
}
}
catch (Exception e)
{
Console.WriteLine("{0}\n", e.Message);
return(false);
}
}
public void OnHeroPowerClicked()
{
if (OptionsManager.Singleton.options.ContainsKey(careAboutGuid))
{
List <Option> ops = OptionsManager.Singleton.options[careAboutGuid];
if (ops.Count == 1)
{
HeroPower hp = ops[0] as HeroPower;
if (hp.targetGuid == "-1")
{
//This means that the hero power is a no target power IE: Hunter, Paladin, Warlock, Warrior, Rougue, Shamen
OptionsManager.Singleton.PickUpOption(ops[0]);
}
}
else
{
//this means there are target, working on that one
}
}
}
public async Task ChangeMainPower(MainPowerChangeDto dto)
{
if (dto.HeroPowerId < 1)
{
throw new ArgumentException("Invalid id");
}
var heroPower = await _context.HeroPowers.Include(hp => hp.Hero).ThenInclude(h => h.MainPower).FirstOrDefaultAsync(hp => hp.Id == dto.HeroPowerId);
var hero = heroPower.Hero;
HeroPower mainPower = null;
if (hero.MainPower != null)
{
mainPower = new HeroPower()
{
Strength = hero.MainPower.Strength,
Hero = hero,
HeroId = hero.Id,
Power = hero.MainPower.Power,
PowerId = hero.MainPower.PowerId,
LastTrainingTime = hero.MainPower.LastTrainingTime
};
}
hero.MainPower = null;
_context.Update(hero);
await _context.SaveChangesAsync();
if (!dto.IsMainPower)
{
return;
}
hero.MainPower = heroPower;
if (mainPower != null)
{
hero.Powers.Append(mainPower);
}
_context.Update(hero);
await _context.SaveChangesAsync();
}
public override TaskState Process()
{
// get a new class
CardClass randClass = 0;
do
{
randClass = (CardClass)Random.Next(2, 11);
} while (randClass == CardClass.WARLOCK);
// replace Hero Power
Card heroPowerCard = null;
switch (randClass)
{
case CardClass.DRUID:
heroPowerCard = Cards.FromId("CS2_017");
break;
case CardClass.HUNTER:
heroPowerCard = Cards.FromId("DS1h_292");
break;
case CardClass.MAGE:
heroPowerCard = Cards.FromId("CS2_034");
break;
case CardClass.PALADIN:
heroPowerCard = Cards.FromId("CS2_101");
break;
case CardClass.PRIEST:
heroPowerCard = Cards.FromId("CS1h_001");
break;
case CardClass.ROGUE:
heroPowerCard = Cards.FromId("CS2_083b");
break;
case CardClass.SHAMAN:
heroPowerCard = Cards.FromId("CS2_049");
break;
case CardClass.WARRIOR:
heroPowerCard = Cards.FromId("CS2_102");
break;
}
HeroPower heroPower =
(HeroPower)Entity.FromCard(Controller, heroPowerCard, new EntityData.Data
{
{ GameTag.CREATOR, Source.Id },
{ GameTag.ZONE, (int)Zone.PLAY }
});
Controller.SetasideZone.Add(Controller.Hero.HeroPower);
Controller.Hero.HeroPower = heroPower;
var cards = Cards.FormatTypeClassCards(Game.FormatType)[randClass].Where(p => p.Class == randClass && !p.IsQuest).ToArray();
// replace cards in hand
for (int i = 0; i < Controller.HandZone.Count; i++)
{
IPlayable entity = Controller.HandZone[i];
if (entity.Card.Class != CardClass.WARLOCK)
{
continue;
}
Controller.HandZone.Remove(entity);
Controller.SetasideZone.Add(entity);
var tags = new EntityData.Data
{
{ GameTag.ZONE_POSITION, i + 1 },
};
if (Game.History)
{
tags.Add(GameTag.CREATOR, Source.Id);
}
IPlayable newEntity = Entity.FromCard(Controller, Util.Choose(cards), tags, Controller.HandZone, -1, i);
newEntity.NativeTags.Add(GameTag.DISPLAYED_CREATOR, Source.Id);
CostReduceEffect.Apply(newEntity.AuraEffects);
}
// replace cards in deck
for (int i = Controller.DeckZone.Count - 1; i >= 0; i--)
{
IPlayable entity = Controller.DeckZone[i];
if (entity.Card.Class != CardClass.WARLOCK)
{
continue;
}
Card randCard = Util.Choose(cards);
IPlayable newEntity = Entity.FromCard(Controller, randCard, null, Controller.DeckZone);
newEntity.NativeTags.Add(GameTag.DISPLAYED_CREATOR, Source.Id);
//Enchantment.GetInstance(Controller, (IPlayable) Source, newEntity, EnchantmentCard);
Controller.DeckZone.Remove(entity);
Controller.SetasideZone.Add(entity);
CostReduceEffect.Apply(newEntity.AuraEffects);
}
Game.OnRandomHappened(true);
return(TaskState.COMPLETE);
}
public ReplaceHeroPower(HeroPower power)
{
Power = power;
PowerCard = null;
}
private ReplaceHeroPower(HeroPower power, Card cardPower)
{
Power = power;
PowerCard = cardPower;
}
public HeroPowerTriggeredAbility(HeroPower power, TriggeredAbility to_wrap)
{
this.to_wrap = to_wrap;
this.to_wrap.SetSource(power);
}
private static bool IsHeroTurn(int turn, HeroPower power)
{
return (power != null && power.Turn == turn - 1);
}
/// <summary>
/// Creates a zone for the opponent using the specified cards and zone.
/// </summary>
/// <param name="opponent">the controller of the opponent</param>
/// <param name="predictedCards">the predicted cards the zone is populated with</param>
/// <param name="zone">the zone who will be created</param>
/// <param name="setasideZone">the setaside zone</param>
/// <returns>the playables of the zone based on the cards</returns>
private List <IPlayable> createZone(Controller opponent, List <Card> predictedCards,
IZone zone, ref SetasideZone setasideZone)
{
var deck = new List <IPlayable>();
foreach (Card card in predictedCards)
{
var tags = new Dictionary <GameTag, int>();
tags[GameTag.ENTITY_ID] = opponent.Game.NextId;
tags[GameTag.CONTROLLER] = opponent.PlayerId;
tags[GameTag.ZONE] = (int)zone.Type;
IPlayable playable = null;
switch (card.Type)
{
case CardType.MINION:
playable = new Minion(opponent, card, tags);
break;
case CardType.SPELL:
playable = new Spell(opponent, card, tags);
break;
case CardType.WEAPON:
playable = new Weapon(opponent, card, tags);
break;
case CardType.HERO:
tags[GameTag.ZONE] = (int)SabberStoneCore.Enums.Zone.PLAY;
tags[GameTag.CARDTYPE] = card[GameTag.CARDTYPE];
playable = new Hero(opponent, card, tags);
break;
case CardType.HERO_POWER:
tags[GameTag.COST] = card[GameTag.COST];
tags[GameTag.ZONE] = (int)SabberStoneCore.Enums.Zone.PLAY;
tags[GameTag.CARDTYPE] = card[GameTag.CARDTYPE];
playable = new HeroPower(opponent, card, tags);
break;
default:
throw new EntityException($"Couldn't create entity, because of an unknown cardType {card.Type}.");
}
opponent.Game.IdEntityDic.Add(playable.Id, playable);
// add entity to the appropriate zone if it was given
zone?.Add(playable);
if (playable.ChooseOne)
{
playable.ChooseOnePlayables[0] = Entity.FromCard(opponent,
Cards.FromId(playable.Card.Id + "a"),
new Dictionary <GameTag, int>
{
[GameTag.CREATOR] = playable.Id,
[GameTag.PARENT_CARD] = playable.Id
},
setasideZone);
playable.ChooseOnePlayables[1] = Entity.FromCard(opponent,
Cards.FromId(playable.Card.Id + "b"),
new Dictionary <GameTag, int>
{
[GameTag.CREATOR] = playable.Id,
[GameTag.PARENT_CARD] = playable.Id
},
setasideZone);
}
deck.Add(playable);
}
return(deck);
}
