public override void BeforePlay(GameModel gameModel)
{
if (this.mimic == null)
{
CardModel target = null;
if (this.forceMimic != null)
{
target = this.forceMimic;
}
else
{
Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.BandOfMisfits, "Play Band of Misfits as...", gameModel.SupplyPiles.Where(p => p.GetCost() < gameModel.GetCost(this) && !p.CostsPotion && p.Count > 0 && p.Card.Is(CardType.Action)));
if (pile != null)
{
target = (CardModel)Activator.CreateInstance(pile.TopCard.GetType());
}
}
if (target != null)
{
this.mimic = target;
if (this.lockCount > 0)
{
this.forceMimic = target;
}
this.SetMimic();
}
}
}
public void Update(CardModel model)
{
CardId = model.CardId;
ListId = model.ListId;
//CreatDate = model.CreatDate;
Text = model.Text;
}
public CardRun(CardIdentity id)
: base(id.ToString())
{
_card = id.Model;
if (id.Model == null)
id.Revealed += new CardIdentityNamer {Target = this}.Rename;
}
public void UnselectCard(CardModel model)
{
SetActiveCard(model);
if (model.ModelCard == null) return;
Cards[model.ModelCard.RawInt].Available = true;
BoardCards[ActiveCard].ModelCard = null;
}
public override int GetCoins(CardModel cardModel, int coins)
{
if (cardModel is Copper)
{
return coins + 1;
}
return coins;
}
public CreateCard(Player owner, int id, ulong key, bool faceUp, CardModel model, int x, int y, bool deletesWhenLeavesGroup)
{
this.owner = owner;
this.id = id; this.key = key;
this.faceUp = faceUp; this.deletesWhenLeavesGroup = deletesWhenLeavesGroup;
this.model = model;
this.x = x; this.y = y;
}
public override void Play(GameModel gameModel)
{
this.choice = gameModel.CurrentPlayer.Chooser.ChooseZeroOrOneCard(CardChoiceType.TrashForTaxman, "You may trash a Treasure from your hand.", ChoiceSource.FromHand, gameModel.CurrentPlayer.Hand.Where(c => c.Is(CardType.Treasure)));
if (this.choice != null)
{
gameModel.CurrentPlayer.Trash(this.choice);
}
}
public void SelectCard(CardModel model)
{
if (BoardCards[ActiveCard].ModelCard != null)
Cards[BoardCards[ActiveCard].ModelCard.RawInt].Available = true;
Cards[model.ModelCard.RawInt].Available = false;
BoardCards[ActiveCard].ModelCard = model.ModelCard;
if (ActiveCard < 4) ActiveCard++;
}
void Awake()
{
cardModel = card.GetComponent<CardModel>();
counter = 0;
generator = new VictimGenerator();
cardModel.v = generator.generateVictim();
generateText(cardModel.v,cardModel);
cardModel.ToggleFace(false);
}
internal Card(Player owner, int id, ulong key, CardDef def, CardModel model, bool mySecret)
: base(owner)
{
_id = id;
Type = new CardIdentity(id) {Alias = false, Key = key, Model = model, MySecret = mySecret};
// var _definition = def;
All.Add(id, this);
_alternateOf = null;
numberOfSwitchWithAlternatesNotPerformed = 0;
_isAlternateImage = false;
}
public CardModel ChooseOneCard(CardChoiceType choiceType, CardModel cardInfo, string choiceText, ChoiceSource source, IEnumerable<CardModel> choices)
{
if (choices.GroupBy(new Func<CardModel, string>(c => c.Name)).Count() <= 1)
{
return choices.FirstOrDefault();
}
else
{
return this.ChooseCards(choiceType, cardInfo, choiceText, source, 1, 1, choices).FirstOrDefault();
}
}
public void ManaCostSucceeds_ComplexTest2_NotNull()
{
var results = ManaCostModelMocks.GetCardValue<List<Card>>(ManaCostModelMocks.ComplicatedJsonResult2);
var result = results.FirstOrDefault();
var model = new CardModel() { ID = result.Id, Name = result.Name, ManaCostSimple = result.ManaCost };
var manaCost = model.ManaCost;
Assert.IsNotNull(manaCost);
Assert.IsNotNull(manaCost.Costs);
}
void OnMouseDown()
{
model = GetComponent<CardModel> ();
key = model.cardIndex;
isPressed = true;
Debug.Log ("Key is:" + key);
cardPrefab.GetComponent<AudioSource>().Play ();
System.Threading.Thread.Sleep(250);
//Destroy (cardPrefab);
}
// Use this for initialization
void Awake()
{
cardModels = new List<CardModel> ();
foreach (CardSuit suit in CARD_SUITS)
{
foreach(CardValue val in CARD_VALUES)
{
CardModel cm = new CardModel(suit,val);
cardModels.Add(cm);
}
}
}
public void ManaCostSucceeds_ComplexText2_CountMatches()
{
var results = ManaCostModelMocks.GetCardValue<List<Card>>(ManaCostModelMocks.ComplicatedJsonResult2);
var result = results.FirstOrDefault();
var model = new CardModel() { ID = result.Id, Name = result.Name, ManaCostSimple = result.ManaCost };
var manaCost = model.ManaCost;
var expectationCost = ManaCostModelMocks.ComplicatedResult2;
Assert.CountIs(manaCost.Costs, expectationCost.Costs.Count);
}
public CreateCard(Player owner, int id, ulong key, bool faceUp, CardModel model, int x, int y,
bool deletesWhenLeavesGroup)
{
_owner = owner;
_id = id;
_key = key;
_faceUp = faceUp;
_deletesWhenLeavesGroup = deletesWhenLeavesGroup;
_model = model;
_x = x;
_y = y;
}
public IEnumerable<CardModel> ChooseSeveralCards(CardChoiceType choiceType, CardModel cardInfo, string choiceText, ChoiceSource source, int minChoices, int maxChoices, IEnumerable<CardModel> choices)
{
if(choices.Count() <= minChoices)
{
return choices;
}
else if (minChoices == maxChoices && choices.GroupBy(new Func<CardModel, string>(c => c.Name)).Count() <= 1)
{
return choices.Take(minChoices);
}
else
{
return this.ChooseCards(choiceType, cardInfo, choiceText, source, minChoices, maxChoices, choices);
}
}
public void generateText(Victim v, CardModel c)
{
c.ctm.text.fontSize = 50;
string toShow = "";
if (v is Animal)
{
Animal a = (Animal)v;
toShow += (a.name + " is a " + a.gender + " " + a.species + " who is " + a.age + " years old.");
}
else
{
Person p = (Person)v;
toShow += (p.name + " is a " + p.ethnicity + " " + p.gender + " who is " + p.age + " years old. \n occupation: " + p.job);
}
c.ctm.cardText= toShow;
}
public BoardModel()
{
Cards = new CardModel[52];
for (int i = 0; i < 52; i++)
{
CardModel model = new CardModel(i);
Cards[i] = model;
}
BoardCards = new CardModel[5];
for (int i = 0; i < 5; i++)
{
CardModel model = new CardModel();
BoardCards[i] = model;
}
}
public Card(int ID, string Type, int PlayerID, CardStates State, int? Position)
{
this.ID = ID;
this.Type = Type;
this.PlayerID = PlayerID;
this.State = State;
this.Position = Position;
StringBuilder QueryText = new StringBuilder(@"SELECT * FROM Cards WHERE TYPE='");
QueryText.Append(Type);
QueryText.Append(@"'");
CardData = Db.FindCard(this.Type);
if (CardData == null)
throw new Exception(String.Format("Card {0} not found", this.Type));
this.Health = GetBaseMaxHealth();
}
/// <summary>
/// Removes a card from a deck
/// </summary>
/// <param name="card">The card to assign (the deck id property must be filled in)</param>
public void RemoveCardFromDeck(CardModel card)
{
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string sql = @"DELETE FROM decks_cards WHERE deck_id = @deckId AND card_id = @cardId;";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("@deckId", card.deckId);
cmd.Parameters.AddWithValue("@cardId", card.id);
cmd.ExecuteNonQuery();
}
}
catch (SqlException ex)
{
return;
}
}
public static Card generateRandomCardFromModel(CardModel cardModel, double cardPoints)
{
switch (cardModel)
{
default:
case CardModel.INSTANT_DICE:
return(generateRandomCardInstantDice(cardPoints));
case CardModel.INSTANT_HEALTH:
return(generateRandomCardInstantHealth(cardPoints));
case CardModel.LAST:
return(generateRandomCardLast(cardPoints));
case CardModel.FIRST:
return(generateRandomCardFirst(cardPoints));
case CardModel.MULTIPLIER:
return(generateRandomCardMultiplier(cardPoints));
case CardModel.DICE_DERIVATIVE:
return(generateRandomCardDerivative(cardPoints));
case CardModel.FIXED_DICE:
return(generateRandomCardFixedDice(cardPoints));
case CardModel.FORBID_NUMBER:
return(generateRandomCardForbidNumber(cardPoints));
case CardModel.ADD_ATTACK_ROLL:
return(generateRandomCardAddAttackRoll(cardPoints));
case CardModel.LOWER_MAX:
return(generateRandomCardLowerMax(cardPoints));
case CardModel.IMPROVE:
return(generateRandomCardImprove(cardPoints));
}
}
void AddCard(Vector3 position, int cardIndex, int positionalIndex)
{
// do nothing if already fetch the card
// without this it won't add the card
if (fetchedCards.ContainsKey(cardIndex))
{
return;
}
GameObject cardCopy = (GameObject)Instantiate(cardPrefab);
cardCopy.transform.position = position;
CardModel cardModel = cardCopy.GetComponent <CardModel>();
cardModel.cardIndex = cardIndex;
cardModel.ToggleFace(faceUp);
SpriteRenderer spriteRenderer = cardCopy.GetComponent <SpriteRenderer>();
spriteRenderer.sortingOrder = 51 - positionalIndex;
fetchedCards.Add(cardIndex, cardCopy); // The line that actually displays the card
}
private List <CardModel> ProcessDirectory(string targetDirectory)
{
List <CardModel> paths = new List <CardModel>();
string[] fileEntries = Directory.GetFiles(targetDirectory);
foreach (string fileName in fileEntries)
{
var contentPath = fileName.Replace(_outputDir.Replace("file:\\", "") + "\\", "");
CardModel card = new CardModel {
Id = fileName.GetHashCode().ToString(), Url = contentPath
};
paths.Add(card);
}
string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory);
foreach (string subdirectory in subdirectoryEntries)
{
paths.AddRange(ProcessDirectory(subdirectory));
}
return(paths);
}
public async Task <IActionResult> Patch(Guid id, [FromBody] Ruling ruling)
{
using (var repository = new Repository(HttpContext.GetUserGuid()))
{
if (!AuthorizeService.HashRight(repository.ServiceUser?.Role, Rights.EditCardRuling))
{
return(Forbid("You are not allowed to change rulings."));
}
if (string.IsNullOrWhiteSpace(ruling.RuleText))
{
return(BadRequest("The rule text is required."));
}
var rulingModel = await repository.Context.Rulings
.Include(x => x.Card)
.Include(x => x.Creator)
.Include(x => x.LastModifiedBy)
.Where(x => x.Guid == id).FirstOrDefaultAsync();
if (rulingModel == null)
{
return(NotFound());
}
CardModel cardModel = null;
if (ruling.Card != null)
{
cardModel = await repository.Context.Cards.FindByGuidAsync(ruling.Card.Guid);
}
rulingModel.Patch(ruling, cardModel, repository.ServiceUser);
ruling = rulingModel.FromDal();
await repository.Context.SaveChangesAsync();
return(Ok(ruling));
}
}
public void SetCards_RPC(string selectedCardsDictionary, int firstCardID)
{
Dictionary <int, List <int> > viewIDtoCardIDList = JsonConvert.DeserializeObject <Dictionary <int, List <int> > >(selectedCardsDictionary);
for (int i = 0; i < playerList.Count; i++)
{
PhotonView pv = playerList[i].GetComponent <PhotonView>();
List <int> cardIDList = viewIDtoCardIDList[pv.ViewID];
List <CardModel> cardModelList = new List <CardModel>();
for (int j = 0; j < cardIDList.Count; j++)
{
CardModel cardModel = cardDealer.cardsDeck.Find(x => x.cardID == cardIDList[j]);
cardModelList.Add(cardModel);
}
playerList[i].SetInitialCards(cardModelList);
}
PlayFirstCard(cardDealer.cardsDeck.Find(x => x.cardID == firstCardID));
}
public void addCard(CardModel Card, int line)
{
var fi = new FileInfo(sourceFile);
ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
using (var p = new ExcelPackage(fi))
{
//Get the Worksheet created in the previous codesample.
var ws = p.Workbook.Worksheets["Feuil1"];
line += 2;
ws.Cells[line, 1].Value = DateTime.Today.ToString();
ws.Cells[line, 2].Value = Card.Atelier;
ws.Cells[line, 3].Value = Card.Equipe;
ws.Cells[line, 4].Value = Card.Ligne;
ws.Cells[line, 5].Value = Card.Source;
ws.Cells[line, 6].Value = Card.Reference;
ws.Cells[line, 7].Value = Card.Designation;
ws.Cells[line, 8].Value = Card.RepereTopo == null ? " - ": Card.RepereTopo;
ws.Cells[line, 9].Value = Card.TypeDefaut;
ws.Cells[line, 10].Value = Card.CauseDefaut;
ws.Cells[line, 11].Value = Card.ActionComm == null ? " - " : Card.ActionComm;
ws.Cells[line, 12].Value = Card.Repartition;
ws.Cells[line, 13].Value = Card.Machine == null ? " - " : Card.Machine;
ws.Cells[line, 14].Value = Card.Responsable == null ? " - " : Card.Responsable;
ws.Cells[line, 15].Value = Card.Qte;
ws.Cells[line, 16].Value = Card.PMP;
ws.Cells[line, 17].Value = Card.Valeur;
ws.Cells[line, 18].Value = Card.EtatCarte == null ? " - " : Card.EtatCarte;
ws.Cells[line, 19].Value = Card.Operateur == null ? " - " : Card.Operateur;
ws.Cells[line, 20].Value = Card.Produit == null ? " - " : Card.Produit;
ws.Cells[line, 21].Value = Card.NumSerie == null ? " - " : Card.NumSerie;
p.Save();
}
}
public RulingModel CreateRuling(CardModel cardModel, string ruleText, Guid guid)
{
var ruling = Context.Rulings.FindByGuid(guid);
if (ruling == null)
{
var utcNow = DateTime.UtcNow;
ruling = new RulingModel
{
Guid = guid,
Card = cardModel,
RuleText = ruleText,
LastModifiedTime = utcNow,
CreateTime = utcNow,
Creator = ServiceUser,
LastModifiedBy = ServiceUser,
};
Context.Rulings.Add(ruling);
Context.SaveChanges();
}
return(ruling);
}
public void ShowCards()
{
int cardCount = 0;
foreach (int i in deck.GetCards())
{
float co = cardOffset * cardCount;
GameObject cardCopy = (GameObject)Instantiate(cardPrefab);
Vector3 temp = start + new Vector3(co, 0f);
cardCopy.transform.position = temp;
CardModel cardModel = cardCopy.GetComponent <CardModel>();
cardModel.cardIndex = i;
cardModel.ToggleFace(true);
SpriteRenderer spriteRenderer = cardCopy.GetComponent <SpriteRenderer>();
spriteRenderer.sortingOrder = cardCount;
cardCount++;
}
}
public async Task <IActionResult> UpdateCard([FromRoute] Guid cardId, [FromBody] CardRequest request)
{
if (!await IsUsersCardAsync(cardId).ConfigureAwait(false))
{
Forbid();
}
var model = new CardModel
{
Id = cardId,
Answer = request.Answer,
Question = request.Question
};
var result = await manager.UpdateCardAsync(model).ConfigureAwait(false);
if (result)
{
return(Ok());
}
return(StatusCode(500));
}
void CreateDeck()
{
int num = deck.getCardNum();
cards = new GameObject[num];
int cardCount = 0;
foreach (int i in deck.GetDeck())
{
float x = cardOffset * cardCount;
cards[i] = Instantiate(cardPref) as GameObject;
start = cards[i].transform.position;
Vector3 temp = start + new Vector3(-x, 0f, -x);
cards[i].transform.position = temp;
cardModel = cards[i].GetComponent <CardModel>();
cardModel.setIndex(i);
cardCount++;
}
}
public void Refresh(CardModel cardModel)
{
costText.text = cardModel.cost.ToString();
switch (cardModel.condition)
{
case 0:
rareEffectObj.SetActive(false);
badEffectObj.SetActive(true);
break;
case 1:
rareEffectObj.SetActive(false);
badEffectObj.SetActive(false);
break;
case 2:
rareEffectObj.SetActive(true);
badEffectObj.SetActive(false);
break;
}
}
public void Given_A_MonsterCard_When_Updated_With_CardModel_Then_CardType_Should_Contain_All_SubCategory_Ids()
{
// Arrange
var expected = new[] { 4, 23 };
var monsterCard = new Card();
var cardModel = new CardModel
{
SubCategoryIds = new List <int>(),
TypeIds = new List <int> {
4, 23
},
LinkArrowIds = new List <int>()
};
// Act
CardMapper.UpdateMonsterCardWith(monsterCard, cardModel);
// Assert
monsterCard.CardType.Select(cs => cs.TypeId).Should().ContainInOrder(expected);
}
private void comboChooser_SelectionChangeCommitted(object sender, EventArgs e)
{
// Look up picture for selected Set
Guid card = Guid.Empty;
string name = comboChooser.Items[comboChooser.SelectedIndex].ToString();
foreach (CardModel Card in SetList)
{
if (name == Card.Set.Name)
{
card = Card.Id;
}
}
GamesRepository proxy = new GamesRepository();
Game mygame = proxy.Games[GameIndex];
BitmapImage img = new BitmapImage();
System.Windows.Controls.Image CardImage = new System.Windows.Controls.Image();
mtgPicture1.Image = SourceConvert.BitmapFromUri(img != null ? CardModel.GetPictureUri(mygame,
mygame.GetCardById(card).Set.Id, mygame.GetCardById(card).ImageUri) : mygame.GetCardBackUri());
selectedCard = card;
}
public WarOutcome CompareCards(CardModel playerCard, CardModel computerCard)
{
History.Add(new HistoryModel
{
PlayerCard = playerCard,
ComputerCard = computerCard
});
//compare the rank of the cards
if (playerCard.CardRank > computerCard.CardRank)
{
return(WarOutcome.WIN); //the war wins, in the player's favor
}
else if (playerCard.CardRank < computerCard.CardRank)
{
return(WarOutcome.LOSE); //the player loses the war
}
else
{
return(WarOutcome.WAR); //cards are equivalent, so start a war.
}
}
public ActionResult EncryptValue(CardModel model)
{
//SecurityKey can be any unique key which is used to Encrypt and Decript a value.
//You will have to pass this SecurityKey along with the text you want to Cipher.
//SecurityKey can be customer's any unique value, for example: userId/CustomerGUID/Email etc.
string SecurityKey = "9898jdhjd7";//(passPhrase) value
string CardNumber, ExpMonth, ExpYear = "";
CardNumber = StringCipher.Encrypt(model.CardNumber, SecurityKey);
ExpMonth = StringCipher.Encrypt(model.ExpMonth, SecurityKey);
ExpYear = StringCipher.Encrypt(model.ExpYear, SecurityKey);
ViewBag.CardNumber = CardNumber;
ViewBag.ExpMonth = ExpMonth;
ViewBag.ExpYear = ExpYear;
return(View());
}
public IHttpActionResult PutCard(int id, CardModel card)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != card.CardId)
{
return(BadRequest());
}
#region this need to be chagne
//////////////////Below is the update part
var dbcard = db.Cards.Find(id);
dbcard.Update(card);
db.Entry(dbcard).State = EntityState.Modified;
#endregion
//db.Entry(card).State = EntityState.Modified; Original Code.
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!CardExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult Post([FromBody] CardModel std)
{
User user = db.User.FirstOrDefault(a => a.Id == std.userId);
if (user != null)
{
CreditCard cm = new CreditCard();
cm.Balance = std.balance;
cm.BankLogo = std.bankLogo;
cm.BankName = std.bankName;
cm.CardNumber = std.cardNumber;
cm.UserId = std.userId;
db.CreditCard.Add(cm);
db.SaveChanges();
return(Ok(new { status = true, message = "карта успешно добавлена!" }));
}
else
{
return(BadRequest(new { status = false, message = "Пользователь не найден" }));
}
}
public void SetCard(CardModel cardModel)
{
nameText.text = cardModel.name;
hpText.text = cardModel.hp.ToString();
atText.text = cardModel.at.ToString();
costText.text = cardModel.cost.ToString();
iconImage.sprite = cardModel.icon;
maskPanel.SetActive(!cardModel.isPlayerCard);
if (cardModel.ability == ABILITY.SHIELD)
{
shieldPanel.SetActive(true);
}
else
{
shieldPanel.SetActive(false);
}
if (cardModel.spell != SPELL.NONE)
{
hpText.gameObject.SetActive(false);
}
}
void AddCard(Vector3 position, int cardIndex)
{
if (cardIndex == -2)
{
return;
}
if (fetchedCards.ContainsKey(cardIndex))
{
return;
}
GameObject cardCopy = (GameObject)Instantiate(cardPrefab);
cardCopy.transform.position = position;
CardModel cardModel = cardCopy.GetComponent <CardModel>();
cardModel.cardIndex = cardIndex;
cardModel.ToggleFace(true);
fetchedCards.Add(cardIndex, cardCopy);
}
private string GetMetaDescription(CardModel card)
{
var desc = $"{card.CardType.Name}";
if (card.SubTypes.Count > 0)
{
desc += $" - {string.Join(" - ", card.SubTypes.Select(x => x.SubType.Name).ToList())} • ";
}
if (!desc.EndsWith(" • "))
{
desc += " • ";
}
var toc = _cardTypeService.GetTypeOfCard(card.CardType.CardTypeId);
switch (toc)
{
case Models.TypeModels.TypeOfCard.Adventure:
case Models.TypeModels.TypeOfCard.Match:
desc += $"{card.Detail.Effect} {card.Detail.ToSolve} {card.Detail.Reward} • ";
break;
case Models.TypeModels.TypeOfCard.Character:
case Models.TypeModels.TypeOfCard.Creature:
case Models.TypeModels.TypeOfCard.Item:
case Models.TypeModels.TypeOfCard.Lesson:
case Models.TypeModels.TypeOfCard.Location:
case Models.TypeModels.TypeOfCard.Spell:
desc += $"{card.Detail.Text} • ";
break;
}
desc += $"#{card.CardNumber} • Illustrated by {card.Detail.Illustrator} • Harry Potter TCG";
return(desc);
}
void OnGUI()
{
if (tagObjects.Length != 26)
{
if (GUI.Button(new Rect(450, 130, 100, 28), "Deal"))
{
if (PhotonNetwork.player.ID == 1)
{
for (int i = 0; i < 13; i++)
{
float co = cardOffset * i; //オフセット幅の計算
Vector3 temp = startfirst + new Vector3(-co, 0f); //tempというオフセットした位置の計算
GameObject cardCopy = (GameObject)PhotonNetwork.Instantiate("card", temp, Quaternion.identity, 0);
CardModel cardModel = cardCopy.GetComponent <CardModel>(); // Cardmodel を使用、
string card = "card" + i;
int indexnumber = (int)PhotonNetwork.room.customProperties[card];
cardModel.cardIndex = indexnumber; //Cardmodel.csのcardIndex に 要素の値を渡す
cardModel.ToggleFace(true); // 表面レンダーする
}
}
else
{
for (int i = 13; i < 26; i++)
{
float co = cardOffset * i; //オフセット幅の計算
Vector3 temp = startsecond + new Vector3(-co, 0f); //tempというオフセットした位置の計算
GameObject cardCopy = (GameObject)PhotonNetwork.Instantiate("card", temp, Quaternion.identity, 0);
CardModel cardModel = cardCopy.GetComponent <CardModel>(); // Cardmodel を使用、
string card = "card" + i;
int indexnumber = (int)PhotonNetwork.room.customProperties[card];
cardModel.cardIndex = indexnumber; //Cardmodel.csのcardIndex に 要素の値を渡す
cardModel.ToggleFace(true); // 表面レンダーする
}
}
}
}
}
public void Calc(decimal money)
{
CardModel card1 = new CardModel();
var card = SessionDb.Session.model1;
var balans = card.Select(x => x.Balance).FirstOrDefault();
decimal result = Convert.ToDecimal(balans) - money;
foreach (var elm in card)
{
elm.Balance = result;
}
DBQuery dBQuery = new DBQuery();
dBQuery.AddBalance(card);
SessionDb.Session.model1 = card;
CardMode.CardMode internetodeme = CardMode.CardMode.InternetOdeme;
ValidEnum @enum = new ValidEnum();
string str = @enum.IsEnumValid(internetodeme, money, result);
dBQuery.InsertMessage(str, card, "InternetOdeme");
}
private void AddResultCard(object sender, SearchCardIdEventArgs e)
{
_unsaved = true;
Deck.Element element = ActiveSection.Cards.FirstOrDefault(c => c.Card.Id == e.CardId);
if (element != null)
{
element.Quantity += 1;
}
else
{
CardModel Card = Game.GetCardById(e.CardId);
if (Card.isDependent())
{
MessageBox.Show("Unable to add " + Card.Name +
"to the deck. It is marked as dependent, which implies it is the alternate version of another card. Please try to add the original instead.",
"Warning: Add dependent card failed.", MessageBoxButton.OK);
}
ActiveSection.Cards.Add(new Deck.Element {
Card = Game.GetCardById(e.CardId), Quantity = 1
});
}
}
public void DeleteHandTest()
{
//Arrange
cgUserDB = new CGUserDB();
CardDB cardDB = new CardDB();
//Act
var userModel = cgUserDB.GetById("Test");
List <CardModel> cardsOnHand = cardDB.GetCardsByDeckId(2);
List <CardModel> filteredCardsOnHand = new List <CardModel>();
for (int i = 0; i < 5; i++)
{
CardModel card = cardsOnHand[i];
filteredCardsOnHand.Add(card);
}
cgUserDB.InsertHand(filteredCardsOnHand, userModel);
cgUserDB.DeleteHand(userModel);
CGUser user = CGUserConverter.convertFromCGUserModelToCGUser(cgUserDB.GetById("Test"));
//Assert
Assert.IsTrue(user.cards.Count == 0);
}
private void GetEFilmGroupInfo(CardModel cardModel)
{
try
{
var eFilmPage = cardModel.FilmPageModel;
if (!eFilmPage.EFilmModel.IsMixed)
{
var studyUid = eFilmPage.PageTitleInfoModel.StudyInstanceUid;
string time = null;
string efilmSeriesUid = null;
int sum = 0;
if (!eFilmGroupSeriesUid.ContainsKey(studyUid))
{
time = DateTime.Now.ToString();
efilmSeriesUid = CreateSeries(eFilmPage.EFilmModel);
eFilmGroupSeriesUid.Add(studyUid, efilmSeriesUid);
eFilmGroupTime.Add(studyUid, time);
int count = cardModelList.Count();
for (int i = 0; i < count; i++)
{
CardModel model = cardModelList[i];
if ((model != null) && (model.FilmPageModel != null) && (model.FilmPageModel.EFilmModel != null) && (!model.FilmPageModel.EFilmModel.IsMixed))
{
if ((model.FilmPageModel.PageTitleInfoModel != null) && (model.FilmPageModel.PageTitleInfoModel.StudyInstanceUid == studyUid))
{
sum++;
}
}
}
eFilmGroupCount.Add(studyUid, sum);
eFilmGroupSaveCount.Add(studyUid, 0);
}
}
}
catch (Exception ex)
{
Logger.LogFuncException(ex.Message + ex.StackTrace);
}
}
public void OnDrop(PointerEventData eventData)
{
var cardModel = CardModel.GetPointerDrag(eventData);
if (cardModel == null ||
cardModel.ParentCardZone != null && cardModel.ParentCardZone.type != CardZoneType.Area ||
cardModel.PlaceHolderCardZone != null && cardModel.PlaceHolderCardZone.type != CardZoneType.Area)
{
return;
}
var drawerViewer = DropHandler as DrawerViewer;
if (drawerViewer != null && Index != null)
{
drawerViewer.AddCard(cardModel.Value, Index ?? 0);
}
else
{
DropHandler.OnDrop(cardModel);
}
}
private void OnEvent(byte eventCode, object content, int senderId)
{
if ((eventCode == SYNC_PLAYER_DISCARD && dropZoneType == DropZoneType.PLAYER) || (eventCode == SYNC_INFECTION_DISCARD && dropZoneType == DropZoneType.INFECTION))
{
int childCount = this.transform.childCount;
for (int i = childCount - 1; i >= 0; i--)
{
if (this.transform.GetChild(i).GetComponent <CardModel>() != null)
{
Destroy(this.transform.GetChild(i).gameObject);
}
}
usedCards.Clear();
int[] cards = (int[])content;
usedCardCount = cards.Length;
usedCardCounter.text = usedCardCount.ToString();
foreach (int card in cards)
{
GameObject cardGameObject = Instantiate <GameObject>(cardPrefab);
CardModel cardModel = cardGameObject.GetComponent <CardModel>();
cardModel.ShowCardFace(card);
cardGameObject.transform.SetParent(this.transform);
cardGameObject.transform.localPosition = new Vector3(28, 0);
cardGameObject.transform.SetSiblingIndex(cardGameObject.transform.GetSiblingIndex() - 2);
cardGameObject.GetComponent <CanvasGroup>().blocksRaycasts = false;
usedCards.Add(cardGameObject);
}
}
}
public static Card GetCard(int cardId, int ownerIndex)
{
CardModel behaviourModel = ModelDatabase.Find(x => x.Id == cardId);
if (behaviourModel == null)
{
throw new BehaviourNotFoundException();
}
Card toInstantiate;
if (!behaviourModel.IsSpell)
{
toInstantiate = new Card(
behaviourModel.Id,
behaviourModel.Health,
behaviourModel.Attack,
behaviourModel.Mana,
behaviourModel.IsTaunt,
behaviourModel.GetBattlecry(),
behaviourModel.GetDeathrattle(),
behaviourModel.PlayRequirements
);
}
else
{
toInstantiate = new Card(
behaviourModel.Id,
behaviourModel.Mana,
behaviourModel.GetBattlecry(),
behaviourModel.PlayRequirements
);
}
toInstantiate.AssignCard(ownerIndex);
return(toInstantiate);
}
private void cardImage_MouseDown(object sender, MouseButtonEventArgs e)
{
if (selection == null)
{
return;
}
if (cardImage.Source.ToString().Contains(selection))
{
string alternate = cardImage.Source.ToString().Replace(".jpg", ".b.jpg");
try
{
var bim = new BitmapImage();
bim.BeginInit();
bim.CacheOption = BitmapCacheOption.OnLoad;
bim.UriSource = new Uri(alternate);
bim.EndInit();
cardImage.Source = bim;
}
catch
{
var bim = new BitmapImage();
bim.BeginInit();
bim.CacheOption = BitmapCacheOption.OnLoad;
bim.UriSource = Game.GetCardBackUri();
bim.EndInit();
cardImage.Source = bim;
}
}
else
{
var bim = new BitmapImage();
bim.BeginInit();
bim.CacheOption = BitmapCacheOption.OnLoad;
bim.UriSource = CardModel.GetPictureUri(Game, set_id, selection);
bim.EndInit();
cardImage.Source = bim;
}
}
void Awake ()
{
spriteRenderer = GetComponent<SpriteRenderer>();
model = GetComponent<CardModel>();
}
public override int GetCost(CardModel cardModel, int cost)
{
return Math.Max(cost - 1, 0);
}
public int ChooseOneEffect(EffectChoiceType choiceType, CardModel cardInfo, string choiceText, string[] choices, string[] choiceDescriptions)
{
return this.ChooseEffects(choiceType, new CardModel[] { cardInfo }, choiceText, 1, 1, choices, choiceDescriptions).First();
}
private void InsertCard(CardModel card)
{
StringBuilder fields = new StringBuilder();
StringBuilder values = new StringBuilder();
fields.Append("[id],[game_id],[set_real_id],[name],[image],[alternate],[dependent]");
values.Append("@id,@game_id,(SELECT real_id FROM sets WHERE id = @set_id LIMIT 1),@name,@image,@alternate,@dependent");
foreach (KeyValuePair<string, object> pair in card.Properties)
{
string name = string.Format("{0}{1}", Id.ToString().Replace("-",""), pair.Key);
fields.Append(string.Format(",[{0}]", name));
values.Append(string.Format(",@{0}", name.Replace(" ", "")));
PropertyType type = PropertyType.String;
object value = "";
if (pair.Value is string)
{
type = PropertyType.String;
value = (string)pair.Value;
}
else if (pair.Value is int)
{
type = PropertyType.Integer;
value = (int)pair.Value;
}
else
{
type = PropertyType.String;
value = (string)pair.Value;
}
if (!DatabaseHandler.ColumnExists("cards", name, GamesRepository.DatabaseConnection))
{
DatabaseHandler.AddColumn("cards", name, type, GamesRepository.DatabaseConnection);
}
}
StringBuilder query = new StringBuilder();
query.Append("INSERT INTO [cards](");
query.Append(fields.ToString());
query.Append(") VALUES(");
query.Append(values.ToString());
query.Append(");");
using (SQLiteCommand com = GamesRepository.DatabaseConnection.CreateCommand())
{
com.CommandText = query.ToString();
com.Parameters.AddWithValue("@id", card.Id.ToString());
com.Parameters.AddWithValue("@game_id", Id.ToString());
com.Parameters.AddWithValue("@set_id", card.Set.Id.ToString());
com.Parameters.AddWithValue("@name", card.Name);
com.Parameters.AddWithValue("@image", card.ImageUri);
com.Parameters.AddWithValue("@alternate", card.Alternate.ToString());
com.Parameters.AddWithValue("@dependent", card.Dependent.ToString());
foreach (KeyValuePair<string, object> pair in card.Properties)
{
string name = string.Format("{0}{1}", Id.ToString().Replace("-",""), pair.Key);
string key = string.Format("@{0}", name.Replace(" ", ""));
com.Parameters.AddWithValue(key, pair.Value);
}
#if(DEBUG)
Debug.WriteLine(com.CommandText);
foreach (SQLiteParameter p in com.Parameters)
{
Debug.Write("ParameterName: " + p.ParameterName + "\r\n Value: " + p.Value + "\r\n");
}
#endif
com.ExecuteNonQuery();
}
}
public CardModel ChooseZeroOrOneCard(CardChoiceType choiceType, CardModel cardInfo, string choiceText, ChoiceSource source, IEnumerable<CardModel> choices)
{
return this.ChooseSeveralCards(choiceType, choiceText, source, 0, 1, choices).FirstOrDefault();
}
public abstract IEnumerable<CardModel> ChooseCards(CardChoiceType choiceType, CardModel cardInfo, string choiceText, ChoiceSource source, int minChoices, int maxChoices, IEnumerable<CardModel> choices);
public IEnumerable<int> ChooseSeveralEffects(EffectChoiceType choiceType, CardModel cardInfo, string choiceText, int minChoices, int maxChoices, string[] choices, string[] choiceDescriptions)
{
return this.ChooseEffects(choiceType, new CardModel[] { cardInfo }, choiceText, minChoices, maxChoices, choices, choiceDescriptions);
}
public void Update(CardModel model)
{
ListId = model.ListId;
Text = model.Text;
}
public Card(CardModel model)
{
this.Update(model);
CreatedDate = DateTime.Now;
}
private void InsertCard(CardModel card)
{
cardTable.Insert();
cardTable.PutGuid("id", card.Id);
cardTable.PutString("name", card.Name);
cardTable.PutString("image", card.ImageUri);
cardTable.PutGuid("setId", card.set.Id);
foreach(KeyValuePair<string, object> pair in card.Properties)
{
if(pair.Value is string)
cardTable.PutString(pair.Key, (string)pair.Value);
else if(pair.Value is int)
cardTable.PutInt32(pair.Key, (int)pair.Value);
else // char
cardTable.PutString(pair.Key, pair.Value.ToString());
}
cardTable.Post();
}
