private Card RandomEnergyCard()
{
int value = Random.Range(0, 100);
Card card = null;
List <Temp> list = new List <Temp>();
for (int i = 0; i < TBL_ENERGY_CARD.CountEntities; i++)
{
TBL_ENERGY_CARD data = TBL_ENERGY_CARD.GetEntity(i);
EnergyCard c = new EnergyCard(data);
list.Add(new Temp(c.percent, CardType.EnergyCard, c));
}
float cumulative = 0f;
for (int i = 0; i < list.Count; i++)
{
cumulative += list[i].percent;
if (value <= cumulative)
{
card = list[i].card;
break;
}
}
return(card);
}
public void TriggerCardPlayer(EnergyCard card, PokemonCard attachedTo)
{
GameController.Instance.playerHand.RemoveCard(card);
cardImage.sprite = null;
cardImage.rectTransform.localScale = new Vector3(0.1f, 0.1f, 1);
cardImage.color = new Color(cardImage.color.r, cardImage.color.g, cardImage.color.b, 0);
loader.LoadSprite(card, cardImage);
cardImage.rectTransform.LeanAlpha(1.0f, 0.2f);
cardImage.rectTransform.LeanScale(new Vector3(1.0f, 1.0f, 1.0f), 0.25f).setOnComplete(() =>
{
cardImage.rectTransform.LeanScale(new Vector3(0.1f, 0.1f, 0.1f), 0.2f).setDelay(0.25f).setOnComplete(() =>
{
var target = GameController.Instance.GetCardRendererById(attachedTo.Id);
var targetTransform = target.GetComponent <RectTransform>();
cardImage.sprite = energyResourceManager.GetSpriteForEnergyCard(card);
cardImage.color = new Color(cardImage.color.r, cardImage.color.g, cardImage.color.b, 0);
var attachedEnergy = Instantiate(attachedEnergyPrefab, attachedParent.transform);
var energyRectTransform = attachedEnergy.GetComponent <RectTransform>();
energyRectTransform.localPosition = new Vector3(400, 0);
attachedEnergy.transform.SetParent(targetTransform.transform);
attachedEnergy.GetComponent <Image>().sprite = EnergyResourceManager.Instance.GetSpriteForEnergyCard(card);
energyRectTransform.LeanMove(new Vector3(20 * (attachedTo.AttachedEnergy.Count + 1), -targetTransform.rect.height + 20, 0), 0.75f).setEaseOutCirc().setDestroyOnComplete(true).setOnComplete(() =>
{
target.insertAttachedEnergy(card);
GameEventHandler.Instance.EventCompleted();
});
});
});
}
public void AttachedAmountMoreThanDiscard()
{
var effect = new DiscardAttachedEnergy
{
Amount = 1,
TargetingMode = TargetingMode.OpponentActive,
};
var opponent = new Player();
var player = new Player();
opponent.ActivePokemonCard = new PokemonCard(opponent);
var goodCard = new EnergyCard();
INetworkPlayer sub = Substitute.For <INetworkPlayer>();
sub.SendAndWaitForResponse <CardListMessage>(Arg.Any <NetworkMessage>())
.ReturnsForAnyArgs(new CardListMessage()
{
Cards = new List <NetworkId> {
goodCard.Id
}
});
player.SetNetworkPlayer(sub);
opponent.ActivePokemonCard.AttachedEnergy.Add(new EnergyCard());
opponent.ActivePokemonCard.AttachedEnergy.Add(goodCard);
effect.Process(new GameField(), player, opponent, null);
Assert.Single(opponent.ActivePokemonCard.AttachedEnergy);
Assert.Equal(goodCard.Id, opponent.DiscardPile[0].Id);
Assert.Single(opponent.DiscardPile);
}
internal void insertAttachedEnergy(EnergyCard attachedEnergy)
{
var attachedObject = Instantiate(AttachedEnergyPrefab, AttachedEnergyList.transform);
attachedObject.GetComponent <AttachedEnergy>().energyCard = attachedEnergy;
attachedObject.GetComponent <Image>().sprite = EnergyResourceManager.Instance.GetSpriteForEnergyCard(attachedEnergy);
}
public void RetreatActivePokemon_Energy_Removed()
{
var p = new Player();
var card = new PokemonCard(p);
var card2 = new PokemonCard(p);
var energyCard = new EnergyCard()
{
Amount = 1
};
p.Hand.Add(energyCard);
p.SetActivePokemon(card);
p.SetBenchedPokemon(card2);
var game = new GameField()
{
ActivePlayerIndex = 0
};
game.AddPlayer(p);
game.AddPlayer(new Player());
game.PlayEnergyCard(energyCard, p.ActivePokemonCard);
p.RetreatActivePokemon(p.BenchedPokemon.ValidPokemonCards.First(), new List <EnergyCard>(p.ActivePokemonCard.AttachedEnergy), new GameField());
Assert.Equal(card2.Id, p.ActivePokemonCard.Id);
Assert.False(card.AttachedEnergy.Any());
}
internal void StartAttachingEnergy(EnergyCard card)
{
SpecialState = SpecialGameState.AttachingEnergyToPokemon;
currentEnergyCard = card;
infoText.text = "Select a Pokémon to attach your energy to";
EnableButtons();
}
public void OnCancelClick()
{
SpecialState = SpecialGameState.None;
selectFromListPanel.SetActive(false);
if (IsMyTurn)
{
infoText.text = "Your turn!";
}
else
{
infoText.text = "Opponent's turn!";
}
foreach (var card in selectedCards)
{
ToggleCardSelected(GetCardRendererById(card.Id));
}
selectedCards.Clear();
currentDeckFilters.Clear();
currentEnergyCard = null;
currentEvolvingCard = null;
EnableButtons();
}
// 에너지 카드 사용
private float UseEnergyCard(EnergyCard card)
{
guard = 0;
AddEnergy(card.energyIncrease);
return(GameSetting.EnergyCardTime);
}
public void CardPlayed(EnergyCard card, PokemonCard target)
{
if (target.Name.Contains("Blaine") && card.EnergyType == EnergyTypes.Fire)
{
AcceptedRule = true;
TargetId = target.Id;
}
CardsAttachedThisTurn++;
}
private void OnTryAttachEnergy(CardRenderer cardRenderer)
{
PokemonCard pokemon = cardRenderer.card as PokemonCard;
if (pokemon == null || Player.Hand.Contains(pokemon) || !pokemon.Owner.Id.Equals(myId))
{
return;
}
NetworkManager.Instance.gameService.AttachEnergy(gameField.Id, pokemon.Id, currentEnergyCard.Id);
currentEnergyCard = null;
SpecialState = SpecialGameState.None;
infoText.text = string.Empty;
EnableButtons();
}
public void PlayEnergyCard(EnergyCard energyCard, PokemonCard target)
{
if (!EnergyRule.CanPlayEnergyCard(energyCard, target))
{
GameLog.AddMessage("Energy-rule disallowed playing the energy");
return;
}
if (!ActivePlayer.Hand.Contains(energyCard) || ActivePlayer.Hand.Contains(target))
{
GameLog.AddMessage($"{ActivePlayer.NetworkPlayer?.Name} tried something wierd");
return;
}
foreach (var ability in target.TemporaryAbilities)
{
if (ability is DisableEnergyAttachmentAbility)
{
GameLog.AddMessage($"Ability {ability.Name} stops attaching energy to {target.Name}");
return;
}
}
GameLog.AddMessage($"Attaching {energyCard.GetName()} to {target.Name}");
EnergyRule.CardPlayed(energyCard, target);
energyCard.RevealToAll();
target.AttachedEnergy.Add(energyCard);
bool fromHand = false;
if (ActivePlayer.Hand.Contains(energyCard))
{
fromHand = true;
ActivePlayer.Hand.Remove(energyCard);
}
SendEventToPlayers(new EnergyCardsAttachedEvent()
{
AttachedTo = target,
EnergyCard = energyCard
});
energyCard.OnAttached(target, fromHand, this);
PushGameLogUpdatesToPlayers();
}
public void CanAttachOnlyOneNonFireEnergyToBlain(EnergyTypes energyType)
{
var card = new EnergyCard {
EnergyType = energyType
};
var pokemon = new PokemonCard {
Name = "Blaine's Pickachu"
};
var rule = new BlainesEnergyRule();
Assert.True(rule.CanPlayEnergyCard(card, pokemon));
rule.CardPlayed(card, pokemon);
Assert.False(rule.CanPlayEnergyCard(card, pokemon));
}
public void CanAttach2FireToBlainesPokemon()
{
var card = new EnergyCard {
EnergyType = EnergyTypes.Fire
};
var pokemon = new PokemonCard {
Name = "Blaine's Pickachu"
};
var rule = new BlainesEnergyRule();
Assert.True(rule.CanPlayEnergyCard(card, pokemon));
rule.CardPlayed(card, pokemon);
Assert.True(rule.CanPlayEnergyCard(card, pokemon));
}
public void CanOnlyAttachToSameBlainePokemon()
{
var card = new EnergyCard {
EnergyType = EnergyTypes.Fire
};
var pokemon = new PokemonCard {
Name = "Blaine's Pickachu"
};
var pokemon2 = new PokemonCard {
Name = "Blaine's Raichi"
};
var rule = new BlainesEnergyRule();
Assert.True(rule.CanPlayEnergyCard(card, pokemon));
rule.CardPlayed(card, pokemon);
Assert.False(rule.CanPlayEnergyCard(card, pokemon2));
}
public Sprite GetSpriteForEnergyCard(EnergyCard energyCard)
{
if (energyCard.AttachedIconOverridden)
{
switch (energyCard.EnergyOverrideType)
{
case EnergyOverriders.Buzzap:
return(BuzzapIcon);
}
}
if (energyCard.Amount == 2 && energyCard.EnergyType == EnergyTypes.Colorless)
{
return(DoubleColorless);
}
if (!energyCard.IsBasic)
{
return(Special);
}
return(Icons[energyCard.EnergyType]);
}
public PokemonCard(string name, string cardSet, Rarity cardRarity, string cardNumber,
string illustrator, string hp, string stage,
EnergyCard.EnergyType pokemonType,
string evolvedFrom, string abilityName, string abilityText,
List<Move> moveData, EnergyCard.EnergyType weaknessType,
string weaknessAmount, EnergyCard.EnergyType resistanceType,
string resistanceAmount, int retreatCost, string cardUrl, string cardImagePath)
: base(name, cardSet, cardRarity, cardNumber, illustrator, cardUrl, cardImagePath)
{
this.HP = hp;
this.Stage = stage;
this.PokemonType = pokemonType;
this.EvolvedFrom = evolvedFrom;
this.AbilityName = abilityName;
this.AbilityText = abilityText;
this.MoveData = moveData;
this.WeaknessType = weaknessType;
this.WeaknessAmount = weaknessAmount;
this.ResistanceType = resistanceType;
this.ResistanceAmount = resistanceAmount;
this.RetreatCost = retreatCost;
this.CardPrice = CardDownloader.GetPriceOfCard(cardSet, cardNumber);
}
public void EvolveAndAttachEnergy()
{
var game = new GameField();
game.InitTest();
game.GameState = GameFieldState.InTurn;
var player = game.ActivePlayer;
player.TurnsTaken = 32;
var pokemon = new PokemonCard(player)
{
Hp = 100, PokemonName = "Basic", Stage = 0, PlayedThisTurn = false
};
var evolution = new PokemonCard(player)
{
Hp = 100, EvolvesFrom = "Basic", Name = "Evolver", Stage = 1
};
var energyCard = new EnergyCard()
{
Amount = 1, EnergyType = EnergyTypes.Colorless
};
player.ActivePokemonCard = pokemon;
player.Hand.Add(evolution);
player.Hand.Add(energyCard);
game.EvolvePokemon(pokemon, evolution);
Assert.Equal(evolution, player.ActivePokemonCard);
game.PlayEnergyCard(energyCard, evolution);
Assert.Single(evolution.AttachedEnergy);
}
public void DeckSearched()
{
var effect = new SearchDeckForCardEffect()
{
CardType = CardType.Any
};
var player = new Player();
player.Id = NetworkId.Generate();
var target = new EnergyCard();
player.Deck.Cards.Push(target);
player.Deck.Cards.Push(new EnergyCard());
player.Deck.Cards.Push(new EnergyCard());
player.Deck.Cards.Push(new EnergyCard());
player.Deck.Cards.Push(new EnergyCard());
var sub = Substitute.For <INetworkPlayer>();
sub.SendAndWaitForResponse <CardListMessage>(Arg.Any <NetworkMessage>()).ReturnsForAnyArgs(new CardListMessage {
Cards = new List <NetworkId> {
target.Id
}
});
player.SetNetworkPlayer(sub);
var game = new GameField();
game.AddPlayer(player);
effect.Process(game, player, null, null);
Assert.Single(player.Hand);
Assert.Equal(4, player.Deck.Cards.Count);
Assert.Equal(target.Id, player.Hand[0].Id);
}
public bool CanPlayEnergyCard(EnergyCard card, PokemonCard target)
{
if (AcceptedRule && !target.Id.Equals(TargetId))
{
return(false);
}
if (target.Name.Contains("Blaine") && card.EnergyType == EnergyTypes.Fire)
{
if (TargetId != null)
{
return(target.Id.Equals(TargetId));
}
return(CardsAttachedThisTurn < 2);
}
if (AcceptedRule)
{
return(false);
}
return(CardsAttachedThisTurn < 1);
}
public void DiscardEnergyCard(EnergyCard energyCard, GameField game, bool isExtraCost = false)
{
if (!isExtraCost)
{
var preventer = TemporaryAbilities.OfType <EffectPreventer>().FirstOrDefault();
if (preventer != null)
{
game.GameLog.AddMessage($"Discard energy card prevented by {preventer.Name}");
return;
}
}
AttachedEnergy.Remove(energyCard);
Owner.DiscardPile.Add(energyCard);
game?.SendEventToPlayers(new AttachedEnergyDiscardedEvent
{
FromPokemonId = Id,
DiscardedCard = energyCard
});
energyCard.OnPutInDiscard(Owner);
}
public List<string> getListOfPokemon(string name, string text, string evolvesFrom, string cardType,
BaseCard.Rarity rarity, string cardSet, int hp, int retreat, EnergyCard.EnergyType weakness,
EnergyCard.EnergyType resistance, string illustrator)
{
List<string> results = new List<string>();
string cardSetUrl = cardSetSearchDictionary[cardSet];
string queryString = BASE_SEARCH_URL + name + SEARCH_ALL_POKEMON_URL + cardSetUrl;
HtmlDocument doc = web.Load(Uri.EscapeUriString(POKEMON_CARD_URL + queryString));
// Check if the user input returns any results on the website
if (doc.DocumentNode.SelectSingleNode(XPATH_NO_RESULT_FOUND) != null)
{
// Search turned up no results
return null;
}
HtmlNode resultNode = doc.DocumentNode.SelectSingleNode("//*[@id='cardResults']");
string numberOfPages = doc.DocumentNode.SelectSingleNode("//*[@id='cards-load-more']/div/span").InnerText;
string[] stringSplit = numberOfPages.Split();
int pagesToSearch = Int32.Parse(stringSplit[stringSplit.Length - 1]);
if (pagesToSearch > 50)
{
Console.WriteLine("Please enter more search criteria");
return null;
}
for (int i = 1; i <= pagesToSearch; ++i)
{
HtmlNodeCollection resultNodes = resultNode.SelectNodes(".//li/a");
foreach (HtmlNode searchNode in resultNodes)
{
results.Add(searchNode.Attributes["href"].Value);
}
if (i != pagesToSearch)
{
string url = doc.DocumentNode.SelectSingleNode("//*[@id='cards-load-more']/div/a[2]").Attributes["href"].Value;
doc = web.Load(Uri.EscapeUriString(POKEMON_CARD_URL + url));
resultNode = doc.DocumentNode.SelectSingleNode("//*[@id='cardResults']");
}
}
return results;
}
void SetCard()
{
int startCount = CardSetting.AttackCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_ATTACK_CARD.CountEntities);
AttackCard card = new AttackCard(TBL_ATTACK_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.EnergyCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_ENERGY_CARD.CountEntities);
EnergyCard card = new EnergyCard(TBL_ENERGY_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.GuardCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_GUARD_CARD.CountEntities);
GuardCard card = new GuardCard(TBL_GUARD_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.HealCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_HEAL_CARD.CountEntities);
HealCard card = new HealCard(TBL_HEAL_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
startCount = CardSetting.MoveCardStartCount;
while (startCount > 0)
{
int random = Random.Range(0, TBL_MOVE_CARD.CountEntities);
MoveCard card = new MoveCard(TBL_MOVE_CARD.GetEntity(random));
if (!CheckDuplicate(card))
{
cardList.Add(card);
startCount--;
}
}
Shuffle(cardList);
//for(int i=0; i<list.Count; i++)
//{
// cardPos[i].GetComponent<CardComponent>().SetCard(list[i]);
//}
UpdateCardPos();
}
public void AttachEnergy(EnergyCard energyCard, GameField game)
{
energyCard.RevealToAll();
AttachedEnergy.Add(energyCard);
bool fromHand = false;
if (Owner.Hand.Contains(energyCard))
{
Owner.Hand.Remove(energyCard);
fromHand = true;
}
else if (Owner.DiscardPile.Contains(energyCard))
{
Owner.DiscardPile.Remove(energyCard);
}
game.SendEventToPlayers(new EnergyCardsAttachedEvent()
{
AttachedTo = this,
EnergyCard = energyCard
});
energyCard.OnAttached(this, fromHand, game);
switch (energyCard.EnergyType)
{
case EnergyTypes.All:
case EnergyTypes.Colorless:
game.TriggerAbilityOfType(TriggerType.EnergyAttached, this, 0, this);
break;
case EnergyTypes.Water:
game.TriggerAbilityOfType(TriggerType.WaterAttached, this, 0, this);
break;
case EnergyTypes.Fire:
game.TriggerAbilityOfType(TriggerType.FireAttached, this, 0, this);
break;
case EnergyTypes.Grass:
game.TriggerAbilityOfType(TriggerType.GrassAttached, this, 0, this);
break;
case EnergyTypes.Electric:
game.TriggerAbilityOfType(TriggerType.ElectricAttached, this, 0, this);
break;
case EnergyTypes.Psychic:
game.TriggerAbilityOfType(TriggerType.PsychicAttached, this, 0, this);
break;
case EnergyTypes.Fighting:
game.TriggerAbilityOfType(TriggerType.FightingAttached, this, 0, this);
break;
case EnergyTypes.Darkness:
break;
case EnergyTypes.Steel:
break;
case EnergyTypes.Fairy:
break;
case EnergyTypes.Dragon:
break;
default:
break;
}
}
public void CardPlayed(EnergyCard card, PokemonCard target)
{
CardsPlayedThisTurn++;
}
// Get By Type
public List<BaseCard> GetCardsByType(EnergyCard.EnergyType key, List<BaseCard> searchList)
{
List<BaseCard> resultList = new List<BaseCard>();
foreach (PokemonCard card in searchList)
{
if (card.PokemonType == key)
{
resultList.Add(card);
}
}
return resultList;
}
public bool CanPlayEnergyCard(EnergyCard card, PokemonCard target)
{
return(CardsPlayedThisTurn == 0);
}
/// <summary>
///
/// </summary>
/// <param name="pokemonName"></param>
/// <returns></returns>
public async Task<List<Tuple<string, string>>> SearchWebsite(string pokemonName, string set, string number,
BaseCard.Rarity rarity, EnergyCard.EnergyType energyType)
{
List<BaseCard> allResults = new List<BaseCard>();
//Console.WriteLine("Awaiting pokemon card results at " + DateTime.Now);
await getListOfPokemonByName(pokemonName, set, number, rarity, energyType);
//Console.WriteLine("Pokemon card results received at " + DateTime.Now);
List<Tuple<string, string>> resultList = new List<Tuple<string, string>>();
//Console.WriteLine("Downloading images at " + DateTime.Now);
foreach (Tuple<string, string, string> result in results)
{
cardUrl = POKEMON_CARD_URL + result.Item1;
string url = result.Item2;
string filePath = "";
string folderName = System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath);
Directory.CreateDirectory(folderName + "\\CardImages");
string[] cardNumberSplit = url.Split('_');
string cardNumber = cardNumberSplit[cardNumberSplit.Length - 1].Split('/', '.')[0];
number = number.Split('/')[0];
if (number != "" && cardNumber != number)
{
// Card number did not match user input
// Continue with the next card
continue;
}
string cardName = result.Item3;
url = "http:" + url;
try
{
if (!File.Exists(folderName + "\\CardImages\\" + cardNumber + cardName + ".png"))
{
using (var client = new WebClient())
{
client.DownloadFile(new Uri(url), folderName + "\\CardImages\\" + cardNumber + cardName + ".png");
}
}
filePath = folderName + "\\CardImages\\" + cardNumber + cardName + ".png";
resultList.Add(new Tuple<string, string>(cardUrl, filePath));
}
catch(WebException ex)
{
Console.WriteLine(ex.InnerException);
}
catch(Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
Console.WriteLine("Images downloaded at " + DateTime.Now);
return resultList;
}
public void Update(EnergyCard obj)
{
throw new NotImplementedException();
}
/// <summary>
/// Search function for the cards.
/// Returns a list of cards based on a user input search term.
/// Searches based on pokemon name.
/// </summary>
/// <param name="pokemonName"></param>
/// <returns></returns>
public async Task getListOfPokemonByName(string pokemonName, string cardSet, string number,
BaseCard.Rarity rarity, EnergyCard.EnergyType energyType)
{
HtmlDocument doc;
List<string> urlSearchList = new List<string>();
// This function should return all the URLs gathered by the search
string cardSetSearch = "";
string cardRaritySearch = "";
string energySearch = "";
if (rarity != BaseCard.Rarity.None)
{
cardRaritySearch = rarityDictionary[rarity];
}
if (energyType != EnergyCard.EnergyType.None)
{
energySearch = energyDictionary[energyType];
}
if (cardSet != "All")
{
cardSetSearch = cardSetSearchDictionary[cardSet];
}
else if (cardSet == "All" || number.Contains("/"))
{
cardSetSearch = "";
if (number.Contains("/"))
{
cardSetSearch = "";
string[] splitString = number.Split('/');
if (cardSetNumberDictionary.ContainsKey(splitString[1]))
{
string[] cardSets = cardSetNumberDictionary[splitString[1]];
if (cardSets.Length > 0)
{
foreach (string setNumber in cardSets)
{
cardSetSearch += setNumber;
}
number = splitString[0];
}
}
else
{
Console.WriteLine("Invalid Set Number Provided");
return;
}
}
}
else
{
cardSetSearch = cardSetSearchDictionary[cardSet];
}
string queryString = "?" + NAME_SEARCH + pokemonName + SEARCH_ALL_POKEMON_URL + cardSetSearch + cardRaritySearch + energySearch;
doc = web.Load(POKEMON_CARD_URL + BASE_SEARCH_URL + queryString);
// Check if the user input returns any results on the website
if (doc.DocumentNode.SelectSingleNode(XPATH_NO_RESULT_FOUND) != null)
{
// Search turned up no results
return;
}
HtmlNode resultNode = doc.DocumentNode.SelectSingleNode("//*[@id='cardResults']");
string numberOfPages = doc.DocumentNode.SelectSingleNode("//*[@id='cards-load-more']/div/span").InnerText;
string[] stringSplit = numberOfPages.Split();
int pagesToSearch = Int32.Parse(stringSplit[stringSplit.Length - 1]);
if (pagesToSearch > 50)
{
return;
}
for (int i = 1; i <= pagesToSearch; ++i)
{
string url = POKEMON_CARD_URL + BASE_SEARCH_URL + i.ToString() + queryString;
urlSearchList.Add(url);
}
await DownloadMultipleFilesAsync(urlSearchList);
return;
}
