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);
}
