public override void HandleEvent(IEvent eventInfo) { base.HandleEvent(eventInfo); PlayerController player = eventInfo.playerId.GetComponent <PlayerController>(); if (gameSession.isServer) { if (eventInfo is StartCardSelectionEvent startEvent) { gameSession.SetWaitingPlayerIndex(gameSession.GetPlayerIndex(player)); seeds[0] = startEvent.seed1; seeds[1] = startEvent.seed2; seeds[2] = startEvent.seed3; srcPlayer = startEvent.srcPlayer.GetComponent <PlayerController>(); flags = startEvent.flags; started = true; player.ServerStartCardSelection(srcPlayer, seeds[0], seeds[1], seeds[2], flags); } if (player == gameSession.GetWaitingOnPlayer() && eventInfo is CardSelectionEvent selectedEvent) { if ((selectedEvent.seed == seeds[0] || selectedEvent.seed == seeds[1] || selectedEvent.seed == seeds[2]) && selectedEvent.srcPlayer == srcPlayer.netIdentity && selectedEvent.flags == flags && started) { started = false; gameSession.ServerPlayerDrawCard(gameSession.GetWaitingOnPlayer(), selectedEvent.srcPlayer.GetComponent <PlayerController>(), selectedEvent.seed, selectedEvent.flags); ExitState(); } } } }
public StartCardSelectionEvent(PlayerController player, PlayerController source, int cardSeed1, int cardSeed2, int cardSeed3, CardGenerationFlags cardFlags) : base(player) { srcPlayer = source.netIdentity; seed1 = cardSeed1; seed2 = cardSeed2; seed3 = cardSeed3; flags = cardFlags; }
public CardInstance(PlayerController src, int seed, CardGenerationFlags flags = CardGenerationFlags.NONE) { srcPlayer = src; cardSeed = seed; cardFlags = flags; baseCard = src.cardGenerator.GenerateCard(seed, flags); modifiers = new List <IModifier>(); }
public void ClientRequestCardSelection(PlayerController src, int seed, CardGenerationFlags flags) { if (isLocalPlayer) { CardSelectionEvent cardEvent = new CardSelectionEvent(this, src, seed, flags); CmdSendCardSelectionEvent(cardEvent); } }
public override void ApplyToTarget(Targettable target, PlayerController player, Targettable source) { PlayerController targetPlayer = target as PlayerController; if (targetPlayer) { GameSession gameSession = GameUtils.GetGameSession(); CardGenerationFlags flags = CardGenerationFlags.NONE; if (cardQualifier != null) { switch (cardQualifier.qualifierType) { case QualifierType.CARD_TYPE: { CardTypeQualifierDescription cardTypeQualifier = cardQualifier as CardTypeQualifierDescription; flags |= EffectConstants.GetGenerationFlags(cardTypeQualifier.cardType); } break; case QualifierType.CREATURE_TYPE: { CreatureTypeQualifierDescription creatureTypeQualifier = cardQualifier as CreatureTypeQualifierDescription; flags |= EffectConstants.GetGenerationFlags(creatureTypeQualifier.creatureType); } break; } } for (int i = 0; i < amount; i++) { switch (drawModifier) { case DrawModifier.RANDOM: gameSession.ServerPlayerDrawCard(targetPlayer, targetPlayer, flags, true); break; case DrawModifier.SELF: gameSession.ServerPlayerDrawCard(targetPlayer, targetPlayer, flags); break; case DrawModifier.OPPONENT_RANDOM: gameSession.ServerPlayerDrawCard(targetPlayer, GameUtils.GetGameSession().GetOpponents(targetPlayer)[0], flags, true); break; case DrawModifier.OPPONENT: gameSession.ServerPlayerDrawCard(targetPlayer, GameUtils.GetGameSession().GetOpponents(targetPlayer)[0], flags); break; } } } }
public void ServerAddCardToHand(PlayerController source, Card card, int seed, CardGenerationFlags flags = CardGenerationFlags.NONE) { if (isServerOnly) { card.cardData = new CardInstance(source, seed, flags); card.owner = this; card.controller = this; card.isRevealed = true; card.isDraggable = false; hand.AddCard(card); } RpcAddCardToHand(source.netIdentity, card.netIdentity, seed, flags); }
public static CardGenerationFlags GetGenerationFlags(CreatureType creatureType) { CardGenerationFlags flag = CardGenerationFlags.CREATURE; switch (creatureType) { case CreatureType.HUMAN: flag |= CardGenerationFlags.HUMAN; break; case CreatureType.GOBLIN: flag |= CardGenerationFlags.GOBLIN; break; case CreatureType.FAERIE: flag |= CardGenerationFlags.FAERIE; break; } return(flag); }
public override CardDescription GenerateCard(int seed, CardGenerationFlags flags = CardGenerationFlags.NONE) { // First select the card type System.Random random = new System.Random(seed); // Still generate a type even if a flag is provided, so that the generation with a seed matches // ie. we don't want to generate 2 different creatures from the same seed just because we specified a creature flag CardType t = ProceduralUtils.GetRandomValue <CardType>(random, model); if ((flags & CardGenerationFlags.CREATURE) == CardGenerationFlags.CREATURE) { t = CardType.CREATURE; } else if ((flags & CardGenerationFlags.SPELL) == CardGenerationFlags.SPELL) { t = CardType.SPELL; } else if ((flags & CardGenerationFlags.TRAP) == CardGenerationFlags.TRAP) { t = CardType.TRAP; } switch (t) { case CardType.CREATURE: return(GenerateCreatureCard(random, model, images, creatureModelIndex, nameModel, flags)); case CardType.SPELL: return(GenerateSpellCard(random, model, images, creatureModelIndex, nameModel, flags)); case CardType.TRAP: return(GenerateTrapCard(random, model, images, creatureModelIndex, nameModel, flags)); } return(new CardDescription()); }
public CardSelectionEvent(PlayerController player, PlayerController source, int cardSeed, CardGenerationFlags cardFlags) : base(player) { srcPlayer = source.netIdentity; seed = cardSeed; flags = cardFlags; }
static private CardDescription GenerateTrapCard(System.Random random, IHistogram model, ImageGlossary images, CreatureModelIndex creatureModels, NameModel nameModel, CardGenerationFlags flags) { CardDescription card = ScriptableObject.CreateInstance(typeof(CardDescription)) as CardDescription; card.cardType = CardType.TRAP; card.manaCost = (int)ProceduralUtils.GetRandomValue <ManaCost>(random, model); double powerBudget = PowerBudget.ManaPowerBudgets[card.manaCost]; double powerMargin = PowerBudget.ManaPowerMargin[card.manaCost]; double powerLimit = PowerBudget.ManaPowerLimit[card.manaCost]; card.cardName = "A trap card"; //card.name += "(" + powerBudget.ToString() + ")"; GenerateCardEffects(random, model, creatureModels, card, powerBudget, powerMargin, powerLimit); // Revise the mana cost based on what effects we actually did generate int revisedMana = PowerBudget.PowerLevelToMana(card.PowerLevel()); if (revisedMana != card.manaCost) { Debug.Log("Had to revise the mana cost from " + card.manaCost.ToString() + " to " + revisedMana.ToString()); card.manaCost = revisedMana; } card.image = ProceduralUtils.GetRandomTexture(random, images.GetTrapImages()); CardTags tags = CardTagging.GetCardTags(card); card.cardName = nameModel.GenerateName(random, tags); return(card); }
static private CardDescription GenerateCreatureCard(System.Random random, IHistogram model, ImageGlossary images, CreatureModelIndex creatureModels, NameModel nameModel, CardGenerationFlags flags) { CreatureCardDescription card = ScriptableObject.CreateInstance(typeof(CreatureCardDescription)) as CreatureCardDescription; card.creatureType = ProceduralUtils.GetRandomValue <CreatureType>(random, model); if ((flags & CardGenerationFlags.HUMAN) == CardGenerationFlags.HUMAN) { card.creatureType = CreatureType.HUMAN; } else if ((flags & CardGenerationFlags.GOBLIN) == CardGenerationFlags.GOBLIN) { card.creatureType = CreatureType.GOBLIN; } else if ((flags & CardGenerationFlags.FAERIE) == CardGenerationFlags.FAERIE) { card.creatureType = CreatureType.FAERIE; } MultiCardHistogram combinedModel = ScriptableObject.CreateInstance(typeof(MultiCardHistogram)) as MultiCardHistogram; combinedModel.Init(new IHistogram[] { model, creatureModels.GetModel(card.creatureType) }); card.manaCost = (int)ProceduralUtils.GetRandomValue <ManaCost>(random, model); // Potentially generate a stronger body, but with a drawback double bodyManaCost = GetCreatureBodyBudget(creatureModels.GetBodyLambda(card.creatureType), random.Next(), card.manaCost + 1); int maxStats = PowerBudget.StatBudget(bodyManaCost); // Decide on stats card.health = GetHealth(random, creatureModels.GetStatProbability(card.creatureType, (int)Math.Round(bodyManaCost, MidpointRounding.AwayFromZero)), maxStats); card.attack = maxStats - card.health; // Decide on power budget double powerBudget = PowerBudget.ManaPowerBudgets[card.manaCost]; double powerMargin = PowerBudget.ManaPowerMargin[card.manaCost]; double powerLimit = PowerBudget.ManaPowerLimit[card.manaCost]; card.cardName = "A creature card"; //card.name += "(" + powerBudget.ToString() + ")"; // Decide on keyword attributes int maxKeywords = 3; for (int i = 0; i < maxKeywords; i++) { double keywordPowerLimit = powerLimit - card.PowerLevel(); if (keywordPowerLimit < 0) { keywordPowerLimit = 0; } KeywordAttribute keyword = ProceduralUtils.GetRandomValue(random, combinedModel, ProceduralUtils.GetKeywordsWithinBudget(keywordPowerLimit, card.attack, card.health)); if (keyword == KeywordAttribute.NONE) { break; } card.AddAttribute(keyword); } // Decide on effects GenerateCardEffects(random, combinedModel, creatureModels, card, powerBudget, powerMargin, powerLimit); // Revise the mana cost based on what effects we actually did generate int revisedMana = PowerBudget.PowerLevelToMana(card.PowerLevel()); if (revisedMana != card.manaCost) { Debug.Log("Had to revise the mana cost from " + card.manaCost.ToString() + " to " + revisedMana.ToString()); card.manaCost = revisedMana; } card.image = ProceduralUtils.GetRandomTexture(random, images.GetCreatureImages(card.creatureType)); CardTags tags = CardTagging.GetCardTags(card); card.cardName = nameModel.GenerateName(random, tags); return(card); }
public void SetCardSelection(PlayerController owner, PlayerController src, int seed1, int seed2, int seed3, CardGenerationFlags flags = CardGenerationFlags.NONE) { cardSelection[0].cardData = new CardInstance(src, seed1, flags); cardSelection[0].owner = owner; cardSelection[1].cardData = new CardInstance(src, seed2, flags); cardSelection[1].owner = owner; cardSelection[2].cardData = new CardInstance(src, seed3, flags); cardSelection[2].owner = owner; }
public abstract CardDescription GenerateCard(int seed, CardGenerationFlags flags);
public void RpcAddCardToHand(NetworkIdentity playerId, NetworkIdentity cardId, int seed, CardGenerationFlags flags) { Card c = cardId.gameObject.GetComponent <Card>(); c.cardData = new CardInstance(playerId.GetComponent <PlayerController>(), seed, flags); c.owner = this; c.controller = this; c.isRevealed = isLocalPlayer; c.isDraggable = isLocalPlayer; SoundLibrary.PlaySound("draw"); hand.AddCard(c); }
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); } }
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); }