private void DealDamageToPlayersBench(Player target, EnergyTypes targetType, GameField game)
{
foreach (var pokemon in target.BenchedPokemon.ValidPokemonCards.Where(x => x.Type == targetType))
{
pokemon.DealDamage(damageToBench, game, game.ActivePlayer.ActivePokemonCard, true);
}
}
void SetPrimaryEneryTypeUI(EnergyTypes primary)
{
GameObject cam = GameObject.FindGameObjectWithTag("MainCamera");
if (cam.transform.Find("Electric") != null)
{
SpriteRenderer electricProj = cam.transform.Find("Electric").gameObject.GetComponent <SpriteRenderer>();
SpriteRenderer fireProj = cam.transform.Find("Fire").gameObject.GetComponent <SpriteRenderer>();
SpriteRenderer freezeProj = cam.transform.Find("Freeze").gameObject.GetComponent <SpriteRenderer>();
SpriteRenderer KineticProj = cam.transform.Find("Kinetic").gameObject.GetComponent <SpriteRenderer>();
electricProj.color = new Color(electricProj.color.r, electricProj.color.g, electricProj.color.b, .3f);
fireProj.color = new Color(fireProj.color.r, fireProj.color.g, fireProj.color.b, .3f);
freezeProj.color = new Color(freezeProj.color.r, freezeProj.color.g, freezeProj.color.b, .3f);
KineticProj.color = new Color(KineticProj.color.r, KineticProj.color.g, KineticProj.color.b, .3f);
if (primary == EnergyTypes.Electric)
{
electricProj.color = new Color(electricProj.color.r, electricProj.color.g, electricProj.color.b, 1f);
}
else if (primary == EnergyTypes.Fire)
{
fireProj.color = new Color(fireProj.color.r, fireProj.color.g, fireProj.color.b, 1f);
}
else if (primary == EnergyTypes.Freeze)
{
freezeProj.color = new Color(freezeProj.color.r, freezeProj.color.g, freezeProj.color.b, 1f);
}
else if (primary == EnergyTypes.Kinetic)
{
KineticProj.color = new Color(KineticProj.color.r, KineticProj.color.g, KineticProj.color.b, 1f);
}
}
}
void ChangeEnergyType()
{
if (Input.GetKeyDown("q"))
{
energyType = EnergyNext(energyType);
}
SetPrimaryEneryTypeUI(energyType);
}
internal void SpawnDamageEffect(EnergyTypes damageType)
{
GameObject effectPrefab;
switch (damageType)
{
case EnergyTypes.Colorless:
effectPrefab = ColorlessEffect;
break;
case EnergyTypes.Water:
effectPrefab = WaterEffect;
break;
case EnergyTypes.Fire:
effectPrefab = FireEffect;
break;
case EnergyTypes.Grass:
effectPrefab = GrassEffect;
break;
case EnergyTypes.Electric:
effectPrefab = ElectricEffect;
break;
case EnergyTypes.Psychic:
effectPrefab = PsychicEffect;
break;
case EnergyTypes.Fighting:
effectPrefab = RockEffect;
break;
case EnergyTypes.Darkness:
effectPrefab = DarknessEffect;
break;
case EnergyTypes.Steel:
effectPrefab = SteelEffect;
break;
case EnergyTypes.Fairy:
effectPrefab = ColorlessEffect;
break;
case EnergyTypes.Dragon:
effectPrefab = DragonEffect;
break;
default:
effectPrefab = ColorlessEffect;
break;
}
Instantiate(effectPrefab, EffectParent);
}
/// <summary>
/// Create a new energy source.
/// </summary>
/// <param name="EnergyType">The energy type.</param>
/// <param name="Percentage">Percentage of EnergyType being used by the charging stations.</param>
public EnergySource(EnergyTypes EnergyType,
Byte?Percentage = null)
{
this.EnergyType = EnergyType;
this.Percentage = Percentage.HasValue && Percentage.Value < 100
? Percentage
: new Byte?();
}
IEnumerator DamageTakenRoutine(CardRenderer cardRenderer, int damage, EnergyTypes damageType)
{
cardRenderer.SpawnDamageEffect(damageType);
cardRenderer.StartOnDamageTaken(damage);
yield return(new WaitForSeconds(1f));
GameEventHandler.Instance.EventCompleted();
}
public EnergyTypeConfig GetCombo(EnergyTypes type)
{
EnergyTypePair pair = combos.Where(x => x.type == type).FirstOrDefault();
if (pair == null)
{
return(null);
}
return(pair.config);
}
internal void OnEnergyTypeClicked(EnergyTypes energyType)
{
if (SpecialState == SpecialGameState.SelectingColor)
{
SpecialState = SpecialGameState.None;
NetworkManager.Instance.SendToServer(new SelectColorMessage(energyType), true);
selectColorPanel.gameObject.SetActive(false);
EnableButtons();
}
}
public void IndicateEnergy(EnergyTypes energyType)
{
foreach (ChosenEnergyIndicator indicator in energyIndicators)
{
if (indicator.Type != energyType)
{
indicator.Deactivate();
}
else
{
indicator.Activate();
}
}
}
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));
}
private void UpdateEnergies()
{
if (!Connected)
{
Reset();
}
else
{
EnergyTypes type = currentEnergies[0].EnergyType.Type;
config = Configs.main.EnergyTypeConfigs[type];
if (currentEnergies.Count > 1)
{
config = config.GetCombo(currentEnergies[1].EnergyType.Type);
}
distanceIndicator.Show(transform.position);
towerMesh.Activate();
Material[] materials = towerTopRenderer.materials;
materials[1] = config.CrystalMaterial;
towerTopRenderer.sharedMaterials = materials;
towerTopRenderer.materials = materials;
materials = towerBottomRenderer.materials;
materials[1] = config.CrystalMaterial;
towerBottomRenderer.sharedMaterials = materials;
towerBottomRenderer.materials = materials;
var main = topEffect.main;
main.startColor = config.EffectColor;
bottomEffect.trailMaterial = config.CrystalMaterial;
topLight.color = config.EffectColor;
topEffect.Play();
topLight.enabled = true;
Color color = config.EffectColor;
color.a = 0.05f;
distanceIndicator.SetColor(color);
}
}
public House(
Uri houseUrl,
AddressLocation address,
Area groundArea,
Area houseArea,
EnergyTypes energyType,
DateTime forSaleDate,
DateTime originalForSaleDate,
IEnumerable <HouseImage> images,
IEnumerable <InternetOption> internetOptions,
IEnumerable <Shop> shops,
IEnumerable <CategoryRating> ratings)
{
if (houseUrl.Scheme != Uri.UriSchemeHttp && houseUrl.Scheme != Uri.UriSchemeHttps)
{
throw new ArgumentException($"House url should use {Uri.UriSchemeHttp} or {Uri.UriSchemeHttps}.", nameof(houseUrl));
}
if (originalForSaleDate > forSaleDate)
{
throw new ArgumentOutOfRangeException(nameof(forSaleDate), "Original for sale date cannot be later than the current for sale date.");
}
if (forSaleDate > DateTime.Now)
{
throw new ArgumentOutOfRangeException(nameof(forSaleDate), "For sale date cannot be in the future.");
}
if (originalForSaleDate > DateTime.Now)
{
throw new ArgumentOutOfRangeException(nameof(originalForSaleDate), "Original for sale date cannot be in the future.");
}
HouseUrl = houseUrl;
Address = address ?? throw new ArgumentNullException(nameof(address));
GroundArea = groundArea ?? throw new ArgumentNullException(nameof(address));
HouseArea = houseArea ?? throw new ArgumentNullException(nameof(address));
EnergyType = energyType;
ForSaleDate = forSaleDate;
OriginalForSaleDate = originalForSaleDate;
Images = new ReadOnlyCollection <HouseImage>(images?.ToList() ?? throw new ArgumentNullException(nameof(images)));
InternetOptions = new ReadOnlyCollection <InternetOption>(internetOptions?.ToList() ?? throw new ArgumentNullException(nameof(internetOptions)));
Shops = new ReadOnlyCollection <Shop>(shops?.ToList() ?? throw new ArgumentNullException(nameof(shops)));
Ratings = new ReadOnlyCollection <CategoryRating>(ratings?.ToList() ?? throw new ArgumentNullException(nameof(ratings)));
}
public Sprite GetEnergyTypeIcon(EnergyTypes energyType)
{
if (energyType == EnergyTypes.MagicMissile)
{
return(magicMissileIcon);
}
if (energyType == EnergyTypes.Lightning)
{
return(LightningIcon);
}
if (energyType == EnergyTypes.Fire)
{
return(FireIcon);
}
if (energyType == EnergyTypes.Ice)
{
return(IceIcon);
}
return(null);
}
public string GetEnergyTypeTitle(EnergyTypes energyType)
{
if (energyType == EnergyTypes.MagicMissile)
{
return("Magic missile");
}
if (energyType == EnergyTypes.Lightning)
{
return("Lightning");
}
if (energyType == EnergyTypes.Fire)
{
return("Fire");
}
if (energyType == EnergyTypes.Ice)
{
return("Ice");
}
return("");
}
public string GetEnergyTypeMessage(EnergyTypes energyType)
{
if (energyType == EnergyTypes.MagicMissile)
{
return("Does damage.");
}
if (energyType == EnergyTypes.Lightning)
{
return("Bounces from target to target.");
}
if (energyType == EnergyTypes.Fire)
{
return("Does damage on an area.");
}
if (energyType == EnergyTypes.Ice)
{
return("Slows down targets.");
}
return("");
}
EnergyTypes EnergyNext(EnergyTypes myEnum)
{
switch (myEnum)
{
case EnergyTypes.Electric:
return(EnergyTypes.Fire);
case EnergyTypes.Fire:
return(EnergyTypes.Freeze);
case EnergyTypes.Freeze:
return(EnergyTypes.Kinetic);
case EnergyTypes.Kinetic:
return(EnergyTypes.Electric);
default:
return(EnergyTypes.Electric);
}
}
public static List <IDeckFilter> GetCardFilters(CardType cardType, EnergyTypes energyType = EnergyTypes.None)
{
var filter = new List <IDeckFilter>();
switch (cardType)
{
case CardType.Pokemon:
filter.Add(new PokemonFilter());
break;
case CardType.BasicPokemon:
filter.Add(new BasicPokemonFilter());
break;
case CardType.Trainer:
filter.Add(new TrainerFilter());
break;
case CardType.Energy:
filter.Add(new EnergyFilter());
break;
case CardType.BasicEnergy:
if (energyType == EnergyTypes.All || energyType == EnergyTypes.None)
{
filter.Add(new BasicEnergyFilter());
}
else
{
filter.Add(new EnergyTypeFilter(energyType));
}
break;
default:
break;
}
return(filter);
}
public DieAmountPair(DieAmountPair p)
{
Die = p.Die;
Amount = p.Amount;
Type = p.Type;
}
public PokemonWithNameOrTypeFilter(string names, EnergyTypes type) : this(names, type, false)
{
}
public EnergyResistance(EnergyTypes type, int amount = 0)
{
Type = type;
Amount = amount;
}
public DieAmountPair(Dice die, int amount = 1, EnergyTypes type = EnergyTypes.Physical)
{
Die = die;
Amount = amount;
Type = type;
}
public Energy(EnergyTypes energyType, int amount)
{
Amount = amount;
EnergyType = energyType;
}
public bool CoversType(EnergyTypes type)
{
return(SourceType == EnergyTypes.All || SourceType == type);
}
public PokemonOwnerAndTypeFilter(NetworkId playerId, EnergyTypes type)
{
OwnerId = playerId;
EnergyType = type;
}
public DieAmountPair()
{
Die = Dice.d6;
Amount = 1;
Type = EnergyTypes.Physical;
}
public PokemonWithNameOrTypeFilter(string names, EnergyTypes type, bool onlyBasic)
{
Names = names;
Type = type;
OnlyBasic = onlyBasic;
}
public BuzzardEnergy(PokemonCard pokemonOwner, EnergyTypes energyType) : this()
{
createdBy = pokemonOwner;
EnergyType = energyType;
}
public EnergyTypeFilter(EnergyTypes energyType)
{
this.energyType = energyType;
}
public int GetEnergyOfType(EnergyTypes energyType) => AttachedEnergy.Count(e => e.EnergyType == energyType || e.EnergyType == EnergyTypes.All);
public static List <Card> GetCardsOfType(List <Card> cards, CardType cardType, EnergyTypes energyType = EnergyTypes.All)
{
switch (cardType)
{
case CardType.Pokemon:
return(cards.OfType <PokemonCard>().OfType <Card>().ToList());
case CardType.BasicPokemon:
return(cards.OfType <PokemonCard>().Where(pokemon => pokemon.Stage == 0).OfType <Card>().ToList());
case CardType.Trainer:
return(cards.OfType <TrainerCard>().OfType <Card>().ToList());
case CardType.Energy:
return(cards.OfType <EnergyCard>().OfType <Card>().ToList());
case CardType.BasicEnergy:
return(cards.OfType <EnergyCard>().Where(e => energyType == EnergyTypes.All || e.EnergyType == energyType).Where(energy => energy.IsBasic).OfType <Card>().ToList());
case CardType.Any:
default:
return(cards);
}
}
