/// <summary>
/// Builds the deck for the current game.
/// </summary>
void Build()
{
TextAsset deckFile = Resources.Load <TextAsset>("Decks/" + deckId);
DeckData deckData = JsonUtility.FromJson <DeckData>(deckFile.text);
cards = new Stack <Card>();
for (int i = 0; i < deckData.cardStacks.Count; i++)
{
CardStack stack = deckData.cardStacks[i];
CardData data;
if (!CardsDatabase.GetById(stack.id, out data))
{
continue;
}
for (int j = 0; j < stack.ammount; j++)
{
// N copies of the same card
cards.Push(new Card(data));
}
}
Shuffle();
}
/// <summary>
///
/// Initialise the upgrade UI when it is opened
///
/// </summary>
public void InitUpgradeUI()
{
if (deckListUI != null && campaignManagerUI != null)
{
throw new Exception("UI not initialised properly");
}
upgradesToAdd = new List <UpgradeData>();
//Gets the deck currently being edited it and copies it to a new instance of the deck
if (deckListUI != null)
{
selectedDeck = GameManager.instance.deckManager.GetPlayerDeck(deckListUI.DeckEditId.Value);
honourPointsArea.SetActive(false);
}
else if (campaignManagerUI != null)
{
selectedDeck = GameManager.instance.deckManager.GetPlayerDeck(campaignManagerUI.loadedDeck.Id.Value);
honourPointsArea.SetActive(true);
upgradeCostTracker = new Dictionary <UpgradeData, int>();
RefreshHonourPoints();
}
newDeck = new DeckData(selectedDeck);
//Refreshes the available upgrades section
RefreshAvailableUpgrades();
//Refreshes the upgrade to add area with an empty list
RefreshUpgradeList(upgradesToAddArea);
//Refresh the selected upgrade with empty fields
RefreshSelectedUpgrade();
}
public static void LoadPlayer(PlayerData data, PlayerController player)
{
player.transform.position = data.Position;
player.CurrentSpirit = data.CurrentSpirit;
player.maxSpirit = data.MaxSpirit;
player.spiritCostPerDiscard = data.SpiritCostPerDiscard;
player.Health = data.Health;
player.maxHealth = data.MaxHealth;
player.Money = data.Money;
player.cardRedrawAmount = data.CardRedrawAmount;
player.maxHandSize = data.MaxHandSize;
player.maxTurnsUntilDraw = data.MaxTurnsUntilDraw;
player.turnsUntilDraw = data.TurnsUntilDraw;
player.CurrentEnergy = data.CurrentEnergy;
player.energyPerTurn = data.EnergyPerTurn;
player.xPos = data.xPos;
player.zPos = data.zPos;
player.UpdateLOS();
BattleManager.player.playerDeck = DeckData.LoadDeck(data.Deck);
foreach (var card in player.playerDeck.hand)
{
player.puim.SpawnCardInHand(card);
}
foreach (var card in player.playerDeck.inventoryCards)
{
player.puim.CardAddedToInventory(card);
}
}
public Deck[] decks;//list of decks
private void Awake()
{
//makes it so that there is only one instance of the deckManager object at all times
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(this.gameObject);
}
else if (this != Instance)
{
Destroy(this.gameObject);
}
//loads all of the decks as soon as this script is first used
for (int i = 0; i < 5; i++)
{
DeckData data = SaveSystem.LoadDeck(i + 1);
if (data != null)
{
decks[i].name = data.deckName;//loads the name of the deck
var allCards = GetComponent <CardList>().cards;
for (int j = 0; j < 30; j++)
{
for (int k = 0; k < 10; k++)
{
if (data.cards[j] == allCards[k].name)
{
decks[i].cards[j] = allCards[k];
}
}
}
}
}
}
public void SetControlledDeck(DeckData deckData = null)
{
if (deckData == null)
{
ControlledDeckData = new DeckData();
UserData.Instance.OwnedDeckList.Add(ControlledDeckData);
DeckNameText.text = ControlledDeckData.DeckName;
DeckCardCountText.text = ControlledDeckData.CardCount + "/30";
}
else
{
ControlledDeckData = deckData;
DeckNameText.text = ControlledDeckData.DeckName;
DeckCardCountText.text = ControlledDeckData.CardCount + "/30";
}
if (DisplayDeckElementList != null)
{
foreach (var element in DisplayDeckElementList)
{
if (element != null)
{
Destroy(element.gameObject);
}
}
DisplayDeckElementList.Clear();
}
SettingDisplayElement();
}
public void ActiveMainUI()
{
//덱 세팅
var deckDataDic = DeckManager.Instance.DeckDic;
for (int i = 0; i < mainSlotUIArray.Length; i++)
{
DeckData deckData = null;
if (deckDataDic.ContainsKey(i))
{
deckData = deckDataDic[i];
}
//데이터가 없다면 비어있는 덱
mainSlotUIArray[i].Init(i, deckData, ClickDeckSlot);
}
//사용중인 덱 선택
if (curSelectedMainSlot == null)
{
int index = DeckManager.Instance.CurDeckIndex;
curSelectedMainSlot = mainSlotUIArray.ElementAtOrDefault(index);
}
curSelectedMainSlot?.ClickSlot();
//각 UI 루트 활성화/비활성화
mainRoot.SetActive(true);
deckEditRoot.SetActive(false);
SlotEditRoot.SetActive(false);
deckEditNameInput.value = string.Empty;
}
/// <summary>
///
/// Create a new player deck
///
/// </summary>
public DeckData CreatePlayerDeck(DeckData deckTemplate, string deckName, int?campaignId = null)
{
//Generate the ID of the deck. Takes the last deck id in the list and adds one to it
var newId = 0;
if (PlayerDeckList.Count > 0)
{
newId = PlayerDeckList.LastOrDefault().Id.Value + 1;
}
//Adds the deck to the list
var newDeck = new DeckData(deckTemplate)
{
Id = newId,
Name = deckName,
};
PlayerDeckList.Add(newDeck);
if (campaignId.HasValue)
{
newDeck.CampaignTracker = new CampaignProgression(newDeck.Id.Value, campaignId.Value);
}
//Save decks to file
SaveDecks();
return(newDeck);
}
public void DeckCombo()
{
comboImage.color = Color.gray;
buffImage.color = Color.white;
deckToEnemy = deckBuff;
DeckSelected(deckCombo);
}
public void SetAllDeck()
{
UnitData[] _dataTemp = new UnitData[_deckKind.Length];
int _allDeckCount = 0;
for (int i = 0; i < _dataTemp.Length; i++)
{
_dataTemp[i] = DataManager.Instance.GetUnitDataWithUnitName(_deckKind[i]);
_allDeckCount += _dataTemp[i].MaxReinforce;
}
_allDeck = new DeckData[_allDeckCount];
int _choiceDeckIndex = 0;
//덱 종류만큼 실행
for (int i = 0; i < _dataTemp.Length; i++)
{
//한 종류의 최대 강화개수만큼 실행
for (int j = 0; j < _dataTemp[i].MaxReinforce; j++)
{
_allDeck[_choiceDeckIndex] = new DeckData()
{
_unit = _dataTemp[i]
};
_choiceDeckIndex++;
}
}
}
//When this method's called, Server has just sent the deck information
//needed to instantiate cards, so we instantiate cards
public void setDeck(DeckData deckData)
{
this.deckData = deckData;
//Takes the deck data and instatiates card GameObjects with AbstractCard scripts
createDeck();
}
/// <summary>
///
/// Function call for selecing a deck for the player to play
///
/// </summary>
public bool SelectDeck(DeckData deckData)
{
//Return the selected deck to the lobby UI
if (lobbyUI.SelectDeck(playerId, deckData))
{
//Sets the properties of the deck currently being edited
SelectedDeckId = deckData.Id;
//Locks the deck scrolling
listScrollArea.vertical = false;
//Hides all deck objects in the deck list except the one being edited
for (int deckIndex = 0; deckIndex < deckListObjects.Count; deckIndex++)
{
if (deckListObjects[deckIndex].GetComponent <DeckListObject>().deckData.Id != SelectedDeckId)
{
deckListObjects[deckIndex].SetActive(false);
}
}
return(true);
}
else
{
return(false);
}
}
public void DeckBuffs()
{
buffImage.color = Color.gray;
comboImage.color = Color.white;
deckToEnemy = deckCombo;
DeckSelected(deckBuff);
}
public void Init()
{
Entity.Create(new Transform2(new Size2(1920, 1080)))
.Add(new Sprite("Images/Table/casino-felt"));
var deckData = DeckData.LoadFromDir("Content/Decks/Poker");
var cards = new Items(deckData.GetAllCards().Select(x => Create(new Card(x))));
var deck = new Deck(cards);
Entity.Create(new Transform2(new Vector2(200, 200), Sizes.Card))
.Add(cards)
.Add(deck.Sprite)
.Add(new ZGravity())
.Add(x => new MouseDropTarget {
OnDrop = o => deck.PutFacedownOnTop(o)
})
.Add(x => new MouseStateActions
{
OnPressed = () => deck.If(deck.Count > 0, () =>
{
var drawnCard = deck.Draw();
drawnCard.Transform.Location = x.Transform.Location;
})
});
}
protected virtual void OnDeckDataChangedEvent(DataChangedEventArgs e)
{
DeckData = e.Data;
NavalFleet.Clear();
for (int i = 0; i < DeckData.Count(); i++)
{
for (int j = 0; j < DeckData[i]["api_ship"].Count(); j++)
{
string key = DeckData[i]["api_ship"][j].ToString();
if (ShipDataMap.ContainsKey(key))
{
NavalFleet[key] = (i + 1) + "-" + (j + 1);
JObject jo = ShipDataMap[key] as JObject;
if (jo["fleet_info"] == null)
{
jo.Add("fleet_info", (i + 1) + "-" + (j + 1));
}
}
}
}
DeckDataChangedEventHandler handler = DeckDataChanged;
if (handler != null)
{
handler(this, e);
}
}
public void Start()
{
tempDeckData = null;
isInitEditSlotList = false;
ActiveMainUI();
}
/// <summary>
///
/// Function call for the deck lists when a deck is selected from the list
///
/// </summary>
public bool SelectDeck(int playerId, DeckData deck)
{
if (!playerDecks.Contains(deck))
{
//Assigned the deck to the required player deck
playerDecks[playerId] = deck;
//If all required decks are selected (i.e. not null), then can begin playing the game (there is no way for a map to not be selected)
playButton.interactable = true;
foreach (var deckCheck in playerDecks)
{
if (deckCheck == null)
{
playButton.interactable = false;
break;
}
}
return(true);
}
else
{
playerDecks[playerId] = null;
return(false);
}
}
// Get deck for player1 -- player2 only if Single player
public void ProcessGetDeck(NetworkResponse response)
{
ResponseGetDeck args = response as ResponseGetDeck;
int numFields = args.numFields;
int numCards = args.numCards;
DeckData deck = args.deck;
//CardData card = deck.popCard();
GameManager.player1.setDeck(deck);
GameManager.player1.dealCard(3);
// Don't allow player1 to move cards until they hasDeck
GameManager.player1.hasDeck = true;
// Only deal cards for opponent if
if (Constants.SINGLE_PLAYER)
{
Debug.Log("Deal player2 Cards");
GameManager.player2.setDeck(deck);
GameManager.player2.dealCard(3);
}
Debug.Log("Protocols Deck Response: deck count: " + deck.getSize() +
" numCards: " + numCards + " num fields: " + numFields);
//Debug.Log ("Card data: cardID: " + card.cardID + " diet Type: " +
// card.dietType + " SpeciesName: " + card.speciesName);
}
public void SaveDeck()
{
if (String.IsNullOrEmpty(deckInProgress.deckName))
{
Debug.LogError("You must name your Grimoire");
return;
}
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(Application.persistentDataPath + "/" + deckInProgress.deckName + ".dat");
DeckData data = new DeckData();
List <int> listToSave = new List <int>();
for (int i = 0; i < deckInProgress.savedDecklist.Count; i++)
{
//Debug.Log(deckInProgress[i] + " is an id being copied to SAVE");
listToSave.Add(deckInProgress.savedDecklist[i]);
}
data.savedDecklist = listToSave;
data.deckName = deckNameText.text;
bf.Serialize(file, data);
file.Close();
if (!savedDecks.Contains(deckNameText.text))
{
savedDecks.Add(deckNameText.text);
SaveLibraryList();
}
}
public override string ToString()
{
DeckData data = new DeckData(name, character, cards);
var str = JsonUtility.ToJson(data, false);
return(str);
}
public IActionResult OnPostDeck([FromBody] DeckData deck)
{
var theDeck = deck.ToDeck();
theDeck.Owner = SignedInUser;
_deckStore.Save(theDeck);
return(new JsonResult(DeckData.FromDeck(theDeck)));
}
private void Start()
{
currentDeck = LocalStorage.GetData <DeckData> (storageKey);
if (currentDeck == null)
{
currentDeck = DeckData.BuildEmpty();
}
}
public DeckManager(DeckData deckData)
{
_deckData = deckData;
for (int i = 0; i < _deckData.cards.Count; i++)
{
_availableCardsIdList.Add(i);
}
}
/// <summary>
///
/// Creates an upgrade card on a canvas
///
/// </summary>
public GameObject CreateUpgrade(UpgradeData upgrade, Transform parent, DeckData currentDeck = null, float scaling = defaultUpgradeScaling)
{
var createdUpgrade = Instantiate(upgradeObject, parent);
createdUpgrade.transform.localScale = new Vector3(scaling, scaling, 1.0f);
createdUpgrade.GetComponent <UpgradeDisplay>().InitDisplay(upgrade, currentDeck);
return(createdUpgrade);
}
public static DeckController GetInstance()
{
if (instance == null)
{
deckData = DeckData.GetInstance();
}
return(instance);
}
public static DeckData GetInstance()
{
if (instance == null)
{
instance = new DeckData();
}
return(instance);
}
public PlayerData(int index, int order, Team team, DeckData deckData)
{
this.index = index;
this.order = order;
this.team = team;
this.deckData = deckData;
this.UseIndexList = new List <int>();
}
/// <summary>
///
/// Refreshes the deck details of the object
///
/// </summary>
public void RefreshDeckDetails(DeckData deckData)
{
deckCardList.RefreshCardList(deckData, deckListUI);
foreach (var deckResourceObject in deckResourceObjects)
{
deckResourceObject.RefreshResourceProperties();
}
}
public void PopulateDeck(DeckData deck)
{
/*
* foreach(var card in deck.CardList)
* {
* // Do something to select the cards.
* }
*/
}
public void SetUnitData(DeckData _deckDa, EnumInfo.TeamType _team)
{
_spawnTeam = _team;
_deckData = _deckDa;
_unitIdxText.text = _deckDa._unit.UnitName;
_maxReinforceText.text = string.Format("최대 강화 [{0}]", _deckDa._unit.MaxReinforce);
}
/// <summary>
///
/// Adds the hero card to the card list
///
/// </summary>
private void AddHeroCard(DeckData deckData)
{
if (deckData.HeroCard != null)
{
var heroCardObject = Instantiate(cardTemplate, cardListArea.transform);
heroCardObject.GetComponent <DeckCardObject>().InitCardObject(deckData.HeroCard, 1, this.deckData.Id, deckListUI);
heroCardObject.name = $"Card- {deckData.HeroCard.Name}";
}
}
/// <summary>
/// Gets the opponents DeckArchtype based on a calculated guess.
/// </summary>
/// <param name="opponentClass"></param>
/// <returns></returns>
private DeckData GetEnemyDeckDataForClass(CClass opponentClass)
{
if (_deckData == null)
{
var playerHistory = GetOpponentHistoryWithClass(opponentClass).FirstOrDefault();
if (playerHistory != null)
{
_deckData = new DeckData
{
Cards = playerHistory.Cards
};
switch (opponentClass)
{
case CClass.WARRIOR:
{
// Temporary for testing
if (_deckData.Cards.Any(c =>
c == "BRM_019" || // Patron
c == "EX1_392" || // Battle rage
c == "EX1_084")) // Warsong Commander
{
_deckData.SubType = SubType.PatronWarrior;
_deckData.ArchType = DeckArchtype.Combo;
}
else if (_deckData.Cards.Any(c =>
c == "GVG_082" || // Clockwork Gnome
c == "GVG_013" || // Cogmaster
c == "GVG_085" || // Annoy-o-Tron
c == "GVG_006")) // Mechwarper
{
_deckData.SubType = SubType.MechWarrior;
_deckData.ArchType = DeckArchtype.Aggro;
}
else if (_deckData.Cards.Any(c =>
c == "AT_071" || // Alexstrasza's Champion
c == "AT_017" || // Twilight Guardian
c == "BRM_033" || // Blackwing Technician
c == "BRM_034")) // Blackwing Corruptor
{
_deckData.SubType = SubType.DragonWarrior;
_deckData.ArchType = DeckArchtype.Midrange;
}
else
{
// Else it's most likely Control Warrior
_deckData.SubType = SubType.ControlWarrior;
_deckData.ArchType = DeckArchtype.Control;
}
break;
}
case CClass.ROGUE:
{
if (_deckData.Cards.Any(c =>
c == "GVG_022")) // Tinker's Sharpsword Oil
{
_deckData.SubType = SubType.OilRogue;
_deckData.ArchType = DeckArchtype.Combo; // Combo?
}
// Else we don't know, not that many rogues around these days
break;
}
case CClass.PALADIN:
{
if (_deckData.Cards.Any(c =>
c == "AT_079")) // Mysterious Challenger
{
_deckData.SubType = SubType.SecretPaladin;
_deckData.ArchType = DeckArchtype.Aggro;
}
// Need more here
break;
}
case CClass.DRUID:
{
if (_deckData.Cards.Any(c =>
c == "NEW1_026" || // Violet Teacher
c == "EX1_160")) // Power of the Wild
{
_deckData.SubType = SubType.TokenDruid;
_deckData.ArchType = DeckArchtype.Combo;
}
else if (_deckData.Cards.Any(c =>
c == "EX1_178")) // Ancient of War
{
_deckData.SubType = SubType.RampDruid;
_deckData.ArchType = DeckArchtype.Control;
}
else
{
// Else it's most likely Mid Range Druid
_deckData.SubType = SubType.MidRangeDruid;
_deckData.ArchType = DeckArchtype.Midrange;
}
break;
}
case CClass.PRIEST:
{
if (_deckData.Cards.Any(c =>
c == "AT_017" || // Twilight Guardian
c == "BRM_033" || // Blackwing Technician
c == "BRM_004" || // Twilight Whelp
c == "AT_116" || // Wyrmrest Agent
c == "BRM_034")) // Blackwing Corruptor
{
_deckData.SubType = SubType.DragonPriest;
_deckData.ArchType = DeckArchtype.Tempo;
}
else
{
// Else it is most likely Control priest
_deckData.SubType = SubType.ControlPriest;
_deckData.ArchType = DeckArchtype.Control;
}
break;
}
case CClass.MAGE:
{
if (_deckData.Cards.Any(c =>
c == "GVG_005" || // Echo of Medivh
c == "EX1_620")) // Molten Giant
{
_deckData.SubType = SubType.EchoMage;
_deckData.ArchType = DeckArchtype.Control;
}
else if (_deckData.Cards.Any(c =>
c == "GVG_003" || // Unstable Portal
c == "BRM_002")) // Flame Walker
{
_deckData.SubType = SubType.TempoMage;
_deckData.ArchType = DeckArchtype.Tempo;
}
else if (_deckData.Cards.Any(c =>
c == "EX1_295")) // Ice block
{
_deckData.SubType = SubType.FreezeMage;
_deckData.ArchType = DeckArchtype.Control;
}
else if (_deckData.Cards.Any(c =>
c == "GVG_082" || // Clockwork Gnome
c == "GVG_013" || // Cogmaster
c == "GVG_085" || // Annoy-o-Tron
c == "GVG_006")) // Mechwarper
{
_deckData.SubType = SubType.MechMage;
_deckData.ArchType = DeckArchtype.Aggro;
}
break;
}
case CClass.WARLOCK:
{
if (_deckData.Cards.Any(c =>
(c == "GVG_021" ||// Mal'Ganis OR
c == "FP1_022") && // Void Caller With one the following:
(c == "EX1_043" || // Twilight Drake
c == "EX1_620" || // Molten Giant
c == "EX1_105"))) // Mountain Giant
{
_deckData.SubType = SubType.DemonHandlock;
_deckData.ArchType = DeckArchtype.Control;
}
else if (_deckData.Cards.Any(c =>
c == "AT_017" || // Twilight Guardian
c == "BRM_033" || // Blackwing Technician
c == "BRM_034")) // Blackwing Corruptor
{
_deckData.SubType = SubType.DragonHandlock;
_deckData.ArchType = DeckArchtype.Control;
}
else if (_deckData.Cards.Any(c =>
c == "EX1_043" || // Twilight Drake
c == "EX1_620" || // Molten Giant
c == "EX1_105")) // Mountain Giant
{
_deckData.SubType = SubType.Handlock;
_deckData.ArchType = DeckArchtype.Control;
}
else if (_deckData.Cards.Any(c =>
c == "GVG_021" || // Mal'Ganis
c == "EX1_620" || // Molten Giant
c == "EX1_105")) // Mountain Giant
{
_deckData.SubType = SubType.DemonZooWarlock;
_deckData.ArchType = DeckArchtype.Aggro;
}
else
{
// Else it's very likely to be zoolock
_deckData.SubType = SubType.Zoolock;
_deckData.ArchType = DeckArchtype.Aggro;
}
break;
}
case CClass.HUNTER:
{
if (_deckData.Cards.Any(c =>
c == "GVG_043" || // Glaivezooka
c == "CS2_188" || // Abusive Sergeant
c == "EX1_089" || // Arcane Golem
c == "EX1_029")) // Leper Gnome
{
_deckData.SubType = SubType.FaceHunter;
_deckData.ArchType = DeckArchtype.Aggro;
}
if (_deckData.Cards.Any(c =>
c == "EX1_534" || // Savannah Highmane
c == "EX1_620" || // Molten Giant
c == "EX1_105")) // Mountain Giant
{
_deckData.SubType = SubType.MidRangeHunter;
_deckData.ArchType = DeckArchtype.Midrange;
}
break;
}
case CClass.SHAMAN:
{
if (_deckData.Cards.Any(c =>
c == "AT_046" || // Tuskarr Totemic
c == "AT_049")) // //Thunder Bluff Valiant
{
_deckData.SubType = SubType.TotemShaman;
_deckData.ArchType = DeckArchtype.Midrange;
}
else if (_deckData.Cards.Any(c =>
c == "GVG_082" || // Clockwork Gnome
c == "GVG_013" || // Cogmaster
c == "GVG_085" || // Annoy-o-Tron
c == "GVG_006")) // Mechwarper
{
_deckData.SubType = SubType.MechShaman;
_deckData.ArchType = DeckArchtype.Aggro;
}
if (_deckData.Cards.Any(c =>
c == "AT_017" || // Twilight Guardian
c == "BRM_033" || // Blackwing Technician
c == "BRM_034")) // Blackwing Corruptor
{
_deckData.SubType = SubType.DragonShaman;
_deckData.ArchType = DeckArchtype.Midrange;
}
else
{
// It's a random Control shaman
_deckData.SubType = SubType.ControlShaman;
_deckData.ArchType = DeckArchtype.Control;
}
break;
}
}
}
// If it's still null, it's unknown
if (_deckData == null)
{
_deckData = new DeckData
{
ArchType = DeckArchtype.Unknown,
SubType = SubType.Unknown,
Cards = new List<string>()
};
}
else
{
// Save stats to database
SharedDataMgr.AddRow("OpponentDeckHits", new string[]
{
Bot.GetCurrentOpponentId().ToString(CultureInfo.InvariantCulture),
opponentClass.ToString(),
DateTime.Now.ToString("g"),
string.Join(",", _deckData.Cards),
_deckData.ArchType.ToString(),
_deckData.SubType.ToString()
});
}
}
Bot.Log("[OpponentDeck] SubType: " + _deckData.SubType);
Bot.Log("[OpponentDeck] Archtype: " + _deckData.ArchType);
Bot.Log("[OpponentDeck] DeckList: " + string.Join(", ", _deckData.Cards));
return _deckData;
}
public override List<Card> HandleMulligan(List<Card> Choices, CClass opponentClass, CClass ownClass)
{
// Don't delete this
_deckData = null;
_playerHistories = null;
_messageReceived = new AutoResetEvent(false);
// For testing (replace this and everything below with your stuff)
var deckData = GetEnemyDeckDataForClass(opponentClass);
return Choices;
}
