/// <summary>
/// (HELPER / overload)
/// Deals cards to Player and Computer 'Play' decks
/// </summary>
/// <param name="player"> client player's 'Play' deck </param>
/// <param name="computer"> computer player's 'Play' deck </param>
/// <returns> completed task </returns>
private async Task DealGameAsync(Deck player, Deck computer)
{
List <Card> cards = await GetAllCardsAsync();
cards.Remove(cards.FirstOrDefault(c => c.ID == 53));
cards.Remove(cards.FirstOrDefault(c => c.ID == 54));
Random random = new Random();
int rnd;
Deck current = player;
while (cards.Count > 0)
{
rnd = random.Next(0, cards.Count - 1);
await _context.DeckCards.AddAsync(new DeckCard()
{
CardID = cards[rnd].ID, DeckID = current.ID
});
await _context.SaveChangesAsync();
DeckCard test = await _context.DeckCards.FirstOrDefaultAsync(c => c.CardID == cards[rnd].ID && c.DeckID == current.ID);
cards.Remove(cards[rnd]);
current = (current == player) ? computer : player;
}
await _context.SaveChangesAsync();
}
public async Task AddCard(string uid)
{
bool isNewCard = true;
for (int i = 0; i < Deck.Cards.Count; i++)
{
if (Deck.Cards[i].UID == uid)
{
isNewCard = false;
Deck.Cards[i].Quantity += 1;
break;
}
}
if (isNewCard)
{
DeckCard NewCard = new DeckCard();
NewCard.Quantity = 1;
NewCard.UID = uid;
Deck.Cards.Add(NewCard);
}
string Ticket = await JSRuntime.InvokeAsync <string>("StartLoading");
await JSRuntime.InvokeVoidAsync("UpdateDeck", Deck);
string selector = "input[data-card-uid=\"" + uid + "\"]";
await JSRuntime.InvokeVoidAsync("FocusElement", selector);
await JSRuntime.InvokeVoidAsync("StopLoading", Ticket);
StateHasChanged();
}
internal async Task <bool> DeleteDeckCardAsync(DeckCard card)
{
try
{
HttpResponseMessage result =
await _httpClient.DeleteAsync(new Uri(_deckcardUri, "deckcards/" + card.DeckCardId));
return(result.IsSuccessStatusCode);
}
catch (HttpRequestException ex)
{
await CustomLogger.Log("DeleteDeckCardAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
catch (InvalidOperationException ex)
{
await CustomLogger.Log("DeleteDeckCardAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
catch (ArgumentNullException ex)
{
await CustomLogger.Log("DeleteDeckCardAsync: " + DateTime.Now.ToShortTimeString() + " " + ex.StackTrace).ConfigureAwait(true);
return(false);
}
}
public void SetDeck(Action onComplete, bool setListener)
{
if (transform.childCount - 1 == GameControl.control.playerData.deck.Count)
{
Debug.Log("saved some CPU; didn't set deck!");
if (setListener)
{
foreach (Transform child in transform)
{
if (child.name == "more")
{
continue;
}
DeckCard DC = child.GetComponent <DeckCard>();
DC.setListener(DeckCardFunction(DC, GameControl.control.getMainUI().detailCard));
}
}
if (onComplete != null)
{
onComplete();
}
return;
}
GameControl.control.StartCoroutine(hardResetDeck(onComplete, setListener));
}
public void CardIDGetSet()
{
DeckCard card = new DeckCard();
card.CardID = 1;
Assert.Equal(1, card.CardID);
}
public async Task <IActionResult> PutDeckCards([FromRoute] int id, [FromBody] DeckCard deckCards)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != deckCards.DeckCardId)
{
return(BadRequest());
}
_context.Entry(deckCards).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DeckCardsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static CardEntity CreateDeckCard(this CardContext context, DeckCard type)
{
var entity = context.CreateEntity();
entity.AddDeckCard(type);
return(entity);
}
private void FormatCardConstantTable(object sender, DataGridViewBindingCompleteEventArgs e)
{
DataGridView dataGridView = (DataGridView)sender;
foreach (DataGridViewRow row in dataGridView.Rows)
{
CardConstant cardConstant;
if (row.DataBoundItem.GetType() == typeof(ObjectView <CardConstant>))
{
cardConstant = ((ObjectView <CardConstant>)row.DataBoundItem).Object;
}
else if (row.DataBoundItem.GetType() == typeof(DeckCard))
{
DeckCard deckCard = (DeckCard)row.DataBoundItem;
cardConstant = deckCard.CardConstant;
}
else if (row.DataBoundItem.GetType() == typeof(ObjectView <DeckCard>))
{
DeckCard deckCard = ((ObjectView <DeckCard>)row.DataBoundItem).Object;
cardConstant = deckCard.CardConstant;
}
else
{
cardConstant = ((ObjectView <CardConstant>)row.DataBoundItem).Object;
}
row.DefaultCellStyle.BackColor = CardConstantRowColor(cardConstant);
row.DefaultCellStyle.ForeColor = Color.White;
}
}
public void DuplicateCard(DeckCard card)
{
var newCard = new DeckCard
{
Count = card.Count,
OracleId = card.OracleId,
Prints = card.Prints,
SelectPrint = card.SelectPrint
};
Deck.Cards.Add(newCard);
var index = Deck.Cards.IndexOf(card);
if (Deck.Cards.Count > index && Deck.Cards[index + 1].IsChild)
{
var child = Deck.Cards[index + 1];
newCard = new DeckCard
{
IsChild = child.IsChild,
OracleId = child.OracleId
};
Deck.Cards.Add(newCard);
}
}
public void DisplayDeck()
{
if (activated)
{
foreach (DeckCard c in cards)
{
Destroy(c.gameObject);
}
cards.Clear();
}
else
{
for (int i = 0; i < character.stats.cards.Count; ++i)
{
int x = i % row;
int y = i / row;
Vector3 destination = new Vector3(start.x + x * width, start.y - y * height);
DeckCard d = Instantiate(prefab);
d.transform.SetParent(panel.transform);
d.SetCard(character.stats.cards[i], character, destination, i);
cards.Add(d);
}
}
activated = !activated;
panel.SetActive(activated);
}
public void ReplaceDeckCard(DeckCard newType)
{
var index = CardComponentsLookup.DeckCard;
var component = CreateComponent <DeckCardComponent>(index);
component.Type = newType;
ReplaceComponent(index, component);
}
public override void SetData(ActiveCard card1)
{
card = card1.Card;
if (card1.Level > 1)
{
spell.UpgradeToLevel(card1.Level);
}
}
public void DeckGetSet()
{
DeckCard card = new DeckCard();
Deck deck = new Deck();
card.Deck = deck;
Assert.Equal(deck, card.Deck);
}
public Image ShowTip()
{
var card = CardAssistant.GetCard(CardId);
DeckCard dc = new DeckCard(CardId, (byte)Level, 0);
card.SetData(dc);
return(card.GetPreview(CardPreviewType.Normal, new int[0]));
}
public void CardGetSet()
{
DeckCard card = new DeckCard();
Card refCard = new Card();
card.Card = refCard;
Assert.Equal(refCard, card.Card);
}
private UnityAction DeckCardFunction(DeckCard card, DetailCard detailCard)
{
return(() =>
{
detailCard.setDetailCard(card);
transform.parent.gameObject.SetActive(false);
});
}
public override void SetData(DeckCard card1)
{
card = card1;
if (card1.Level > 1)
{
spell.UpgradeToLevel(card1.Level);
}
}
/// Karten FÜR das Deck
public static List <Card> GetAllCardsForDeck(string email, int idDeck)
{
List <PersonCard> personCards = null;
try
{
using (var context = new ClonestoneFSEntities())
{
var person = context.AllPersons
.Include(x => x.AllPersonCards)
.Include(x => x.AllPersonCards.Select(y => y.Card))
.FirstOrDefault(x => x.Email.Equals(email));
if (person == null)
{
throw new ArgumentException("Invalid username");
}
/// get ALL cards assigned to this user
personCards = person.AllPersonCards.ToList();
/// get deck for given idDeck
Deck deck = context.AllDecks.FirstOrDefault(x => x.ID == idDeck);
if (deck == null)
{
throw new ArgumentException("Invalid idDeck");
}
/// iterate over all userCards
foreach (var userCard in personCards)
{
/// check if current userCard is already present in current deck
DeckCard deckCard = deck.AllDeckcards.FirstOrDefault(x => x.ID_Card == userCard.ID_Card);
/// if card is already in deck
if (deckCard != null)
{
/// decrease number of cards available
userCard.NumberOfCards -= deckCard.NumCards;
}
}
/// return only those cards, whose number is greater than 0
personCards = personCards.Where(x => x.NumberOfCards > 0).ToList();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debugger.Break();
throw ex;
}
return(personCards.Select(x => x.Card).ToList());
}
public void OpenScryfall(DeckCard card)
{
var localCard = localData.Cards.FirstOrDefault(lc => lc.Prints.Any(p => p.Id == card.SelectPrint.Id));
if (localCard != null)
{
System.Diagnostics.Process.Start(localCard.ScryUrl);
}
}
public void setDetailCard(DeckCard deckCard)
{
this.deckCard = deckCard;
leveledUp = false;
setUI(deckCard.cat);
setInfo(deckCard.cat);
setStats(deckCard.cat);
gameObject.SetActive(true);
}
public void YieldCat()
{
// assumes player has enough gold
CatType result = Yield();
Cat newCat = new Cat(result);
newCat.catLvl = new CatLevel(MathUtils.FairEnemyCatLevel(DataUtils.getTotalLevels(), MathUtils.progressThroughWorld(), UnityEngine.Random.Range(0.4f, 0.6f)));
lastDC = GameControl.control.AddToDeck(newCat);
}
public static void Patch(this DeckCardModel deckCardModel, DeckCard deckCard, UserModel user)
{
if (deckCardModel == null)
{
return;
}
deckCardModel.Quantity = deckCard.Quantity;
deckCardModel.PatchBase(user);
}
private void DeckEditRemoveSelectedMenuItem_Click(object sender, EventArgs e)
{
foreach (DataGridViewRow row in deckEditorDataGridView.SelectedRows)
{
DeckCard deckCard = (DeckCard)row.DataBoundItem;
deckCardListBinding.Remove(deckCard);
}
refreshDeckInfoLabels();
}
public IHttpActionResult AddCardToDeck(int deckId, int cardId)
{
var deckCard = new DeckCard();
deckCard.DeckId = deckId;
deckCard.CardId = cardId;
database.DeckCards.Add(deckCard);
database.SaveChanges();
return(Ok());
}
/// <summary>
/// returns a random card from specified deck
/// simulates returning top card from a shuffled deck
/// </summary>
/// <param name="userID"> deck owner's ID </param>
/// <param name="deckType"> deck type (ie - 'play', 'collect', 'discard' </param>
/// <returns> randomly selected card from specified deck </returns>
public async Task <DeckCard> GetCard(int userID, DeckType deckType)
{
List <DeckCard> cardDeck = await GetDeck(userID, deckType);
Random random = new Random();
int rnd = random.Next(0, cardDeck.Count - 1);
DeckCard deckCard = cardDeck[rnd];
return(deckCard);
}
/// <summary>
/// (HELPER for public ResetDecks() and Slap() methods)
/// reassigns all cards in specified donor deck to specified recipient deck
/// </summary>
/// <param name="donor"> deck from which cards are to be moved </param>
/// <param name="recipient"> deck to which cards are to be moved </param>
/// <returns> completed task </returns>
private async Task ResetDecks(List <DeckCard> donor, Deck recipient)
{
DeckCard temp = new DeckCard();
foreach (DeckCard card in donor)
{
temp.CardID = card.CardID;
await UpdateDeckCard(card.CardID, card.DeckID, recipient.ID);
}
}
private DeckCard newDeckCard(Cat cat)
{
GameObject card = (GameObject)Instantiate(deckCardPrefab, transform);
card.transform.SetSiblingIndex(transform.childCount - 2);
DeckCard DC = card.GetComponent <DeckCard>();
DC.setDeckCard(cat, GameControl.GetTextBox(card, "rarity"));
return(DC);
}
public void RemoveCardFromDeck(DeckCard card)
{
var index = Deck.Cards.IndexOf(card);
if (Deck.Cards.Count < index && Deck.Cards[index + 1].IsChild)
{
Deck.Cards.RemoveAt(index + 1);
}
Deck.Cards.Remove(card);
}
public DeckCard AddToDeck(Cat cat, bool setListener)
{
DeckCard DC = newDeckCard(cat);
if (setListener)
{
DC.setListener(DeckCardFunction(DC, GameControl.control.getMainUI().detailCard));
}
return(DC);
}
public void SetInfo(DeckCard dcard)
{
cid = dcard.BaseId;
level = dcard.Level;
lastCell = -1;
skills = new List <MonsterSkill>();
string effectName = "";
if (cid > 0)
{
card = CardAssistant.GetCard(cid);
virtualRegion.SetRegionKey(3, CardConfigManager.GetCardConfig(cid).Quality + 1);
var jobId = CardConfigManager.GetCardConfig(cid).JobId;
if (jobId > 0)
{
jobId = ConfigData.GetJobConfig(jobId).JobIndex;
}
virtualRegion.SetRegionKey(4, jobId);
card.SetData(dcard);
if (card.GetCardType() == CardTypes.Monster)
{
MonsterCard monsterCard = card as MonsterCard;
if (monsterCard != null)
{
CheckMonster(monsterCard, ref effectName);
}
}
}
string nowEffectName = "";
if (coverEffect != null)
{
nowEffectName = coverEffect.Name;
}
if (effectName != nowEffectName)
{
if (effectName == "")
{
coverEffect = null;
}
else
{
coverEffect = new CoverEffect(EffectBook.GetEffect(effectName), new Point(X + 20, Y + 20), new Size(160, 180));
}
}
tooltip.Hide(parent);
if (Invalidate != null)
{
Invalidate();
}
}
public override Deck Load(string filename)
{
if(File.Exists(filename)) {
StreamReader reader = new StreamReader(filename);
List<string> list = new List<string>();
while(!reader.EndOfStream) {
list.Add(reader.ReadLine());
}
reader.Close();
reader.Dispose();
Deck deck = new Deck();
deck.Filename = filename;
deck.Name = Path.GetFileNameWithoutExtension(filename);
bool isSideboard = false;
foreach(string line in list) {
if(!line.IsNullOrTrimmedEmpty()
&& !line.StartsWith("//")) {
string correctLine = line;
// kill spaces and tabs inside of the string
correctLine = correctLine.Replace("\t", " ").Trim();
// sb?
if(correctLine.ToLower().Equals("sideboard")) {
isSideboard = true;
}
if(correctLine.StartsWith("SB:")) {
correctLine = correctLine.Replace("SB:", "").Trim();
isSideboard = true;
}
// add
if(!correctLine.ToLower().Equals("sideboard")) {
string amount = "";
string name = "";
if(correctLine[0].ToString().IsNumeric()) {
amount = correctLine.Substring(0, correctLine.IndexOf(" ")).Trim();
name = correctLine.Substring(correctLine.IndexOf(" ")).Trim();
}
else {
amount = "1";
name = correctLine.Trim();
}
DeckCard dc = new DeckCard();
dc.Amount = amount.ToInt32();
// the card object will be laoded by setting the name (part of the property)
dc.Name = name;
dc.Sideboard = isSideboard;
deck.CardList.Add(dc);
}
}
}
return deck;
}
return null;
}
public override Deck Load(string filename)
{
if(File.Exists(filename)) {
StreamReader reader = new StreamReader(filename);
List<string> list = new List<string>();
while(!reader.EndOfStream) {
list.Add(reader.ReadLine());
}
reader.Close();
reader.Dispose();
Deck deck = new Deck();
deck.Filename = filename;
deck.Name = Path.GetFileNameWithoutExtension(filename);
// TODO: Implement XML Document, currently line parsing is enough
bool isSideboard = false;
foreach(string line in list) {
string correctLine = line;
// kill spaces and tabs inside of the string
correctLine = correctLine.Replace("\t", " ").Trim();
// name
if(correctLine.Contains("<deckname>")) {
string nameLine = correctLine.Substring(correctLine.IndexOf("<deckname>") + 10)
.Trim();
nameLine = nameLine.Substring(0, nameLine.IndexOf("</deckname>"));
if(nameLine.Contains(" by ")) {
string[] splitted = nameLine.Split(new string[] { " by " }, StringSplitOptions.RemoveEmptyEntries);
deck.Name = splitted[0].Trim();
if(splitted.Length > 1) {
deck.Author = splitted[1].Trim();
}
}
else {
deck.Name = nameLine;
}
}
// comment
if(correctLine.Contains("<comments>")) {
string nameLine = correctLine.Substring(correctLine.IndexOf("<comments>") + 10)
.Trim();
nameLine = nameLine.Substring(0, nameLine.IndexOf("</comments>"));
deck.Comment = nameLine;
}
// sideboard
if(correctLine.Contains("<zone name=\"side\">")) {
isSideboard = true;
}
// add card
if(correctLine.Contains("<card ")) {
string amount = "";
string name = "";
string content = correctLine
.Replace("<card number=\"", "")
.Replace("\" name=\"", "|")
.Replace("\"/>", "");
List<string> numberAndName = content.Split("|");
if(numberAndName.Count == 2) {
amount = numberAndName[0].Trim();
name = numberAndName[1].Trim();
}
else if(numberAndName.Count == 1) {
amount = "1";
name = correctLine.Trim();
}
else {
amount = "1";
name = "Plains";
}
DeckCard dc = new DeckCard();
dc.Amount = amount.ToInt32();
// the card object will be laoded by setting the name (part of the property)
dc.Name = name;
dc.Sideboard = isSideboard;
deck.CardList.Add(dc);
}
}
return deck;
}
return null;
}
void DeckCount()
{
DeckCard a = new DeckCard(0,0,0,"");
for (int i = 0; i < Deck.Count; i++)
{
switch (Deck[i])
{
case "銅貨":
a = new DeckCard(1, 0, 0, Deck[i]);
break;
case "銀貨":
a = new DeckCard(2, 0, 0, Deck[i]);
break;
case "金貨":
a = new DeckCard(3, 0, 0, Deck[i]);
break;
case "屋敷":
a = new DeckCard(0, 0, 0, Deck[i]);
break;
case "公領":
a = new DeckCard(0, 0, 0, Deck[i]);
break;
case "属州":
a = new DeckCard(0, 0, 0, Deck[i]);
break;
case "地下貯蔵庫":
a = new DeckCard(0, 0, 0, Deck[i]);
break;
case "市場":
a = new DeckCard(1, 1, 0, Deck[i]);
break;
case "民兵":
a = new DeckCard(2, 0, -1, Deck[i]);
break;
case "鉱山":
a = new DeckCard(0, 0, -1, Deck[i]);
break;
case "堀":
a = new DeckCard(0, 2, -1, Deck[i]);
break;
case "鍛冶屋":
a = new DeckCard(0, 3, -1, Deck[i]);
break;
case "村":
a = new DeckCard(0, 1, 1, Deck[i]);
break;
case "木こり":
a = new DeckCard(2, 0, -1, Deck[i]);
break;
case "改築":
a = new DeckCard(0, 0, -1, Deck[i]);
break;
case "工房":
a = new DeckCard(0, 0, -1, Deck[i]);
break;
}
DeckList.Add(a);
}
}
public override Deck Load(string filename)
{
if(File.Exists(filename)) {
StreamReader reader = new StreamReader(filename);
List<string> list = new List<string>();
StringBuilder str = new StringBuilder();
while(!reader.EndOfStream) {
string line = reader.ReadLine();
str.Append(line);
list.Add(line);
}
reader.Close();
reader.Dispose();
Deck deck = new Deck();
deck.Filename = filename;
deck.Name = Path.GetFileNameWithoutExtension(filename);
bool isOldFormat = !str.ToString().Contains("SB:");
bool isSideboard = false;
foreach(string line in list) {
string correctLine = line;
// kill spaces and tabs inside of the string
correctLine = correctLine.Replace("\t", " ").Trim();
// name
if(correctLine.Contains("//")
&& correctLine.Contains("NAME:")) {
string nameLine = correctLine.Substring(correctLine.IndexOf("NAME") + 4)
.Replace(":", "")
.Trim();
if(correctLine.Contains(" by ")) {
string[] splitted = nameLine.Split(new string[] { " by " }, StringSplitOptions.RemoveEmptyEntries);
deck.Name = splitted[0].Trim();
if(splitted.Length > 1) {
deck.Author = splitted[1].Trim();
}
}
else {
deck.Name = nameLine;
}
}
// comment
if(correctLine.Contains("//")
&& correctLine.ToLower().Contains("comment")) {
string nameLine = correctLine.Substring(correctLine.IndexOf("COMMENT") + 7)
.Replace(":", "")
.Trim();
deck.Comment = nameLine;
}
// sb?
if(isOldFormat
&& correctLine.Contains("//")
&& correctLine.ToLower().Contains("sideboard")) {
isSideboard = true;
}
// add
if(!correctLine.IsNullOrTrimmedEmpty()
&& !correctLine.StartsWith("//")) {
string amount = "";
string name = "";
if(correctLine.StartsWith("SB: ")) {
correctLine = correctLine.Replace("SB: ", "");
isSideboard = true;
}
if(correctLine[0].ToString().IsNumeric()) {
amount = correctLine.Substring(0, correctLine.IndexOf(" ")).Trim();
name = correctLine.Substring(correctLine.IndexOf(" ")).Trim();
}
else {
amount = "1";
name = correctLine.Trim();
}
DeckCard dc = new DeckCard();
dc.Amount = amount.ToInt32();
// the card object will be laoded by setting the name (part of the property)
dc.Name = name;
dc.Sideboard = isSideboard;
deck.CardList.Add(dc);
}
}
return deck;
}
return null;
}
