public MainWindow()
: base(Gtk.WindowType.Toplevel)
{
Build();
deck = CardDeck.FromNewDeckOrder();
updateDeckView();
}
public void InitializeDecks(int seed)
{
StuffManager stuffManager = StuffManager.Instance;
DxMCardDeck = new CardDeck<IDxMCard>(stuffManager.DxMCards, seed);
TreasureCardDeck = new CardDeck<ITreasureCard>(stuffManager.TreasureCards, seed);
MonsterCardDeck = new CardDeck<IMonsterCard>(stuffManager.MonsterCards, seed);
}
public static void Main(string[] args)
{
CardDeck deck = new CardDeck();
deck.Shuffle();
deck.Sort();
Console.Write(deck);
}
public void ShuffleDeck()
{
var rnd = new Random();
var rndDeck = new CardDeck();
rndDeck.Clear();
while (Deck.Count > 0)
{
var rndThis = rnd.Next(Deck.Count);
rndDeck.Add(Deck[rndThis]);
Deck.Remove(Deck[rndThis]);
}
Deck = rndDeck;
}
public void TestDeckShuffle()
{
CardDeck deck = new CardDeck();
deck.Shuffle();
//TODO: what is an acceptable criteria for proper shuffling? check the first few cards?
//check the whole stack and expect x% to not be in the same spot?
Assert.IsFalse(deck[0].Value == 1 && deck[0].Suite == CardDeck.Suite.Spade
&& deck[1].Value == 2 && deck[1].Suite == CardDeck.Suite.Spade
&& deck[2].Value == 3 && deck[2].Suite == CardDeck.Suite.Spade
&& deck[3].Value == 4 && deck[0].Suite == CardDeck.Suite.Spade
&& deck[4].Value == 5 && deck[0].Suite == CardDeck.Suite.Spade);
}
/// <summary>
/// Creates a new game instance.
/// </summary>
public GameManager()
{
_gameSettings = new GameSettings();
_gameState = GameStates.NotStarted;
_playerTurnState = PlayerTurnState.None;
_gameBoard = new GameBoard();
_players = new List<Player>();
_developmentCardDeck = new CardDeck<DevelopmentCards>();
_dice = new Dice();
_tradeHelper = new TradeHelper();
_playersCardsToLose = new Dictionary<Player, int>();
_playersToStealFrom = new List<Player>();
}
public Table(int numplay, String _playername, int initstack, GameControl game)
{
players = new List<Player>(2);
cards = new List<Card>(5);
carddeck = new CardDeck();
players.Add(new Human(_playername, initstack, game));
mainplayer = (Human)players[0];
gamelog = new GameLog();
players.Add(new AIPlayer("Аркадий", initstack, game));
sblind = 2;
roundnum = 1;
}
/// <summary>
/// Begins the game
/// </summary>
/// <param name="winningLevel"> The winning level. </param>
public async void Begin(int winningLevel)
{
// initialize and shuffle the decks
DoorsCardDeck = new CardDeck<DoorsCard>(_doorsFactories.SelectMany(x => x.GetDoorsCards()));
DiscardedDoorsCards = new CardDeck<DoorsCard>();
TreasureCardDeck = new CardDeck<TreasureCard>(_treasuresFactories.SelectMany(x => x.GetTreasureCards()));
DiscardedTreasureCards = new CardDeck<TreasureCard>();
WinningLevel = winningLevel;
// give all players initial cards
Players.ForEach(ReviveHero);
// play turns until the end
while (await NextTurn()) { }
}
private static void Main(string[] args)
{
var deck = new CardDeck();
var dealer = new Dealer(deck);
List<PlayingCard> hand;
int numberOfShuffles = 0;
do
{
numberOfShuffles++;
dealer.ShuffleDeck();
hand = dealer.DrawCards();
} while (Dealer.FourOfAKindOfNumber(hand, 3) == false);
Console.WriteLine("Done after: " + numberOfShuffles);
Console.ReadLine();
}
private string Round(ref CardDeck deck1, ref CardDeck deck2, string username1, string username2)
{
Card card1Deck = deck1.GetRandomCard();
Card card2Deck = deck2.GetRandomCard();
// create new cards instead of references
Card card1 = card1Deck switch
{
Dragon d => new Dragon(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
Elve e => new Elve(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
Goblin g => new Goblin(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
Knight k => new Knight(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
Kraken k => new Kraken(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
Orc o => new Orc(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
Wizard w => new Wizard(card1Deck.ID, card1Deck.Name, card1Deck.Damage, card1Deck.Type),
FireSpell f => new FireSpell(card1Deck.ID, card1Deck.Name, card1Deck.Damage),
NormalSpell n => new NormalSpell(card1Deck.ID, card1Deck.Name, card1Deck.Damage),
WaterSpell w => new WaterSpell(card1Deck.ID, card1Deck.Name, card1Deck.Damage),
};
Card card2 = card2Deck switch
{
Dragon d => new Dragon(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
Elve e => new Elve(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
Goblin g => new Goblin(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
Knight k => new Knight(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
Kraken k => new Kraken(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
Orc o => new Orc(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
Wizard w => new Wizard(card2Deck.ID, card2Deck.Name, card2Deck.Damage, card2Deck.Type),
FireSpell f => new FireSpell(card2Deck.ID, card2Deck.Name, card2Deck.Damage),
NormalSpell n => new NormalSpell(card2Deck.ID, card2Deck.Name, card2Deck.Damage),
WaterSpell w => new WaterSpell(card2Deck.ID, card2Deck.Name, card2Deck.Damage),
};
//card1.Damage = card1.Damage * _elementEffectivenessService.CompareElements(card1.Type, card2.Type);
//card2.Damage = card2.Damage * _elementEffectivenessService.CompareElements(card2.Type, card1.Type);
card1.EnhanceDamage(_elementEffectivenessService.CompareElements(card1.Type, card2.Type));
card2.EnhanceDamage(_elementEffectivenessService.CompareElements(card2.Type, card1.Type));
// without special abilities
/*int card1wins = card1 switch
* {
* IMonster monster => monster.CompareDamage(card2.Damage) ? 1 : -1,
* ISpell spell => spell.CompareDamage(card2.Damage) ? 1 : -1,
* _ => 0
* };*/
Random random = new Random();
bool boosterCard1 = (random.Next(1, 21) == 20);
if (boosterCard1)
{
//card1.Damage = card1.Damage * 10;
card1.EnhanceDamage(10);
}
int card1wins = card1 switch
{
IMonster _ when card2 is IMonster => FightMonsterMonster(card1, card2),
IMonster _ when card1 is ISpell => FightMonsterSpell(card1, card2),
ISpell _ when card2 is IMonster => FightSpellMonster(card2, card1),
_ => FightSpellSpell(card1, card2)
};
string roundLog;
if (card1wins == 1)
{
deck1.AddCard(card2Deck, true);
deck2.RemoveCard(card2Deck);
if (boosterCard1)
{
roundLog = (card1Deck.ToBattleString() + " (" + username1 + ") won with a booster against " + card2Deck.ToBattleString() + " (" + username2 + ")");
}
else
{
roundLog = (card1Deck.ToBattleString() + " (" + username1 + ") won against " + card2Deck.ToBattleString() + " (" + username2 + ")");
}
}
else if (card1wins == -1)
{
deck2.AddCard(card1Deck, true);
deck1.RemoveCard(card1Deck);
if (boosterCard1)
{
roundLog = (card1Deck.ToBattleString() + " (" + username1 + ") lost although a booster to " + card2Deck.ToBattleString() + " (" + username2 + ")");
}
else
{
roundLog = (card1Deck.ToBattleString() + " (" + username1 + ") lost to " + card2Deck.ToBattleString() + " (" + username2 + ")");
}
}
else
{
if (boosterCard1)
{
roundLog = (card1Deck.ToBattleString() + " (" + username1 + ") drew although a booster with " + card2Deck.ToBattleString() + " (" + username2 + ")");
}
else
{
roundLog = (card1Deck.ToBattleString() + " (" + username1 + ") drew with " + card2Deck.ToBattleString() + " (" + username2 + ")");
}
}
return(roundLog);
}
public CardCreate()
{
deck = new CardDeck();
_updating = false;
cardsToDelete = new List <int>();
}
private void DoneButton_Click(object sender, RoutedEventArgs e)
{
CardDeck deck = DataContext as CardDeck;
deck.SaveDeck.Execute(null);
}
public void Setup()
{
testDeck = new CardDeck(() => { return(new Card()); });
}
private AITuple <int, string, int> getSpecialEval(CardGame game, Field field, Card card)
{
AITuple <int, string, int> result = AITuple.Create(-1, "", -1);
if (card.Power == 1)
{
var t1 = calcFieldScore(game.Turn, field, card);
int min = Int32.MaxValue;
foreach (Field f in game.Fields)
{
CardDeck deck = f.CardList[game.Turn];
if (!f.IsFixed && deck.Count() > 0)
{
Card c = deck.Last();
if (c == card)
{
if (deck.Count() > 1)
{
c = deck[deck.Count() - 2];
}
else
{
continue;
}
}
var t2 = calcFieldScore(game.Turn, f, c);
if (t2.Item1 < min)
{
min = t2.Item1;
result = AITuple.Create(EVAL_SPECIAL1_A - (min + t1.Item1) * EVAL_SPECIAL1_B, c.Name, f.Number);
}
}
}
}
else if (card.Power == 3)
{
int max = game.Player.Hand.Max(c => c.Power);
result = AITuple.Create(EVAL_SPECIAL3_A - (max * EVAL_SPECIAL3_B), "", -1);
}
else if (card.Power == 5)
{
int enemyTurn = (game.Turn + 1) % 2;
int myTurn = game.Turn;
Dictionary <Color, Int32> score = new Dictionary <Color, Int32>();
score[Color.Red] = 0;
score[Color.White] = 0;
score[Color.Blue] = 0;
score[Color.Black] = 0;
score[Color.Green] = 0;
foreach (Card c in field.CardList[enemyTurn])
{
score[c.Color]--;
}
foreach (Card c in field.CardList[myTurn])
{
score[c.Color]++;
}
int maxScore = Int32.MinValue;
Color maxColor = null;
foreach (Color c in Color.List)
{
int s = score[c] - score[field.Color];
if (maxScore < s)
{
maxScore = s;
maxColor = c;
}
}
result = AITuple.Create(EVAL_SPECIAL5_A + maxScore * EVAL_SPECIAL5_B, maxColor.ToString(), -1);
}
else if (card.Power == 7)
{
var t1 = calcFieldScore(game.Turn, field, card);
int max = -1;
foreach (Field f in game.Fields)
{
CardDeck deck = f.CardList[(game.Turn + 1) % 2];
if (!f.IsFixed && deck.Count() > 0)
{
Card c = deck.Last();
if (c == card)
{
if (deck.Count() > 1)
{
c = deck[deck.Count() - 2];
}
else
{
continue;
}
}
var t = calcFieldScore(game.Turn, f, c);
if (t.Item1 > max)
{
max = t.Item1;
result = AITuple.Create((max - t1.Item1) * EVAL_SPECIAL7_B + EVAL_SPECIAL7_A, c.Name, f.Number);
}
}
}
}
else if (card.Power == 9)
{
int count = 0;
foreach (Field f in game.Fields)
{
CardDeck deck = f.CardList[(game.Turn + 1) % 2];
if (deck.Count() == 2)
{
count++;
}
}
result = AITuple.Create(count * EVAL_SPECIAL9_B + EVAL_SPECIAL9_A, "", -1);
}
return(result);
}
public void Setup()
{
_deck = new CardDeck();
}
public virtual void ReplaceCard(CardDeck deck)
{
}
public void Constructor_AllDefaultParametersAndJokers_PlayingWithAFullDeckContainingJokers()
{
var deck = new CardDeck(numJokers: 2);
deck.ToString().RemoveAllWhiteSpace().ShouldBeEquivalentTo(FullDeckStringWithJokers.RemoveAllWhiteSpace());
}
public void Constructor_AllDefaultParameters_PlayingWithAFullDeck()
{
var deck = new CardDeck();
deck.ToString().RemoveAllWhiteSpace().ShouldBeEquivalentTo(FullDeckString.RemoveAllWhiteSpace());
}
public void Constructor_AllDefaultParameters_CreatesAStandard52CardDeck()
{
var deck = new CardDeck();
deck.DeckSize.Should().Be(52);
}
public void Constructor_BadParameters_ThrowsExceptions()
{
var deck = new CardDeck(-2, -45, -3);
// should throw argument exceptions
}
public void Creation_ThrowsArgumentNullException_WhenGivenNull()
{
_ = new CardDeck(null);
}
public static void DrawCardDeck(this Graphics g, Point point,
CardDeck deck)
{
CardsWrapper.DrawDeck(g, point.X, point.Y, deck, Color.Empty);
}
public static void DrawCardDeck(this Graphics g, int x, int y,
CardDeck deck)
{
CardsWrapper.DrawDeck(g, x, y, deck, Color.Empty);
}
public void Setup()
{
cardDeck = new CardDeck();
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
Console.WriteLine(" GRAMY W OCZKO !!!");
CardDeck cd = new CardDeck();
Player comp = new Player();
Player home = new Player();
home.PushCard(cd.GetTwoCards());
comp.PushCard(cd.GetTwoCards());// komputer jako krupier - po dwie karty
int pv = home.GetHandCardsValue();
int cv = comp.GetHandCardsValue();
Console.WriteLine("Karty gracza" + string.Join(' ', home.GetHandCardsList));
Console.WriteLine(home.GetHandCardsValue());
int i = 2;
Console.WriteLine("Dodać karte t/n");
string linia = Console.ReadLine();
while (linia == "t")
{
home.PushCard(cd.GetOneCard());
Console.WriteLine(string.Join(' ', home.GetHandCardsList[i]));
Console.WriteLine(home.GetHandCardsValue());
if (home.GetHandCardsValue() < 21)
{
Console.WriteLine("Dodać karte t/n");
}
else if (home.GetHandCardsValue() == 21)
{
Console.WriteLine("Masz oczko!!!");
break;
}
else
{
Console.WriteLine("Przegrana");
break;
}
linia = Console.ReadLine();
if (linia != "t")
{
break;
}
i++;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
Console.WriteLine("Karty komputera" + string.Join(' ', comp.GetHandCardsList));
Console.WriteLine(comp.GetHandCardsValue());
i = 2;
int toGoal = 21 - cv;
var newList = cd.GetTabCards.FindAll(x => x.Value < toGoal);
if (newList.Count > 6)
{
linia = "t";
}
//foreach(var c in newList)
//{
// Console.WriteLine(string.Join(' ', c));
// Console.WriteLine(newList.Count);
//}
newList.Clear();
while (linia == "t")
{
comp.PushCard(cd.GetOneCard());
Console.WriteLine(string.Join(' ', comp.GetHandCardsList[i]));
Console.WriteLine(comp.GetHandCardsValue());
if (comp.GetHandCardsValue() < 21)
{
cv = comp.GetHandCardsValue();
toGoal = 21 - cv;
newList = cd.GetTabCards.FindAll(x => x.Value < toGoal);
if (newList.Count > 6)
{
linia = "t";
}
newList.Clear();
}
else if (comp.GetHandCardsValue() == 21)
{
Console.WriteLine("Masz oczko!!!");
break;
}
else
{
Console.WriteLine("Przegrana");
break;
}
if (linia != "t")
{
break;
}
i++;
}
if (cv > pv)
{
Console.WriteLine($"{home.Name} WIN");
}
else
{
Console.WriteLine("COMP WIN");
}
//for (int i = 0; i < 52; i++)
//{
// Card card = cd.GetCard(i);
// Console.WriteLine(card.ToString());
//}
//Console.ReadLine();
}
public static void DrawDeck(Graphics g, int x, int y, CardDeck deck, Color color)
{
if (!isInitialized)
{
LOG.Warn("Cannot draw card deck: Not initialized!");
return;
}
IntPtr hDC = g.GetHdc();
try
{
Cards.cdtDraw(hDC, x, y, (int)deck, 1, color.ToBGR());
}
finally
{
g.ReleaseHdc(hDC);
}
}
public Form1()
{
InitializeComponent();
carddeck = new CardDeck();
}
private void mnuNew_Click(object sender, EventArgs e)
{
deck = new CardDeck();
ShowCard();
ShowBackCard();
}
public static void DrawCardDeck(this Graphics g, Rectangle rect,
CardDeck deck)
{
CardsWrapper.DrawDeck(g, rect.X, rect.Y, rect.Width, rect.Height, deck, Color.Empty);
}
/// <summary>
/// Игрок кладет одну карту себе в колоду
/// </summary>
/// <param name="card">Добавляемая карта</param>
public void PutCardInDeck(CardDeck.CardFactory card)
{
cardsOnHand.AddCardToDeck(card);
}
public static string ToJson(CardDeck deck, bool prettyPrint)
{
return(JsonUtility.ToJson(deck, prettyPrint));
}
public void addCard(BasicCard card)
{
CardDeck.Add(card);
}
public static CardDeck FromFile(string path)
{
TextAsset ingredientDeckJson = Resources.Load <TextAsset>(path);
return(CardDeck.FromJson(ingredientDeckJson.text));
}
public void sort()
{
CardDeck.Sort();
}
public GameItem( DeckSize deckSize )
: base( 0x12AB )
{
_deck = new CardDeck( deckSize );
}
public void addCardRandomlyToDeck(BasicCard card)
{
int index = random.Next(0, topCardIndex());
CardDeck.Insert(index, card);
}
public void InitializeNewGame()
{
User[] users = new User[NUM_USERS];
for (int i = 0; i < NUM_USERS; i++)
{
string path = Path.Combine(Application.persistentDataPath, "testdeck_player" + i + ".xml");
Debug.Log("path=" + path);
//create a new deck
CardDeck newDeck = new CardDeck();
//print the cards in the draw pile
newDeck.Print(CardDeck.DeckType.DrawPile);
if (File.Exists(path) == true)
{
newDeck.Load(path);
}
else
{
newDeck.GenerateTestCards();
}
//shuffle it
newDeck.Shuffle(new List <CardDeck.DeckType>()
{
CardDeck.DeckType.All
}, false);
//print the cards in the draw pile now that they're shuffled
newDeck.Print(CardDeck.DeckType.DrawPile);
//shuffle it again, this time returning all the cards to the drawpile
newDeck.Shuffle(new List <CardDeck.DeckType>()
{
CardDeck.DeckType.All
}, true);
//print the draw pile again
newDeck.Print(CardDeck.DeckType.DrawPile);
newDeck.Save(path);
for (int k = 0; k < newDeck.DrawPile.cards.Count; k++)
{
newDeck.DrawPile.cards[k].CardValue = randomGenerator.Next(1, 20);
}
users[i] = new User(i, "Player " + i, newDeck);
}
_game = new BasketballCardGame(users, DEBUG_WIN_SCORE);
// Flip a coin to see who goes first.
int flip = randomGenerator.Next(2);
_currentUser = _game.Users[flip];
// Game is initialized;
_game.IsInitialized = true;
}
public DeckPickedEvent(CardDeck deck)
{
this.deck = deck;
}
public Tuple <int, string> Battle(User user1, User user2)
{
CardDeck deck1 = new CardDeck();
foreach (var card in user1.Deck.CardCollection)
{
deck1.AddCard(card);
}
CardDeck deck2 = new CardDeck();
foreach (var card in user2.Deck.CardCollection)
{
deck2.AddCard(card);
}
Random random = new Random();
int roundNumber;
bool roundsStartAtZero = false;
if (random.Next(0, 2) == 0)
{
roundNumber = 0;
roundsStartAtZero = true;
}
else
{
roundNumber = 1;
}
Dictionary <string, string> battleLog = new Dictionary <string, string>();
battleLog.Add("Result", "");
while (deck1.CardCollection.Count > 0 && deck2.CardCollection.Count > 0 && roundNumber < 100)
{
string roundLog = "";
if (roundNumber % 2 == 0)
{
roundLog += Round(ref deck1, ref deck2, user1.Username, user2.Username);
}
else
{
roundLog += Round(ref deck2, ref deck1, user2.Username, user1.Username);
}
if (roundsStartAtZero)
{
battleLog.Add("Round " + (roundNumber + 1), roundLog);
}
else
{
battleLog.Add("Round " + roundNumber, roundLog);
}
roundNumber++;
}
if ((roundNumber == 100 && !roundsStartAtZero) || (roundNumber == 99 && roundsStartAtZero))
{
battleLog["Result"] = "DRAW";
return(Tuple.Create(0, JsonSerializer.Serialize(battleLog)));
}
if (deck1.CardCollection.Count > deck2.CardCollection.Count)
{
battleLog["Result"] = user1.Username + " won against " + user2.Username;
return(Tuple.Create(1, JsonSerializer.Serialize(battleLog)));
}
else
{
battleLog["Result"] = user2.Username + " won against " + user1.Username;
return(Tuple.Create(-1, JsonSerializer.Serialize(battleLog)));
}
}
public CardDistributor()
{
TableCards = new GameObject[5];
CardDeck = new CardDeck();
playersFilter = new PlayersFilter ();
}
public void DeckMustContains52Cards()
{
var newDeck = CardDeck.BuildDeck();
Assert.AreEqual(52, newDeck.Count);
}
// null
// 找到最优解
public static CardDeck SelectCard(int mybc, int addbc, int fcp, int fcp_max, int flv)
{
List<CardDeck> decklst = new List<CardDeck>();
//我瞎猜的
flv = (int)((float)flv * 1.19);
Script.frm.LogUpdateFunction("SordCard NeedBC=" + (addbc + Math.Sqrt(fcp / (float)fcp_max) * flv) + " Lv=" + flv + " fcp=" + fcp);
if (mybc - 4 < addbc + Math.Sqrt(fcp / (float)fcp_max) * flv)
{
Script.frm.LogUpdateFunction("NeedBC=" + (addbc + Math.Sqrt(fcp / (float)fcp_max) * flv) + "预算CP超出当放弃自动配卡");
return null;
}
//得到能击杀妖精卡组
//得到LV>10 CP + 4 < SQRT(FCP/FCP_MAX)*flv 全排列卡组
int cardCnt = MA.cardlst.Count;
for (int i = 0; i < cardCnt; i++)
{
CardDeck deck = new CardDeck();
if (MA.cardlst[i].lv < 10)
continue;
if (MA.cardlst[i].cp > 50)
continue;
if (useautocard_cp > (MA.cardlst[i].hp + MA.cardlst[i].power) / MA.cardlst[i].cp)
continue;
deck.card[0] = MA.cardlst[i];
for (int j = 0; j < cardCnt; j++)
{
if (i == j || MA.cardlst[j].master_card_id == deck.card[0].master_card_id)
continue;
if (MA.cardlst[j].lv < 10)
continue;
if (MA.cardlst[j].cp > 50)
continue;
if (useautocard_cp > (MA.cardlst[j].hp + MA.cardlst[j].power) / MA.cardlst[j].cp)
continue;
deck.card[1] = MA.cardlst[j];
deck.cp = deck.card[0].cp + deck.card[1].cp;
deck.power = deck.card[0].power + deck.card[1].power;
deck.hp = deck.card[0].hp + deck.card[1].hp;
if (deck.cp > addbc + Math.Sqrt(fcp / (float)fcp_max) * flv)
decklst.Add(deck.Copy());
for (int k = 0; k < cardCnt; k++)
{
if (i == k || MA.cardlst[k].master_card_id == deck.card[0].master_card_id)
continue;
if (i == k || MA.cardlst[k].master_card_id == deck.card[1].master_card_id)
continue;
if (MA.cardlst[k].lv < 10)
continue;
if (MA.cardlst[k].cp > 50)
continue;
if (useautocard_cp > (MA.cardlst[k].hp + MA.cardlst[k].power) / MA.cardlst[k].cp)
continue;
deck.card[2] = MA.cardlst[k];
deck.cp = deck.card[0].cp + deck.card[1].cp + deck.card[2].cp;
deck.power = deck.card[0].power + deck.card[1].power + deck.card[2].power;
deck.hp = deck.card[0].hp + deck.card[1].hp + deck.card[2].hp;
if (deck.cp > addbc + Math.Sqrt(fcp / (float)fcp_max) * flv)
decklst.Add(deck.Copy());
}
deck.card[2] = null;
}
deck.card[1] = null;
}
//
if (decklst.Count == 0 || decklst[0].cp > mybc)
{
Script.frm.LogUpdateFunction("找不出能日死的组合??");
return null;
}
if (decklst[0].cp > mybc)
{
Script.frm.LogUpdateFunction("NeedBC=" + (addbc + Math.Sqrt(fcp / (float)fcp_max) * flv) + " +8 计算CP超出当放弃自动配卡");
return null;
}
//找出BC相同最大输出卡组
//得到CP升序排列
int cp = decklst[0].cp;
int deck_i = 0;
int deck_output = decklst[0].hp + decklst[0].power;
if (decklst.Count >= 2)
{
for (int i = 1; i < decklst.Count; i++)
{
if (decklst[i].cp != cp)
{
break;
}
int deck_o = decklst[i].hp + decklst[i].power;
if (deck_output < deck_o)
{
deck_i = i;
deck_output = deck_o;
}
}
}
return decklst[deck_i];
}
/*
* ASSESSMENT4 ADDITION: added code which creates a PVC unit, places it within the scene and
* links it to the game class.
*/
private void Setup()
{
// initialize the game, map, and players with any references needed
// the "GameManager" asset contains a copy of the GameManager object
// in the 4x4 Test, but its script lacks references to players & the map
game = MonoBehaviour.Instantiate(Resources.Load <GameObject>("GameManager")).GetComponent <Game>();
// the "Map" asset is a copy of the 4x4 Test map, complete with
// adjacent sectors and landmarks at (0,1), (1,3), (2,0), and (3,2),
// but its script lacks references to the game & sectors
map = MonoBehaviour.Instantiate(Resources.Load <GameObject>("Map")).GetComponent <Map>();
// the "Players" asset contains 4 prefab Player game objects; only
// references not in its script is each player's color
players = MonoBehaviour.Instantiate(Resources.Load <GameObject>("Players")).GetComponentsInChildren <Player>();
// the "GUI" asset contains the PlayerUI object for each Player
gui = MonoBehaviour.Instantiate(Resources.Load <GameObject>("GUI")).GetComponentsInChildren <PlayerUI>();
// the "Scenery" asset contains the camera and light source of the 4x4 Test
// can uncomment to view scene as tests run, but significantly reduces speed
//MonoBehaviour.Instantiate(Resources.Load<GameObject>("Scenery"));
// establish references from game to players & map
game.players = players;
game.gameMap = map.gameObject;
// establish references from map to game & sectors (from children)
map.game = game;
map.sectors = map.gameObject.GetComponentsInChildren <Sector>();
// establish references to SSB 64 colors for each player
players[0].SetColor(Color.red);
players[1].SetColor(Color.blue);
players[2].SetColor(Color.yellow);
players[3].SetColor(Color.green);
// establish references to a PlayerUI and Game for each player & initialize GUI
for (int i = 0; i < players.Length; i++)
{
players[i].SetGui(gui[i]);
players[i].SetGame(game);
players[i].GetGui().Initialize(players[i], i + 1);
players[i].SetHuman(true);
}
// enable game's test mode
game.EnableTestMode();
//ASSESSMENT4 ADDITION:
GameObject winScreen = new GameObject("winScreen");
winScreen.AddComponent <UnityEngine.UI.Text> ();
game.winnerScreen = winScreen;
GameObject pvc = new GameObject("pvc");
pvc.AddComponent <Landmark> ();
pvc.AddComponent <MeshRenderer> ();
pvc.AddComponent <MeshCollider> ();
game.viceChancellorGameObj = pvc;
GameObject cardDeck = new GameObject("PunishmentCardMenu");
GameObject cardMenu = new GameObject("Menu");
cardMenu.transform.parent = cardDeck.transform;
cardDeck.SetActive(false);
CardDeck cd = cardDeck.AddComponent <CardDeck> ();
cd.menu = cardMenu;
cardDeck.SetActive(true);
game.cardDeck = cd;
}
/// <summary>
/// Получение картинки карты
/// </summary>
/// <param name="card">сама карта</param>
/// <returns>картинка карты</returns>
System.Windows.Controls.Image GetImagePicture(CardDeck.CardFactory card)
{
CardDeck.ImageGraphic image = new CardDeck.ImageGraphic();
return image.GetCardImage(card);
}
public void CardDeck_Validate_Number_Of_Cards()
{
CardDeck newCardDeck = CreateCardDeck();
Assert.AreEqual(newCardDeck.cardDeck.Count, CardDeck.DeckSize);
}
private void CreateNewDeck()
{
CardDeck newDeck = CollectionUtils.NewDeck(deckNameInput.text);
OpenDeck(newDeck);
}
public Dealer(CardDeck deck)
{
Deck = deck;
}
public void AddCards(CardDeck deck) //adds two decks together. Input is put on the "bottom" of the original deck. (For shuffling, add discard pile to original deck)
{
_deck.AddRange(deck.getCards());
}
public void CreateDeck()
{
var deck = new CardDeck();
Assert.IsNotNull(deck);
}
public static void DrawCardDeck(this Graphics g, int x, int y, int width, int height,
CardDeck deck)
{
CardsWrapper.DrawDeck(g, x, y, width, height, deck, Color.Empty);
}
public void CardsInDeck()
{
var deck = new CardDeck();
Assert.AreEqual(deck.Cards.Count, Constants.NUMBER_OF_CARDS_IN_DECK);
}
private void DisplayDeckInfoUI(CardDeck openDeck)
{
Debug.Log("Displaying info for open deck");
}
public CardDeck Copy()
{
CardDeck d = new CardDeck();
d.power = power;
d.hp = hp;
d.cp = cp;
if (card[0] != null)
d.card[0] = card[0].Copy();
if (card[1] != null)
d.card[1] = card[1].Copy();
if (card[2] != null)
d.card[2] = card[2].Copy();
return d;
}
public void Setup()
{
testDeck = new CardDeck(() => { return new Card(); });
}
