public void StartCombatStateMachine(EncounterConfig combatConfig, Player p)
{
useAI = true;
currentConfig = combatConfig;
playerDiscardPile = new CombatDeck();
playerExilePile = new CombatDeck();
playerHand = new CombatHand();
Main.instance.ShufflePlayerCurrentCombatDeck(p);
playerSideDeck = new CombatDeck(p.GetCurrentCombatDeck());
//TODO: Load Combat Configs and init enemies
enemies.Clear();
foreach (var enemy in combatConfig.enemies)
{
//UnityEngine.Debug.Log(ConfigHandler.enemyConfigs[enemy].type);
Enemy e = new Enemy();
e.Init(ConfigHandler.enemyConfigs[enemy]);
enemies.Add(e);
}
MainUIController.instance.ActivateEnemyCanvas(enemies);
DrawInitialHands(p.GetStartingCardCount(), 3); //TODO: Config Enemy Starting Hands
turn = 0;
isPlayerTurn = true;
isActive = true;
}
public void StopTimelineStateMachine(Player p)
{
if (isActive == true)
{
isActive = false;
enemies.Clear();
isPlayerTurn = false;
ProcessEndOfCombat(currentConfig, p);
currentConfig = null;
}
}
public void InitEncounter(Enums.EncounterID id)
{
//Debug.Log(id.ToString());
currentConfig = ConfigHandler.encounterConfigs[id];
currentSequenceIndex = 0;
Main.instance.SetScriptedUIState(currentConfig.hideHandUI, currentConfig.hideStatsUI);
if (currentConfig.type == Enums.EncounterType.TimelineSequence)
{
PlayEncounter(currentConfig.sequence[0].timelineName);
}
}
public void StartEncounter(Enums.EncounterID encounter)
{
//Debug.Log(encounter.ToString());
EncounterConfig config = ConfigHandler.encounterConfigs[encounter];
switch (config.type)
{
case Enums.EncounterType.TimelineSequence:
StartTimelineCombat(config);
timelineScriptController.InitEncounter(config.id);
break;
case Enums.EncounterType.Combat:
StartCombat(config);
break;
}
}
public void StartTimelineStateMachine(EncounterConfig timelineConfig, Player p)
{
useAI = false;
currentConfig = timelineConfig;
playerDiscardPile = new CombatDeck();
playerExilePile = new CombatDeck();
playerHand = new CombatHand();
playerSideDeck = new CombatDeck(p.GetCurrentCombatDeck());
enemies.Clear();
foreach (var enemy in timelineConfig.enemies)
{
//UnityEngine.Debug.Log(ConfigHandler.enemyConfigs[enemy].type);
Enemy e = new Enemy();
e.Init(ConfigHandler.enemyConfigs[enemy]);
enemies.Add(e);
}
isPlayerTurn = false;
isActive = true;
}
void ProcessEndOfCombat(EncounterConfig config, Player p)
{
ClearHands();
UnityEngine.Debug.Log("Processing End of Combat");
}
static void LoadXMLConfigFile(string f)
{
XmlDocument doc = new XmlDocument();
doc.Load(f);
XmlNode header = doc.FirstChild;
//UnityEngine.Debug.Log(header.Name);
if (header.Name == "enemies")
{
enemyConfigs = new Dictionary <Enums.EnemyType, EnemyConfig>();
foreach (XmlNode enemy in header.ChildNodes)
{
EnemyConfig config = new EnemyConfig();
config.type = Enums.ParseEnum <Enums.EnemyType>(enemy.Attributes["type"].Value);
//UnityEngine.Debug.Log(config.type);
config.name = enemy.Attributes["name"].Value;
config.health = int.Parse(enemy.ChildNodes[0].Attributes["amount"].Value);
config.mana = int.Parse(enemy.ChildNodes[1].Attributes["amount"].Value);
config.action = int.Parse(enemy.ChildNodes[2].Attributes["amount"].Value);
config.deck = new List <Enums.Card>();
foreach (XmlNode card in enemy.SelectSingleNode("deck"))
{
config.deck.Add(Enums.ParseEnum <Enums.Card>(card.Attributes["type"].Value));
}
enemyConfigs.Add(config.type, config);
}
}
else if (header.Name == "encounters")
{
encounterConfigs = new Dictionary <Enums.EncounterID, EncounterConfig>();
foreach (XmlNode encounter in header.ChildNodes)
{
if (encounter.NodeType == XmlNodeType.Comment)
{
continue;
}
EncounterConfig config = new EncounterConfig();
config.id = Enums.ParseEnum <Enums.EncounterID>(encounter.Attributes["id"].Value);
//UnityEngine.Debug.Log(config.id);
if (encounter.Attributes["type"] != null)
{
config.type = Enums.ParseEnum <Enums.EncounterType>(encounter.Attributes["type"].Value);
}
if (encounter.Attributes["hideStatsUI"] != null)
{
config.hideStatsUI = bool.Parse(encounter.Attributes["hideStatsUI"].Value);
}
if (encounter.Attributes["hideHandUI"] != null)
{
config.hideHandUI = bool.Parse(encounter.Attributes["hideHandUI"].Value);
}
foreach (XmlNode childNode in encounter.ChildNodes)
{
if (childNode.Name == "enemies")
{
config.enemies = new List <Enums.EnemyType>();
foreach (XmlNode child in childNode)
{
config.enemies.Add(Enums.ParseEnum <Enums.EnemyType>(child.Attributes["type"].Value));
}
}
else if (childNode.Name == "sequence")
{
config.sequence = new List <ScriptConfig>();
foreach (XmlNode child in childNode)
{
ScriptConfig scriptConfig = new ScriptConfig();
scriptConfig.type = Enums.ParseEnum <Enums.ScriptActionType>(child.Attributes["type"].Value);
scriptConfig.dialogue = child.Value;
if (scriptConfig.type == Enums.ScriptActionType.PlayTimeline)
{
scriptConfig.timelineName = child.Attributes["timelineName"].Value;
}
config.sequence.Add(scriptConfig);
}
}
}
encounterConfigs.Add(config.id, config);
}
}
else if (header.Name == "cards")
{
cardConfigs = new Dictionary <Enums.Card, CardConfig>();
foreach (XmlNode cardNode in header.ChildNodes)
{
CardConfig config = new CardConfig();
config.card = Enums.ParseEnum <Enums.Card>(cardNode.Attributes["type"].Value);
config.displayName = cardNode.Attributes["displayName"].Value;
config.imagePath = cardNode.Attributes["imagePath"].Value;
if (cardNode.Attributes["cardType"] != null)
{
config.cardType = Enums.ParseEnum <Enums.CardType>(cardNode.Attributes["cardType"].Value);
}
else
{
config.cardType = Enums.CardType.None;
}
if (cardNode.Attributes["targetType"] != null)
{
config.targetType = Enums.ParseEnum <Enums.CardTargetType>(cardNode.Attributes["targetType"].Value);
}
else
{
config.targetType = Enums.CardTargetType.Self;
}
if (cardNode.Attributes["rarity"] != null)
{
config.rarity = Enums.ParseEnum <Enums.Rarity>(cardNode.Attributes["rarity"].Value);
}
config.costs = new List <KeyValuePair <Enums.CostType, int> >();
if (cardNode.SelectSingleNode("costs") != null)
{
foreach (XmlNode costNode in cardNode.SelectSingleNode("costs"))
{
config.costs.Add(new KeyValuePair <Enums.CostType, int>(Enums.ParseEnum <Enums.CostType>(costNode.Attributes["type"].Value), int.Parse(costNode.Attributes["amount"].Value)));
}
}
config.effects = new List <CardEffectConfig>();
if (cardNode.SelectSingleNode("effects") != null)
{
foreach (XmlNode effectNode in cardNode.SelectSingleNode("effects"))
{
CardEffectConfig effectConfig = new CardEffectConfig();
effectConfig.effect = Enums.ParseEnum <Enums.CardEffect>(effectNode.Attributes["type"].Value);
if (effectNode.Attributes["amount"] != null)
{
effectConfig.amount = int.Parse(effectNode.Attributes["amount"].Value);
}
if (effectNode.Attributes["stat"] != null)
{
effectConfig.stat = Enums.ParseEnum <Enums.StatType>(effectNode.Attributes["stat"].Value);
}
if (effectNode.Attributes["equipment"] != null)
{
effectConfig.equipment = Enums.ParseEnum <Enums.Equipment>(effectNode.Attributes["equipment"].Value);
}
if (effectNode.Attributes["trinket"] != null)
{
effectConfig.trinket = Enums.ParseEnum <Enums.Trinket>(effectNode.Attributes["trinket"].Value);
}
if (effectNode.Attributes["class"] != null)
{
effectConfig.selectedClass = Enums.ParseEnum <Enums.Class>(effectNode.Attributes["class"].Value);
}
if (effectNode.Attributes["card"] != null)
{
effectConfig.card = Enums.ParseEnum <Enums.Card>(effectNode.Attributes["card"].Value);
}
if (effectNode.Attributes["effectType"] != null)
{
effectConfig.appliedEffect = Enums.ParseEnum <Enums.AppliedEffect>(effectNode.Attributes["effectType"].Value);
}
config.effects.Add(effectConfig);
}
}
config.description = GetDescription(cardNode.Attributes["description"].Value, config);
//UnityEngine.Debug.Log(config.description);
cardConfigs.Add(config.card, config);
}
}
}
void StartCombat(EncounterConfig config)
{
mainUIController.LoadCombatUI(player);
combatStateMachine.StartCombatStateMachine(config, player);
}
void StartTimelineCombat(EncounterConfig config)
{
combatStateMachine.StartTimelineStateMachine(config, player);
}
