internal async void ImportFromIdString()
{
try
{
var settings = new MessageDialogs.Settings();
var clipboard = Clipboard.ContainsText() ? Clipboard.GetText() : "";
if (clipboard.Count(c => c == ':') > 0 && clipboard.Count(c => c == ';') > 0)
{
settings.DefaultText = clipboard;
}
//import dialog
var idString =
await
this.ShowInputAsync("Import deck",
"id:count;id2:count2;... (e.g. EX1_050:2;EX1_556:1;)\nObtained from: \nEXPORT > COPY IDS TO CLIPBOARD",
settings);
if (string.IsNullOrEmpty(idString))
{
return;
}
var deck = new Deck();
foreach (var entry in idString.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
var splitEntry = entry.Split(':');
if (splitEntry.Length != 2)
{
continue;
}
var card = Database.GetCardFromId(splitEntry[0]);
if (card.Id == "UNKNOWN")
{
continue;
}
int count;
int.TryParse(splitEntry[1], out count);
card.Count = count;
if (string.IsNullOrEmpty(deck.Class) && card.GetPlayerClass != "Neutral")
{
deck.Class = card.GetPlayerClass;
}
deck.Cards.Add(card);
}
if (Config.Instance.AutoSaveOnImport)
{
DeckManager.SaveDeck(deck);
}
else
{
ShowDeckEditorFlyout(deck, true);
}
}
catch (Exception ex)
{
Log.Info("Error importing deck from clipboard(id string): " + ex);
}
}
// Use this for initialization
void Start()
{
instance = this;
LoadActionCards();
DontDestroyOnLoad(gameObject);
SceneManager.LoadScene("Title");
}
public override bool Cast(BoardTarget target, DeckManager manager)
{
if (manager.energy < cost)
{
manager.Alert("Not enough energy!");
return(false);
}
if (target == null || target.unit == null)
{
manager.Alert("Invalid target!");
return(false);
}
else
{
if (target.unit.team == manager)
{
manager.Alert("Target is friendly!");
return(false);
}
target.unit.moveDist = Mathf.Max(1.1f, target.unit.moveDist * 0.6f);
if (damage < 0)
{
target.unit.Heal(-damage);
}
else
{
target.unit.Damage(damage);
}
manager.Discard(this);
manager.energy -= cost;
return(true);
}
}
static Watchers()
{
ArenaWatcher.OnCompleteDeck += (sender, args) => DeckManager.AutoImportArena(Config.Instance.SelectedArenaImportingBehaviour ?? ArenaImportingBehaviour.AutoImportSave, args.Info);
PackWatcher.NewPackEventHandler += (sender, args) => PackUploader.UploadPack(args.PackId, args.Cards);
DungeonRunWatcher.DungeonRunMatchStarted += DeckManager.DungeonRunMatchStarted;
DungeonRunWatcher.DungeonInfoChanged += DeckManager.UpdateDungeonRunDeck;
}
public override bool Cast(BoardTarget target, DeckManager manager)
{
if (manager.energy < cost)
{
manager.Alert("Not enough energy!");
return(false);
}
foreach (var b in target.board.targets)
{
if (b.unit != null && (b.transform.localPosition - target.transform.localPosition).sqrMagnitude < radius * radius)
{
if (damage < 0)
{
b.unit.Heal(-damage);
}
else
{
b.unit.Damage(damage);
}
}
}
manager.Discard(this);
manager.energy -= cost;
return(true);
}
public void HasLocal_NewRemote_NewId_Distinct_ExactVersionMatch()
{
var localDeck = TestData.LocalDeck1;
localDeck.Version = new SerializableVersion(1, 1);
localDeck.Versions.Add(TestData.LocalDeck2);
_localDecks.Add(localDeck);
_remoteDecks.Add(TestData.RemoteDeck2);
Assert.AreEqual(1, _localDecks.Count);
Assert.AreEqual(1, _remoteDecks.Count);
var decks = DeckImporter.GetImportedDecks(_remoteDecks, _localDecks);
Assert.AreEqual(1, decks.Count);
DeckComparer.AssertAreEqual(TestData.RemoteDeck2, decks[0].Deck);
Assert.IsTrue(decks[0].Import);
var existingDeck = decks[0].SelectedImportOption as ExistingDeck;
Assert.IsNotNull(existingDeck);
Assert.AreEqual(0, existingDeck.NewVersion.Major);
Assert.AreEqual(0, existingDeck.NewVersion.Minor);
DeckManager.ImportDecksTo(_localDecks, decks, false, true, true);
Assert.AreEqual(1, _localDecks.Count);
var newLocalDeck = TestData.LocalDeck1;
newLocalDeck.HsId = 2;
DeckComparer.AssertAreEqual(newLocalDeck, _localDecks[0]);
Assert.AreEqual(1, _localDecks[0].Versions.Count);
DeckComparer.AssertAreEqual(TestData.LocalDeck2, _localDecks[0].Versions[0]);
}
private void Awake()
{
grid = GameObject.FindObjectOfType(typeof(Grid)) as Grid;
tileMap = GameObject.FindObjectOfType(typeof(Tilemap)) as Tilemap;
deckManager = GameObject.FindObjectOfType(typeof(DeckManager)) as DeckManager;
gameManager = GameObject.FindObjectOfType(typeof(GameManager)) as GameManager;
}
public void HasLocal_NewRemote_ExistingId_MajorChanges()
{
_localDecks.Add(TestData.LocalDeck1);
_remoteDecks.Add(TestData.RemoteDeck1_MajorChanges);
Assert.AreEqual(1, _localDecks.Count);
Assert.AreEqual(1, _remoteDecks.Count);
var decks = DeckImporter.GetImportedDecks(_remoteDecks, _localDecks);
Assert.AreEqual(1, decks.Count);
DeckComparer.AssertAreEqual(TestData.RemoteDeck1_MajorChanges, decks[0].Deck);
Assert.IsTrue(decks[0].Import);
Assert.AreEqual(2, decks[0].ImportOptions.Count());
var existingDeck = decks[0].SelectedImportOption as ExistingDeck;
Assert.IsNotNull(existingDeck);
Assert.AreEqual(2, existingDeck.NewVersion.Major);
Assert.AreEqual(0, existingDeck.NewVersion.Minor);
DeckManager.ImportDecksTo(_localDecks, decks, false, true, true);
Assert.AreEqual(1, _localDecks.Count);
DeckComparer.AssertAreEqual(TestData.LocalDeck1_MajorChanges, _localDecks[0]);
Assert.AreEqual(1, _localDecks[0].Versions.Count);
DeckComparer.AssertAreEqual(TestData.LocalDeck1, _localDecks[0].Versions[0]);
}
public void HasLocal_Archived_NewRemote_NewId_ExactMatch()
{
var remoteDeck = TestData.RemoteDeck1;
remoteDeck.Id = 2;
_remoteDecks.Add(remoteDeck);
var archivedDeck = TestData.LocalDeck1;
archivedDeck.Archived = true;
_localDecks.Add(archivedDeck);
Assert.AreEqual(1, _localDecks.Count);
Assert.AreEqual(1, _remoteDecks.Count);
var decks = DeckImporter.GetImportedDecks(_remoteDecks, _localDecks);
Assert.AreEqual(1, decks.Count);
DeckComparer.AssertAreEqual(remoteDeck, decks[0].Deck);
var existingDeck = decks[0].SelectedImportOption as ExistingDeck;
Assert.IsNotNull(existingDeck);
Assert.AreEqual(0, existingDeck.NewVersion.Major);
Assert.AreEqual(0, existingDeck.NewVersion.Minor);
Assert.IsTrue(decks[0].Import);
DeckManager.ImportDecksTo(_localDecks, decks, false, true, true);
Assert.AreEqual(1, _localDecks.Count);
Assert.IsFalse(_localDecks[0].Archived);
DeckComparer.AssertAreEqual(remoteDeck, _localDecks[0]);
}
public void HasLocal_Archived_NewRemote_ExistingId_Distinct()
{
var archivedDeck = TestData.LocalDeck1;
archivedDeck.Archived = true;
_localDecks.Add(archivedDeck);
_remoteDecks.Add(TestData.RemoteDeck1_DifferentCards);
Assert.AreEqual(1, _localDecks.Count);
Assert.AreEqual(1, _remoteDecks.Count);
var decks = DeckImporter.GetImportedDecks(_remoteDecks, _localDecks);
Assert.AreEqual(1, decks.Count);
DeckComparer.AssertAreEqual(TestData.RemoteDeck1_DifferentCards, decks[0].Deck);
Assert.IsTrue(decks[0].Import);
Assert.AreEqual(2, decks[0].ImportOptions.Count());
Assert.AreEqual(0, decks[0].SelectedIndex);
Assert.AreEqual(typeof(NewDeck), decks[0].SelectedImportOption.GetType());
DeckManager.ImportDecksTo(_localDecks, decks, false, true, true);
Assert.AreEqual(2, _localDecks.Count);
var localDeck = TestData.LocalDeck1;
localDeck.HsId = 0;
DeckComparer.AssertAreEqual(localDeck, _localDecks[0]);
Assert.IsTrue(_localDecks[0].Archived);
DeckComparer.AssertAreEqual(TestData.RemoteDeck1_DifferentCards, _localDecks[1]);
}
public void HasLocal_Archived_NewRemote_NewId_MinorChanges()
{
var remoteDeck = TestData.RemoteDeck1_MinorChanges;
remoteDeck.Id = 2;
var archivedDeck = TestData.LocalDeck1;
archivedDeck.Archived = true;
_localDecks.Add(archivedDeck);
_remoteDecks.Add(remoteDeck);
Assert.AreEqual(1, _localDecks.Count);
Assert.AreEqual(1, _remoteDecks.Count);
var decks = DeckImporter.GetImportedDecks(_remoteDecks, _localDecks);
Assert.AreEqual(1, decks.Count);
DeckComparer.AssertAreEqual(remoteDeck, decks[0].Deck);
Assert.IsTrue(decks[0].Import);
Assert.AreEqual(1, decks[0].ImportOptions.Count());
// The current behavior is to always create a new deck for a new id
// this will likely change with the new data model
Assert.AreEqual(typeof(NewDeck), decks[0].SelectedImportOption.GetType());
DeckManager.ImportDecksTo(_localDecks, decks, false, true, true);
Assert.AreEqual(2, _localDecks.Count);
DeckComparer.AssertAreEqual(TestData.LocalDeck1, _localDecks[0]);
Assert.IsTrue(_localDecks[0].Archived);
DeckComparer.AssertAreEqual(remoteDeck, _localDecks[1]);
}
void Update()
{
if (drawBool)
{
drawBool = false;
if (cardGOs.Length == 0)
{
chance = UnityEngine.Random.Range(0, DeckManager.currentCorrectPairs());
}
if (chance == 0)
{
Draw(DeckManager.drawSmartAnswer());
}
else
{
Draw(DeckManager.drawAnswer());
}
}
if (currentPresentNodeCount < handNodeCount)
{
Draw(DeckManager.drawAnswer());
}
}
Vector3[] GetDepotPositions(GameObject player)
{
DeckManager deckManager = player.GetComponent <DeckManager> ();
CannonManager cannonManager = player.GetComponent <CannonManager> ();
Vector3[] result = new Vector3[cannonManager.cannonNumber];
float[] xPosUsed = new float[cannonManager.cannonNumber];
float zPos = 0;
if (player == player1)
{
zPos = deckManager.deckHeight - (deckManager.deckHeight);
}
else if (player == player2)
{
zPos = player.GetComponent <Player> ().posOffsetZ + (deckManager.deckHeight - 1);
}
for (int i = 0; i < result.Length; i++)
{
float newX = GetRandomX(player, xPosUsed);
xPosUsed [i] = newX;
result [i] = new Vector3(newX, 0, zPos);
}
return(result);
}
void CreateDepots(GameObject player)
{
DepotManager depotManager = player.GetComponent <DepotManager> ();
DeckManager deckManager = player.GetComponent <DeckManager> ();
Vector3[] positions = GetDepotPositions(player);
for (int i = 0; i < (depotManager.ammoDepotNumber + depotManager.woodDepotNumber); i++)
{
if (depotManager.ammoDepotsCreated < depotManager.ammoDepotNumber)
{
GameObject depotToDeploy = depotManager.CreateAmmoDepot(player.transform);
int xPos = (int)positions [i].x;
int zPos = (int)positions [i].z;
depotToDeploy.GetComponent <Depot> ().PlaceDepot(deckManager.RetrieveTile(xPos, zPos));
depotManager.ammoDepotsCreated += 1;
}
else
{
GameObject depotToDeploy = depotManager.CreateWoodDepot(player.transform);
int xPos = (int)positions [i].x;
int zPos = (int)positions [i].z;
depotToDeploy.GetComponent <Depot> ().PlaceDepot(deckManager.RetrieveTile(xPos, zPos));
depotManager.woodDepotsCreated += 1;
}
}
}
private void Start()
{
var center = Vector3.zero;
hexCalc = new HexCalculator();
hexCoordinate = new HexCoordinate(RingSize - 1, (RingSize - 1) * 2);
var proguression = hexCalc.CalcProgression(0, 6, RingSize);
var hexNum = proguression[proguression.Length - 1] + 1;
hices = new Hex[hexNum];
perform = new HexPerform(this);
shake = GetComponent <HexShake>();
for (int i = 0; i < hexNum; i++)
{
var obj = Instantiate(HexObject, transform);
obj.name = "obj" + i;
obj.transform.localPosition = hexCalc.PositionFromIndex(i, center, 87, proguression);
// obj.transform.SetParent(transform);
hices[i] = obj.GetComponent <Hex>();
hices[i].Point = hexCalc.CalcCoordinate(i, proguression);
hices[i].SetHexMaster(this);
hices[i].ID = i;
hexCoordinate.SetHex(hices[i]);
}
for (int i = 0; i < hexNum; i++)
{
hices[i].SetContacted(hexCoordinate.GetContactedHex(hices[i].Point));
}
deck = GetComponent <DeckManager>();
}
private async void CreatButton_Click(object sender, RoutedEventArgs e)
{
ChangeVisibilityByNewDeck();
if (NewDeckName.Text != "")
{
creatingDeck.ChangeName(NewDeckName.Text);
}
else
{
int maxn = 0;
for (int i = 0; i < deckList.Count; i++)
{
if (deckList[i].Name.Contains("Deck "))
{
if (int.Parse(deckList[i].Name[5].ToString()) > maxn)
{
maxn = int.Parse(deckList[i].Name[5].ToString());
}
}
}
creatingDeck.ChangeName("Deck " + (maxn + 1).ToString());
}
//CardDataManager.SortCardListByCost(creatingDeck.MinionCard);
//CardDataManager.SortCardListByCost(creatingDeck.SpellCard);
await DeckManager.CreatDeck(creatingDeck);
NewDeckTip.Visibility = Visibility.Collapsed;
DeckLoad();
}
public override bool Cast(BoardTarget target, DeckManager manager)
{
if (manager.energy < cost)
{
manager.Alert("Not enough energy!");
return(false);
}
if (target == null || target.unit == null)
{
manager.Alert("Invalid target!");
return(false);
}
if (target.unit.team == manager)
{
manager.Alert("Target is friendly!");
return(false);
}
if ((target.transform.localPosition - target.transform.parent.InverseTransformPoint(manager.transform.position)).sqrMagnitude > 1.8f)
{
manager.Alert("Target is too far away!");
return(false);
}
if (damage < 0)
{
target.unit.Heal(-damage);
}
else
{
target.unit.Damage(damage);
}
manager.AddAtRandom(this);
manager.energy -= cost;
return(true);
}
// Use this for initialization
void Awake()
{
Instance = this;
deck = new Dictionary <string, int>();
if (PlayerPrefs.HasKey("deck"))
{
for (var i = 0; i < PlayerPrefs.GetInt("deck"); i++)
{
var id = PlayerPrefs.GetString("deck_card_id_" + i);
var nb = PlayerPrefs.GetInt("deck_card_nb_" + i);
deck.Add(id, nb);
nbCardsInDeck += nb;
}
}
if (!list)
{
return;
}
var newList = "Deck(" + nbCardsInDeck + "/20)\n";
newList += deck.Keys.Aggregate("", (current, k) => current + ("\n" + GetNameFromId(k) + " : " + deck[k]));
list.text = newList;
}
void initializeALLservants()
{
menu = new Menu();
servants.Add(menu);
setting = new Setting();
servants.Add(setting);
selectDeck = new selectDeck();
servants.Add(selectDeck);
room = new Room();
servants.Add(room);
cardDescription = new CardDescription();
deckManager = new DeckManager();
servants.Add(deckManager);
ocgcore = new Ocgcore();
servants.Add(ocgcore);
selectServer = new SelectServer();
servants.Add(selectServer);
book = new Book();
servants.Add(book);
selectReplay = new selectReplay();
servants.Add(selectReplay);
puzzleMode = new puzzleMode();
servants.Add(puzzleMode);
aiRoom = new AIRoom();
servants.Add(aiRoom);
}
/// <summary>
/// 牌組管理器實體物件
/// </summary>
//protected 保護:允許子類別使用成員
//virtual 虛擬:允許子類別用 override 覆寫
protected virtual void Awake()
{
instance = this;
btnStart.interactable = false; //取消開始遊戲按鈕 互動
btnStart.onClick.AddListener(StartBattle); //添加監聽(開始遊戲)
LVsave.exitdeck = false;
}
private void OnDestroy()
{
if (this == sInstance)
{
sInstance = null;
}
}
private async void DeckLoad()
{
deckList.Clear();
await DeckManager.LoadDecks(deckList);
DeckListView.Visibility = Visibility.Visible;
}
public override bool Cast(BoardTarget target, DeckManager manager)
{
if (manager.energy < cost)
{
manager.Alert("Not enough energy!");
return(false);
}
if (target == null)
{
manager.Alert("Must target the board!");
return(false);
}
if (target.unit != null)
{
manager.Alert("Space is already occupied!");
return(false);
}
else
{
if (this.target == Target.Spawn && !Utils.Vector3InBox(manager.transform.position, manager.spawnPositionLimit, target.transform.position))
{
manager.Alert("Can only be spawned on the homerow!");
return(false);
}
manager.energy -= cost;
Instantiate(unit, target.transform.position, Quaternion.identity).Setup(manager, target);
return(true);
}
}
public void Handle(LogLineItem logLine, IHsGameState gameState, IGame game)
{
var match = HsLogReaderConstants.GameModeRegex.Match(logLine.Line);
if (!match.Success)
{
return;
}
game.CurrentMode = GetMode(match.Groups["curr"].Value);
game.PreviousMode = GetMode(match.Groups["prev"].Value);
if ((DateTime.Now - logLine.Time).TotalSeconds < 5 && _lastAutoImport < logLine.Time && game.CurrentMode == Mode.TOURNAMENT)
{
_lastAutoImport = logLine.Time;
var decks = DeckImporter.FromConstructed();
if (decks.Any() && (Config.Instance.ConstructedAutoImportNew || Config.Instance.ConstructedAutoUpdate))
{
DeckManager.ImportDecks(decks, false, Config.Instance.ConstructedAutoImportNew, Config.Instance.ConstructedAutoUpdate);
}
}
if (game.PreviousMode == Mode.GAMEPLAY)
{
gameState.GameHandler.HandleInMenu();
}
if (game.CurrentMode == Mode.HUB && !_checkedMirrorStatus && (DateTime.Now - logLine.Time).TotalSeconds < 5)
{
CheckMirrorStatus();
}
}
// Start is called before the first frame update
protected override void Start()
{
base.Start();
// GetComponent<Button>().onClick.AddListener(UseCard);
playerAP = FindObjectOfType <PlayerAP>();
deckManager = FindObjectOfType <DeckManager>();
}
void init()
{
if (gm != null)
{
gm = null;
gm = this.gameObject.GetComponent <GameManager>();
}
else
{
gm = this.gameObject.GetComponent <GameManager>();
}
dm = GetComponent <DeckManager>();
string[] boynamelines = boynamedata.ToString().Split('\n');
foreach (string s in boynamelines)
{
string ss = Regex.Replace(s, "[^\\w\\._]", "");
boyfirstNames.Add(ss);
}
string[] girlnamelines = girlnamedata.ToString().Split('\n');
foreach (string s in girlnamelines)
{
string ss = Regex.Replace(s, "[^\\w\\._]", "");
girlfirstNames.Add(ss);
}
}
public void CanPopHand()
{
var deckManager = new DeckManager();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.True(deckManager.CanPopHand);
deckManager.PopHand();
Assert.False(deckManager.CanPopHand);
}
void Start()
{
players = new List <Player>();
dm = gameObject.GetComponent <DeckManager>();
selected = new List <GameObject>();
}
public void Handle(LogLine logLine, IHsGameState gameState, IGame game)
{
var match = LogConstants.GameModeRegex.Match(logLine.Line);
if (match.Success)
{
game.CurrentMode = GetMode(match.Groups["curr"].Value);
game.PreviousMode = GetMode(match.Groups["prev"].Value);
if ((DateTime.Now - logLine.Time).TotalSeconds < 5 && _lastAutoImport < logLine.Time &&
game.CurrentMode == Mode.TOURNAMENT)
{
_lastAutoImport = logLine.Time;
var decks = DeckImporter.FromConstructed();
if (decks.Any() && (Config.Instance.ConstructedAutoImportNew || Config.Instance.ConstructedAutoUpdate))
{
DeckManager.ImportDecks(decks, false, Config.Instance.ConstructedAutoImportNew,
Config.Instance.ConstructedAutoUpdate);
}
}
if (game.PreviousMode == Mode.GAMEPLAY && game.CurrentMode != Mode.GAMEPLAY)
{
gameState.GameHandler.HandleInMenu();
}
if (game.CurrentMode == Mode.HUB && !_checkedMirrorStatus && (DateTime.Now - logLine.Time).TotalSeconds < 5)
{
CheckMirrorStatus();
}
if (game.CurrentMode == Mode.DRAFT)
{
Watchers.ArenaWatcher.Run();
}
else
{
Watchers.ArenaWatcher.Stop();
}
if (game.CurrentMode == Mode.PACKOPENING)
{
Watchers.PackWatcher.Run();
}
else
{
Watchers.PackWatcher.Stop();
}
if (game.CurrentMode == Mode.TAVERN_BRAWL)
{
Core.Game.CacheBrawlInfo();
}
}
else if (logLine.Line.Contains("Gameplay.Start"))
{
gameState.Reset();
gameState.GameHandler.HandleGameStart(logLine.Time);
}
}
// 手札山札墓地追放UIの更新
public void UpdateDeckUI(DeckManager deckManager, bool isMyPlayer)
{
var numHand = deckManager.GetNumHand();
var numYamahuda = deckManager.GetNumYamahuda();
var numBochi = deckManager.GetNumCemetery();
var numTsuihou = deckManager.GetNumTsuihou();
if (isMyPlayer)
{
// UIテキストの変更
myHandCountNumber.SetNumber(numHand);
myYamahudaCountNumber.SetNumber(numYamahuda);
myBochiCountNumber.SetNumber(numBochi);
myTsuihouCountNumber.SetNumber(numTsuihou);
//myHandCountText.text = "x" + numHand.ToString();
//myYamahudaCountText.text = "x" + numYamahuda.ToString();
//myBochiCountText.text = "x" + numBochi.ToString();
//myTsuihouCountText.text = "x" + numTsuihou.ToString();
}
else
{
// UIテキストの変更
//cpuHandCountText.text = "x" + numHand.ToString();
//cpuYamahudaCountText.text = "x" + numYamahuda.ToString();
//cpuBochiCountText.text = "x" + numBochi.ToString();
//cpuTsuihouCountText.text = "x" + numTsuihou.ToString();
cpuHandCountNumber.SetNumber(numHand);
cpuYamahudaCountNumber.SetNumber(numYamahuda);
cpuBochiCountNumber.SetNumber(numBochi);
cpuTsuihouCountNumber.SetNumber(numTsuihou);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CrisisManagementControl"/> class.
/// </summary>
/// <param name="crisisCard">The crisis card.</param>
/// <param name="order">The order this crisis was drawn.</param>
/// <remarks>Adding this Control to a form via the designer is gonna end in sorrow.</remarks>
public CrisisManagementControl(DeckManager.Cards.CrisisCard crisisCard, int order)
{
Card = crisisCard;
InitializeComponent();
orderTextBox.Text = order.ToString(CultureInfo.InvariantCulture);
CrisisDisplayTextBox.Text = Card.Heading + Environment.NewLine + Card.AdditionalText;
}
/* Creates a player with the given ID value */
public PlayerScript(DeckManager DM)
{
deck = DM;
currency = 0;
}
private void PlaceComponent(ListBox sector, DeckManager.Components.BaseComponent token)
{
sector.BeginUpdate();
sector.Items.Add(token);
sector.EndUpdate();
}
// Use this for initialization
void Start()
{
// Initialize hand display
GameObject[] card_frames = GameObject.FindGameObjectsWithTag("Hand");
hand_display = new HandScript[DeckManager.MAX_HAND_SIZE];
for (int idx = 0; idx < card_frames.Length; ++idx) {
hand_display[idx] = card_frames[idx].GetComponent<HandScript>();
}
musicSlider = GameObject.Find ("Slider");
UI.GetComponentInChildren<Canvas> ().enabled = false;
shopCanvas.enabled = false;
units = new List<UnitScript>();
// give starting deck specifications
DeckManager d1 = new DeckManager( new CardScript.CardType[] {CardScript.CardType.Currency1, CardScript.CardType.Currency2, CardScript.CardType.HumanInfantry, CardScript.CardType.HumanTank}, new int[] {7, 2, 2, 1} );
DeckManager d2 = new DeckManager( new CardScript.CardType[] {CardScript.CardType.Currency1, CardScript.CardType.Currency2, CardScript.CardType.AlienInfantry, CardScript.CardType.AlienTank}, new int[] {7, 2, 2, 1} );
// player setup
Player1 = new PlayerScript(d1);
Player2 = new PlayerScript(d2);
Player1.getDeck().deck.shuffle();
Player2.getDeck().deck.shuffle();
turn = 1;
getPlayer().getDeck().deal();
drawCards();
Map = new MapManager(SceneTransitionStorage.map_width, SceneTransitionStorage.map_height, SceneTransitionStorage.map_type, SceneTransitionStorage.fog);
// map setup
Map.generatePseudoRandomMap();
// place alien base
turn = 2;
HexScript hex = Map.hex_at_offset_from(Map.map[0][0], false, false, System.Math.Min(Map.width / 2, Map.height / 2));
p2Base = placeUnit ( UnitScript.Types.A_Base, (int)hex.position.x, (int)hex.position.y );
//int unit = 4;
// place one of each unit
/*for (int adj_idx = 0; adj_idx < 6; ++adj_idx) {
HexScript adj_hex = Map.adjacentHexTo(hex, adj_idx);
if (adj_hex != null && adj_hex.getOccupied() == 0) {
placeUnit((UnitScript.Types)unit, (int)adj_hex.position.x, (int)adj_hex.position.y );
++unit;
}
if (unit > 7) { break; }
}*/
turn = 1;
if (Map.FOG_OF_WAR) { Map.fog_of_war(true); }
// place human base
hex = Map.hex_at_offset_from(Map.map[Map.width - 1][Map.height - 1], false, false, System.Math.Min(Map.width / 2, Map.height / 2));
p1Base = placeUnit ( UnitScript.Types.H_Base, (int)hex.position.x, (int)hex.position.y );
// place one of each unit
/*unit = 0;
for (int adj_idx = 0; adj_idx < 6; ++adj_idx) {
HexScript adj_hex = Map.adjacentHexTo(hex, adj_idx);
if (adj_hex != null && adj_hex.getOccupied() == 0) {
placeUnit((UnitScript.Types)unit, (int)adj_hex.position.x, (int)adj_hex.position.y );
++unit;
}
if (unit > 3) { break; }
}*/
}
void Start()
{
debugLog = GameObject.FindGameObjectWithTag ( "DebugLog" ).GetComponent<DebugLog>();
preferencesManager = GameObject.FindGameObjectWithTag ( "Manager" ).GetComponent<PreferencesManager>();
externalInformation = GameObject.FindGameObjectWithTag ( "ExternalInformation" ).GetComponent<ExternalInformation> ();
deckManager = GameObject.FindGameObjectWithTag ( "Manager" ).GetComponent<DeckManager>();
userInterface = GameObject.FindGameObjectWithTag ( "UserInterface" ).GetComponent<UserInterface>();
}
