public void DirectiveResponse()
{
AlexaResponse resp = new AlexaResponse
{
Version = "1.0",
Response = new AlexaResponseAttributes
{
OutputSpeech = OutputSpeechBuilder.GetPlainTextSpeech("You are hearing me talk."),
Card = CardBuilder.GetSimpleCardResponse("Card Title", "This is some card text."),
},
};
DisplayDirectiveResponse displayResp = new DisplayDirectiveResponse();
displayResp.Template = new DisplayTemplate();
displayResp.Template.Type = DisplayTemplateTypeEnum.BodyTemplate3;
displayResp.Template.Token = "user_email";
displayResp.Template.Title = "Display Title";
displayResp.Template.TextContent = new DisplayTextContent();
displayResp.Template.TextContent.PrimaryText = new DisplayTextField();
displayResp.Template.TextContent.PrimaryText.Type = DisplayTextTypeEnum.RichText;
displayResp.Template.TextContent.PrimaryText.Text = "<b><font size=\"6\">Some bold text</font></b>";
displayResp.Template.Image = new DisplayDirectiveImage("small image", "http://pathtosomeimage");
displayResp.Template.BackgroundImage = new DisplayDirectiveImage("background image", "http://pathtosomebackgroundimage");
resp.Response.Directives = new List <DirectiveResponse>();
resp.Response.Directives.Add(displayResp);
string textResp = JsonConvert.SerializeObject(resp, Formatting.Indented);
// The text should serialize to empty brackets.
}
public static bool ChooseEnemyThenReSummon(GameEvent gameEvent)
{
Card card = gameEvent.player.board.ChooseTarget
(
gameEvent.player.board.GetMinionTargetLambda(gameEvent.player.board.GetAnotherPlayer(gameEvent.player), MinionType.Any, null)
);
int id = card.id;
gameEvent.hostCard.effectsStay.Add(new ProxyEffect(ProxyEnum.Deathrattle, gameEvent2 =>
{
bool isGold = gameEvent2.hostCard.isGold;
if (true)
{
Card byCard = gameEvent2.hostCard;
Card newCard = CardBuilder.NewCard(id);
gameEvent2.player.board.SummonMinionByMinion(new GameEvent()
{
hostCard = gameEvent2.hostCard,
targetCard = newCard,
player = gameEvent2.player,
}, byCard);
byCard = newCard;
}
return(true);
}));
return(true);
}
public void ValidateDeckTest()
{
// Should fail: Null value
CardBuilder[] Zeroth = DeckChoiceUI
.SWARM_DECK
.Select(n => Cards.CardFromID(n))
.ToArray();
Zeroth[0] = null;
Assert.IsFalse(Cards.ValidateDeck(Zeroth, out string zero));
// Should fail: Too many duplicates
CardBuilder[] First = Enumerable
.Repeat(1, 25)
.Select(n => Cards.CardFromID((byte)n))
.ToArray();
Assert.IsFalse(Cards.ValidateDeck(First, out string one));
// Should fail: Too few cards
CardBuilder[] Second = new CardBuilder[]
{
Cards.CardFromID(1),
Cards.CardFromID(2),
};
Assert.IsFalse(Cards.ValidateDeck(Second, out string two));
// Should fail: Too many cards
CardBuilder[] Third = Enumerable
.Range(0, 30)
.Select(n => Cards.CardFromID((byte)n))
.ToArray();
Assert.IsFalse(Cards.ValidateDeck(Third, out string three));
}
public static bool Summon1Or2JadeGloem(GameEvent gameEvent)
{
Card targetCard = CardBuilder.SearchCardByName("青玉魔像");
if (targetCard != null)
{
gameEvent.player.JadeGloem++;
Card golem1 = targetCard.NewCard();
golem1.effectsStay.Add(new BodyPlusEffect(gameEvent.player.JadeGloem, gameEvent.player.JadeGloem));
gameEvent.player.board.SummonMinion(new GameEvent()
{
hostCard = gameEvent.hostCard,
targetCard = golem1,
player = gameEvent.player,
});
if (gameEvent.hostCard.isGold)
{
gameEvent.player.JadeGloem++;
Card golem2 = targetCard.NewCard();
golem2.effectsStay.Add(new BodyPlusEffect(gameEvent.player.JadeGloem, gameEvent.player.JadeGloem));
gameEvent.player.board.SummonMinion(new GameEvent()
{
hostCard = gameEvent.hostCard,
targetCard = golem2,
player = gameEvent.player,
});
}
}
return(true);
}
public static bool SummonFirst2DeathMech(GameEvent gameEvent)
{
List <Card> summons = new List <Card>();
foreach (var id in gameEvent.player.deathMinionCollection)
{
if (summons.Count >= (gameEvent.hostCard.isGold ? 4 : 2))
{
break;
}
Card card = CardBuilder.GetCard(id);
if (card.IsMinionType(MinionType.Mechs))
{
summons.Add(card.NewCard());
}
}
var byCard = gameEvent.hostCard;
foreach (var card in summons)
{
gameEvent.player.board.SummonMinionByMinion(new GameEvent()
{
hostCard = gameEvent.hostCard,
targetCard = card,
player = gameEvent.player
}, byCard);
byCard = card;
}
return(true);
}
public void BuildTest()
{
GameState G = new GameState(DeckChoiceUI.COMBO_DECK, DeckChoiceUI.COMBO_DECK, true, 0);
// For a minion
CardBuilder MinionBuilder = new CardBuilder
{
TypeID = CardBuilder.CardType.Minion,
AttackData = 2,
HealthData = 3,
NameData = "MIN1",
DescriptionData = "ABCXYZ",
MinionOnPlayData = (s, m) =>
{
},
MinionEffectData = new EffectData <MinionCard>()
{
{
Effect.CardDrawn, (s, m) =>
{
}
}
},
};
MinionCard Minion = MinionBuilder.Build(G, G.PlayerOne) as MinionCard;
Assert.AreEqual(MinionBuilder.AttackData, Minion.Attack);
Assert.AreEqual(MinionBuilder.HealthData, Minion.Health);
Assert.AreEqual(MinionBuilder.NameData, Minion.Name);
Assert.AreEqual(MinionBuilder.DescriptionData, Minion.Description);
Assert.AreEqual(MinionBuilder.MinionOnPlayData, Minion.OnPlay);
Assert.AreEqual(MinionBuilder.MinionEffectData, Minion.Effects);
}
public void ShouldNotThrow()
{
//arrange
//act
//assert
Expect(() => CardBuilder.Create().Build())
.To.Not.Throw();
}
private Game AcesFullOfKingsGame()
{
return(new Game(
CardBuilder.Ace().Hearths(),
CardBuilder.Ace().Diamonds(),
CardBuilder.King().Clubs(),
CardBuilder.Ace().Spades(),
CardBuilder.King().Hearths()));
}
public static Game HearthsRoyalFlush()
{
return(new Game(
CardBuilder.Ace().Hearths(),
CardBuilder.King().Hearths(),
CardBuilder.Queen().Hearths(),
CardBuilder.Jack().Hearths(),
CardBuilder.Ten().Hearths()));
}
private async Task <AlexaResponse> GetLaunchResponseAsync(AlexaRequest request)
{
Adventure adv = await _adventureRep.GetAdventureAsync();
AdventureNode curNode = await _curNodeRep.GetCurrentNodeAsync(request, adv.Nodes);
// If there is a current node that has choices, then let the user resume.
bool nodeHasChoices = (curNode?.NodeRoutes?.Any()).GetValueOrDefault(false);
AlexaResponse resp;
if (!nodeHasChoices)
{
string welcomeText = "Welcome to the Adventure Sample. When you are ready to start the adventure, say begin";
resp = new AlexaResponse
{
Version = "1.0",
Response = new AlexaResponseAttributes
{
OutputSpeech =
OutputSpeechBuilder.GetPlainTextSpeech(welcomeText),
Card = CardBuilder.GetSimpleCardResponse("Welcome to the Adventure", welcomeText),
Reprompt = new RepromptAttributes
{
OutputSpeech = OutputSpeechBuilder.GetPlainTextSpeech("Say begin when you're ready to begin")
}
}
};
}
else
{
string resumeText = "Welcome back! You have an adventure in progress. Would you like to resume or restart?";
resp = new AlexaResponse
{
Version = "1.0",
Response = new AlexaResponseAttributes
{
OutputSpeech =
OutputSpeechBuilder.GetPlainTextSpeech(resumeText),
Card = CardBuilder.GetSimpleCardResponse("Welcome Back to the Adventure", resumeText),
Reprompt = new RepromptAttributes
{
OutputSpeech = OutputSpeechBuilder.GetPlainTextSpeech("You can resume or restart.")
}
}
};
}
return(resp);
}
public static bool Summon88(GameEvent gameEvent)
{
Card targetCard = CardBuilder.SearchCardByName("忠实护卫");
if (targetCard != null)
{
gameEvent.player.AddMinionToBattlePile(targetCard.NewCard(), 0);
}
return(false);
}
public static bool FullYourHandWithCoins(GameEvent gameEvent)
{
Card targetCard = CardBuilder.SearchCardByName("铸币");
for (int i = 0; i < 5; i++)
{
gameEvent.player.AddMinionToHandPile(targetCard.NewCard());
}
return(true);
}
private void onHandChange()
{
this.destroyChildren();
foreach (Card card in DeckManager.Instance.getHand())
{
GameObject newInstance = Instantiate(Resources.Load("RuntimePrefabs/Card"), this.transform) as GameObject;
CardBuilder cardBuilderScript = newInstance.GetComponent <CardBuilder>();
cardBuilderScript.buildWithCard(card);
}
}
private void StartGame()
{
InitTalkingData();
CardBuilder.InitAllCards();
//gameController = gameObject.AddComponent<GameController>();
//UnlockAllHero(true);
gameController = new GameController(this);
StartCoroutine(gameController.EGameStart());
}
public async Task<PaymentMethodNonce> TokenizeAsync(CardBuilder card)
{
var actionListener = new PaymentMethodNonceListener();
try
{
AddListener(actionListener);
Card.Tokenize(this, card);
return await actionListener.Task();
}
// There is no catch statements here. Exception handling must be done by caller.
finally
{
RemoveListener(actionListener);
}
}
