void Start()
{
if (instance == null)
{
lock (padlock)
{
if (instance == null)
{
//instance = new Knight();
instance = this;
HeroPool.GetInstance().SetHero(this, CommonConfig.Knight);
LevelManager = new KnightLeveling(this, KnightConfig.Level);
}
}
}
HeroAnimator = GetComponent <Animator>();
LoadAttr();
particleEffect.Stop();
LoadSkill();
InvokeRepeating("UpdateTarget", 0f, 0.5f);
}
void Awake()
{
if (instance != null)
{
Debug.LogError("More than one HeroPool in scene!");
return;
}
instance = this;
}
private FireMage getInstance()
{
if (instance == null)
{
instance = this;
HeroPool.GetInstance().SetHero(this, CommonConfig.FireMage);
LevelManager = new MageLeveling(this, FireMageConfig.Level);
}
return(instance);
}
void Start()
{
LevelManager = new ArcherLeveling(this, ArcherConfig.Level);
LoadAttr();
LoadSkill();
HeroPool.GetInstance().SetHero(this, CommonConfig.Archer);
HeroAnimator = GetComponent <Animator>();
particleEffect.Stop();
arrowEffect.Stop();
InvokeRepeating("UpdateTarget", 0f, 0.5f);
}
private Priest getInstance()
{
if (instance == null)
{
instance = this;
HeroPool.GetInstance().SetHero(this, CommonConfig.Priest);
LevelManager = new PriestLeveling(this, PriestConfig.Level);
}
return(instance);
}
// Start is called before the first frame update
void Start()
{
if (Instance != null)
{
DestroyImmediate(gameObject);
}
else
{
Instance = this;
DontDestroyOnLoad(this);
}
}
private Archer getInstance()
{
if (instance == null)
{
instance = this;
HeroPool.GetInstance().SetHero(this, CommonConfig.Archer);
LevelManager = new ArcherLeveling(this, ArcherConfig.Level);
}
return(instance);
}
void Start()
{
HeroPool.GetInstance().SetHero(this, CommonConfig.Priest);
LevelManager = new PriestLeveling(this, PriestConfig.Level);
animator = GetComponent <Animator>();
LoadAttr();
LoadSkill();
particleEffect.Stop();
InvokeRepeating("UpdateHeroTarget", 0f, 0.5f);
}
void Start()
{
HeroPool.GetInstance().SetHero(this, CommonConfig.FireMage);
LevelManager = new MageLeveling(this, FireMageConfig.Level);
HeroAnimator = GetComponent <Animator>();
Logger.Log(HeroAnimator);
LoadAttr();
particleEffect.Stop();
fireEffect.Stop();
LoadSkill();
InvokeRepeating("UpdateTarget", 0f, 0.5f);
}
public void UpdateSettings(Scenario a_Scenario)
{
m_Scenario = a_Scenario;
for (int i = 0; i < 8; i++)
{
if (a_Scenario.PlayerInfo[i].HumanPlayable)
{
m_GameSettings.LocalPlayerIndex = i;
break;
}
}
for (int i = 0; i < 8; i++)
{
m_AlliesFlags[i].gameObject.SetActive(false);
m_EnemiesFlags[i].gameObject.SetActive(false);
}
HeroPool.Initialize(m_Scenario.HeroInfo, m_Scenario.AvailableHeroes);
int _CurrentPlayer = 0;
for (int i = 0; i < 8; i++)
{
if (a_Scenario.PlayerInfo[i].ComputerPlayable)
{
m_Players[_CurrentPlayer].gameObject.SetActive(true);
m_Players[_CurrentPlayer].Initialize(i, a_Scenario.PlayerInfo[i]);
m_Players[_CurrentPlayer].SetName("Computer");
_CurrentPlayer++;
}
}
m_Players[m_GameSettings.LocalPlayerIndex].SetName("Player");
for (int i = _CurrentPlayer; i < 8; i++)
{
m_Players[i].gameObject.SetActive(false);
}
UpdateHeroLists();
UpdateFlags();
}
public GameSettings.Player GetGameSettings()
{
GameSettings.Player _Player = new GameSettings.Player();
_Player.IsPlayer = m_IsPlayer;
_Player.IsLocalPlayer = m_IsLocalPlayer;
_Player.Index = PlayerIndex;
_Player.SetMapHero = m_IsHeroRandom;
if (m_CurrentTownIndex != -1)
{
_Player.Faction = m_AvailableTowns[m_CurrentTownIndex];
}
else
{
_Player.Faction = m_AvailableTowns[Random.Range(0, m_AvailableTowns.Count)];
}
if (m_GenerateHeroAtMainTown || m_IsHeroRandom)
{
if (m_CurrentHeroIndex != -1)
{
_Player.Hero = m_AvailableHeroes[m_CurrentHeroIndex];
}
else
{
_Player.Hero = HeroPool.GetRandomHero(PlayerIndex, _Player.Faction, true);
HeroPool.ClaimHero(_Player.Hero);
}
}
else
{
_Player.Hero = m_CustomHero;
}
if (m_CurrentStartingBonusIndex != -1)
{
_Player.StartingBonus = m_StartingBonuses.StartingBonuses[m_CurrentStartingBonusIndex];
}
else
{
_Player.StartingBonus = m_StartingBonuses.StartingBonuses[Random.Range(0, m_StartingBonuses.StartingBonuses.Count)];
}
return(_Player);
}
void RenewHeroList()
{
if (m_CurrentHeroIndex != -1 && m_AvailableHeroes != null)
{
HeroPool.FreeHero(m_AvailableHeroes[m_CurrentHeroIndex]);
m_ScenarioSettings.UpdateHeroLists(PlayerIndex);
}
m_CurrentHeroIndex = -1;
if (m_CurrentTownIndex == -1)
{
UpdateHeroSprite();
return;
}
m_AvailableHeroes = HeroPool.GetFactionHeroes(PlayerIndex, m_AvailableTowns[m_CurrentTownIndex], true);
UpdateHeroSprite();
}
public void HeroRightPressed()
{
if (m_CurrentHeroIndex != -1)
{
HeroPool.FreeHero(m_AvailableHeroes[m_CurrentHeroIndex]);
}
m_CurrentHeroIndex++;
if (m_CurrentHeroIndex > m_AvailableHeroes.Count - 1)
{
m_CurrentHeroIndex = -1;
}
else
{
HeroPool.ClaimHero(m_AvailableHeroes[m_CurrentHeroIndex]);
}
m_ScenarioSettings.UpdateHeroLists(PlayerIndex);
UpdateHeroSprite();
}
public void UpdateHeroList()
{
if (m_CurrentHeroIndex != -1 && m_AvailableHeroes != null)
{
Hero _CurrentHero = m_AvailableHeroes[m_CurrentHeroIndex];
HeroPool.FreeHero(_CurrentHero);
m_AvailableHeroes = HeroPool.GetFactionHeroes(PlayerIndex, m_AvailableTowns[m_CurrentTownIndex], true);
HeroPool.ClaimHero(_CurrentHero);
m_CurrentHeroIndex = m_AvailableHeroes.IndexOf(_CurrentHero);
}
else if (m_CurrentTownIndex != -1 && m_AvailableTowns.Count > 0)
{
m_AvailableHeroes = HeroPool.GetFactionHeroes(PlayerIndex, m_AvailableTowns[m_CurrentTownIndex], true);
}
UpdateHeroSprite();
}
private void UpdateCustomProperties()
{
var playerProps = new ExitGames.Client.Photon.Hashtable();
for (int i = 0; i < multiplayerPartyPanel.PartySlots.Count; i++)
{
var hero = multiplayerPartyPanel.PartySlots[i].SelectedHero;
playerProps.Add("HC" + (i + 1), multiplayerPartyPanel.PartySlots[i].SelectedHero.ClassStringId);
playerProps.Add("HN" + (i + 1), multiplayerPartyPanel.PartySlots[i].SelectedHero.Name);
playerProps.Add("HS" + (i + 1), HeroSeeds[HeroPool.IndexOf(hero)]);
var skillFlags = PlayerSkillFlags.Empty;
for (int j = 0; j < hero.CurrentCombatSkills.Length; j++)
{
if (hero.CurrentCombatSkills[j] != null && hero.SelectedCombatSkills.Contains(hero.CurrentCombatSkills[j]))
{
skillFlags |= (PlayerSkillFlags)Mathf.Pow(2, j + 1);
}
}
playerProps.Add("HF" + (i + 1), skillFlags);
}
PhotonNetwork.player.SetCustomProperties(playerProps, playerProps);
}
public void Initialize(ScenarioObject a_ScenarioObject, GameReferences a_GameReferences)
{
PlayerIndex = a_ScenarioObject.Hero.PlayerIndex;
m_GameReferences = a_GameReferences;
if (a_ScenarioObject.Template.Name == "avxprsn0")
{
IsPrison = true;
}
Hero _BaseHero;
bool _ClaimedMainHero = false;
if (a_ScenarioObject.Hero.ID != 255)
{
_BaseHero = m_Heroes.Heroes.First((a_Hero) => a_Hero.Hero.ID == a_ScenarioObject.Hero.ID).Hero;
}
else
{
GameSettings.Player _Player = m_GameSettings.Players.First((a_Player) => a_Player.Index == PlayerIndex);
if (m_GameSettings.Scenario.PlayerInfo[PlayerIndex].IsMainHeroRandom &&
_Player.SetMapHero)
{
_BaseHero = _Player.Hero;
_Player.SetMapHero = false;
_ClaimedMainHero = true;
}
else
{
_BaseHero = HeroPool.GetRandomHero(PlayerIndex, m_GameSettings.Players.First((a_Player) => a_Player.Index == PlayerIndex).Faction, true);
}
}
Hero = new Hero();
Hero.ID = _BaseHero.ID;
Hero.Faction = _BaseHero.Faction;
Hero.HeroVisualData = _BaseHero.HeroVisualData;
if (a_ScenarioObject.Hero.Name != "")
{
Hero.Name = a_ScenarioObject.Hero.Name;
}
else
{
Hero.Name = _BaseHero.Name;
}
if (a_ScenarioObject.Hero.Portrait != 255)
{
Hero _Hero = m_Heroes.Heroes.First((a_Hero) => a_Hero.Hero.ID == a_ScenarioObject.Hero.Portrait).Hero;
Hero.SmallPortrait = _Hero.SmallPortrait;
Hero.LargePortrait = _Hero.LargePortrait;
}
else
{
Hero.SmallPortrait = _BaseHero.SmallPortrait;
Hero.LargePortrait = _BaseHero.LargePortrait;
}
if (a_ScenarioObject.Hero.HasCustomPrimarySkills)
{
Hero.Attack = a_ScenarioObject.Hero.Attack;
Hero.Defense = a_ScenarioObject.Hero.Defense;
Hero.Spellpower = a_ScenarioObject.Hero.Spellpower;
Hero.Knowledge = a_ScenarioObject.Hero.Knowledge;
}
else
{
Hero.Attack = _BaseHero.Attack;
Hero.Defense = _BaseHero.Defense;
Hero.Spellpower = _BaseHero.Spellpower;
Hero.Knowledge = _BaseHero.Knowledge;
}
if (!_ClaimedMainHero)
{
HeroPool.ClaimHero(Hero);
}
m_DynamicObstacle.Initialize(m_GameReferences.Pathfinding, this);
m_PathfindingPos = new Vector2Int(a_ScenarioObject.PosX - 1, a_ScenarioObject.PosY);
Initialize();
}
void Start()
{
m_TerrainSprites = new List <List <Sprite> >();
m_TerrainSprites.Add(m_DirtSprites);
m_TerrainSprites.Add(m_SandSprites);
m_TerrainSprites.Add(m_GrassSprites);
m_TerrainSprites.Add(m_SnowSprites);
m_TerrainSprites.Add(m_SwampSprites);
m_TerrainSprites.Add(m_RoughSprites);
m_TerrainSprites.Add(m_SubterraneanSprites);
m_TerrainSprites.Add(m_LavaSprites);
m_TerrainSprites.Add(new List <Sprite>());
m_TerrainSprites.Add(m_RockSprites);
m_RiverSprites = new List <List <Sprite> >();
m_RiverSprites.Add(new List <Sprite>());
m_RiverSprites.Add(m_IcyRiverSprites);
m_RiverSprites.Add(m_MuddyRiverSprites);
m_RiverSprites.Add(new List <Sprite>());
m_RoadSprites = new List <List <Sprite> >();
m_RoadSprites.Add(m_DirtRoadSprites);
m_RoadSprites.Add(m_GravelRoadSprites);
m_RoadSprites.Add(m_CobbleRoadSprites);
if (m_GameSettings.Scenario.Version != Scenario.SHADOW_OF_DEATH)
{
Debug.Log($"This map isn't SoD, not supported yet");
return;
}
int _Size = m_GameSettings.Scenario.Size;
m_TerrainFrame.size = new Vector2(_Size + 2, _Size + 2);
m_TerrainFrame.transform.localPosition = new Vector3(_Size / 2 - 0.5f, -_Size / 2 + 0.5f, 0);
m_TerrainMask.localScale = new Vector3(_Size, _Size, 1);
m_TerrainMask.transform.localPosition = new Vector3(_Size / 2 - 0.5f, -_Size / 2 + 0.5f, 0);
// <><><><><> Above Ground Terrain
List <TerrainTile> _Terrain = m_GameSettings.Scenario.Terrain;
m_TerrainTileObjects = new List <TerrainTileObject>(_Terrain.Capacity);
m_RiverTileObjects = new List <TerrainTileObject>();
m_RoadTileObjects = new List <TerrainTileObject>();
for (int x = 0; x < _Size; x++)
{
for (int y = 0; y < _Size; y++)
{
int _Index = x + y * _Size;
// <><><><><> Terrain Tile
TerrainTileObject _TileObject = Instantiate(m_TileObjectPrefab, new Vector2(x, -y), Quaternion.identity);
_TileObject.Renderer.sortingOrder = -32768;
if (_Terrain[_Index].TerrainType < m_TerrainSprites.Count)
{
if (_Terrain[_Index].TerrainType == WATER_TILE_INDEX)
{
_TileObject.AnimationRenderer.SetSprites(m_WaterAnimations[_Terrain[_Index].TerrainSpriteID].Array);
}
else if (_Terrain[_Index].TerrainSpriteID < m_TerrainSprites[_Terrain[_Index].TerrainType].Count)
{
_TileObject.Renderer.sprite = m_TerrainSprites[_Terrain[_Index].TerrainType][_Terrain[_Index].TerrainSpriteID];
}
else
{
Debug.Log($"Failed ID {_Terrain[_Index].TerrainSpriteID}");
}
}
else
{
Debug.Log($"Failed Type {_Terrain[_Index].TerrainType}");
}
_TileObject.Renderer.sortingLayerName = "Terrain";
_TileObject.Renderer.flipX = (_Terrain[_Index].Mirrored & 1) == 1;
_TileObject.Renderer.flipY = (_Terrain[_Index].Mirrored & 2) == 2;
_TileObject.name = $"{_TileObject.Renderer.sprite.name} Pos {_Index} ID {_Terrain[_Index].TerrainSpriteID}";
_TileObject.transform.parent = m_TerrainTileObjectParent;
m_TerrainTileObjects.Add(_TileObject);
// <><><><><> River Tile
if (_Terrain[_Index].RiverType != 0)
{
_TileObject = Instantiate(m_TileObjectPrefab, new Vector2(x, -y), Quaternion.identity);
if (_Terrain[_Index].RiverType - 1 < m_RiverSprites.Count)
{
if (_Terrain[_Index].RiverType == CLEAR_RIVER_INDEX)
{
_TileObject.AnimationRenderer.SetSprites(m_ClearRiverAnimations[_Terrain[_Index].RiverSpriteID].Array);
}
else if (_Terrain[_Index].RiverType == LAVA_RIVER_INDEX)
{
_TileObject.AnimationRenderer.SetSprites(m_LavaRiverAnimations[_Terrain[_Index].RiverSpriteID].Array);
}
else if (_Terrain[_Index].RiverSpriteID < m_RiverSprites[_Terrain[_Index].RiverType - 1].Count)
{
_TileObject.Renderer.sprite = m_RiverSprites[_Terrain[_Index].RiverType - 1][_Terrain[_Index].RiverSpriteID];
}
else
{
Debug.Log($"River Failed ID {_Terrain[_Index].RiverSpriteID}");
}
}
else
{
Debug.Log($"River Failed Type {_Terrain[_Index].RiverSpriteID}");
}
_TileObject.Renderer.sortingOrder = 1;
_TileObject.Renderer.sortingLayerName = "Terrain";
_TileObject.Renderer.flipX = (_Terrain[_Index].Mirrored & 4) == 4;
_TileObject.Renderer.flipY = (_Terrain[_Index].Mirrored & 8) == 8;
_TileObject.name = $"{_TileObject.Renderer.sprite.name} Pos {_Index} ID {_Terrain[_Index].RiverSpriteID}";
_TileObject.transform.parent = m_RiverTileObjectParent;
m_RiverTileObjects.Add(_TileObject);
}
// <><><><><> Road Tile
if (_Terrain[_Index].RoadType != 0)
{
_TileObject = Instantiate(m_TileObjectPrefab, new Vector2(x, -y - 0.5f), Quaternion.identity);
if (_Terrain[_Index].RoadType - 1 < m_RoadSprites.Count)
{
if (_Terrain[_Index].RoadSpriteID < m_RoadSprites[_Terrain[_Index].RoadType - 1].Count)
{
_TileObject.Renderer.sprite = m_RoadSprites[_Terrain[_Index].RoadType - 1][_Terrain[_Index].RoadSpriteID];
}
else
{
Debug.Log($"Road Failed ID {_Terrain[_Index].RoadSpriteID}");
}
}
else
{
Debug.Log($"Road Failed Type {_Terrain[_Index].RoadSpriteID}");
}
_TileObject.Renderer.sortingOrder = 2;
_TileObject.Renderer.sortingLayerName = "Terrain";
_TileObject.Renderer.flipX = (_Terrain[_Index].Mirrored & 16) == 16;
_TileObject.Renderer.flipY = (_Terrain[_Index].Mirrored & 32) == 32;
_TileObject.name = $"{_TileObject.Renderer.sprite.name} Pos {_Index} ID {_Terrain[_Index].RoadSpriteID}";
_TileObject.transform.parent = m_RoadTileObjectParent;
m_RoadTileObjects.Add(_TileObject);
}
}
}
if (m_GameSettings.Scenario.HasUnderground)
{
// <><><><><> Underground Terrain
List <TerrainTile> _UndergroundTerrain = m_GameSettings.Scenario.UndergroundTerrain;
m_UndergroundTerrainTileObjects = new List <TerrainTileObject>(_Terrain.Capacity);
m_UndergroundRiverTileObjects = new List <TerrainTileObject>();
m_UndergroundRoadTileObjects = new List <TerrainTileObject>();
for (int x = 0; x < _Size; x++)
{
for (int y = 0; y < _Size; y++)
{
int _Index = x + y * _Size;
// <><><><><> Terrain Tile
TerrainTileObject _TileObject = Instantiate(m_TileObjectPrefab, new Vector2(x, -y), Quaternion.identity);
_TileObject.Renderer.sortingOrder = -32768;
if (_UndergroundTerrain[_Index].TerrainType < m_TerrainSprites.Count)
{
if (_UndergroundTerrain[_Index].TerrainType == WATER_TILE_INDEX)
{
if (m_WaterAnimations[_UndergroundTerrain[_Index].TerrainSpriteID] != null)
{
_TileObject.AnimationRenderer.SetSprites(m_WaterAnimations[_UndergroundTerrain[_Index].TerrainSpriteID].Array);
}
}
else if (_UndergroundTerrain[_Index].TerrainSpriteID < m_TerrainSprites[_UndergroundTerrain[_Index].TerrainType].Count)
{
_TileObject.Renderer.sprite = m_TerrainSprites[_UndergroundTerrain[_Index].TerrainType][_UndergroundTerrain[_Index].TerrainSpriteID];
}
else
{
Debug.Log($"Failed ID {_UndergroundTerrain[_Index].TerrainSpriteID}");
}
}
else
{
Debug.Log($"Failed Type {_UndergroundTerrain[_Index].TerrainType}");
}
_TileObject.Renderer.sortingLayerName = "Terrain";
_TileObject.Renderer.flipX = (_UndergroundTerrain[_Index].Mirrored & 1) == 1;
_TileObject.Renderer.flipY = (_UndergroundTerrain[_Index].Mirrored & 2) == 2;
_TileObject.name = $"{_TileObject.Renderer.sprite.name} Pos {_Index} ID {_UndergroundTerrain[_Index].TerrainSpriteID}";
_TileObject.transform.parent = m_UndergroundTerrainTileObjectParent;
m_UndergroundTerrainTileObjects.Add(_TileObject);
// <><><><><> River Tile
if (_UndergroundTerrain[_Index].RiverType != 0)
{
_TileObject = Instantiate(m_TileObjectPrefab, new Vector2(x, -y), Quaternion.identity);
if (_UndergroundTerrain[_Index].RiverType == CLEAR_RIVER_INDEX)
{
_TileObject.AnimationRenderer.SetSprites(m_ClearRiverAnimations[_UndergroundTerrain[_Index].RiverSpriteID].Array);
}
else if (_UndergroundTerrain[_Index].RiverType == LAVA_RIVER_INDEX)
{
_TileObject.AnimationRenderer.SetSprites(m_LavaRiverAnimations[_UndergroundTerrain[_Index].RiverSpriteID].Array);
}
else if (_UndergroundTerrain[_Index].RiverSpriteID < m_RiverSprites[_UndergroundTerrain[_Index].RiverType - 1].Count)
{
_TileObject.Renderer.sprite = m_RiverSprites[_UndergroundTerrain[_Index].RiverType - 1][_UndergroundTerrain[_Index].RiverSpriteID];
}
else
{
Debug.Log($"River Failed ID {_UndergroundTerrain[_Index].RiverSpriteID}");
}
_TileObject.Renderer.sortingOrder = 1;
_TileObject.Renderer.sortingLayerName = "Terrain";
_TileObject.Renderer.flipX = (_UndergroundTerrain[_Index].Mirrored & 4) == 4;
_TileObject.Renderer.flipY = (_UndergroundTerrain[_Index].Mirrored & 8) == 8;
_TileObject.name = $"{_TileObject.Renderer.sprite.name} Pos {_Index} ID {_UndergroundTerrain[_Index].RiverSpriteID}";
_TileObject.transform.parent = m_UndergroundRiverTileObjectParent;
m_UndergroundRiverTileObjects.Add(_TileObject);
}
// <><><><><> Road Tile
if (_UndergroundTerrain[_Index].RoadType != 0)
{
_TileObject = Instantiate(m_TileObjectPrefab, new Vector2(x, -y - 0.5f), Quaternion.identity);
if (_UndergroundTerrain[_Index].RoadType - 1 < m_RoadSprites.Count)
{
if (_UndergroundTerrain[_Index].RoadSpriteID < m_RoadSprites[_UndergroundTerrain[_Index].RoadType - 1].Count)
{
_TileObject.Renderer.sprite = m_RoadSprites[_UndergroundTerrain[_Index].RoadType - 1][_UndergroundTerrain[_Index].RoadSpriteID];
}
else
{
Debug.Log($"Road Failed ID {_UndergroundTerrain[_Index].RoadSpriteID}");
}
}
else
{
Debug.Log($"Road Failed Type {_UndergroundTerrain[_Index].RoadSpriteID}");
}
_TileObject.Renderer.sortingOrder = 2;
_TileObject.Renderer.sortingLayerName = "Terrain";
_TileObject.Renderer.flipX = (_UndergroundTerrain[_Index].Mirrored & 16) == 16;
_TileObject.Renderer.flipY = (_UndergroundTerrain[_Index].Mirrored & 32) == 32;
_TileObject.name = $"{_TileObject.Renderer.sprite.name} Pos {_Index} ID {_UndergroundTerrain[_Index].RoadSpriteID}";
_TileObject.transform.parent = m_UndergroundRoadTileObjectParent;
m_UndergroundRoadTileObjects.Add(_TileObject);
}
}
}
}
// <><><><><> Objects
m_OverworldObjects = new List <GameObject>();
m_UndergroundObjects = new List <GameObject>();
List <ScenarioObject> _Objects = m_GameSettings.Scenario.Objects;
List <MapObjectBase> _MapObjects = new List <MapObjectBase>(_Objects.Count);
Dictionary <ScenarioObject, DynamicMapObstacle> _DynamicObstacles = new Dictionary <ScenarioObject, DynamicMapObstacle>();
// Load map objects
for (int i = 0; i < _Objects.Count; i++)
{
ScenarioObject _Object = _Objects[i];
MapObjectBase _MapObject;
switch (_Object.Template.Type)
{
case ScenarioObjectType.Hero:
MapHero _Hero = Instantiate(m_MapHeroPrefab, m_MapObjectParent);
_Hero.Initialize(_Object, m_GameReferences);
_MapObject = _Hero;
_DynamicObstacles.Add(_Object, _Hero.DynamicObstacle);
break;
case ScenarioObjectType.Resource:
MapResource _Resource = Instantiate(m_MapResourcePrefab, m_MapObjectParent);
_Resource.Initialize(_Object, m_GameReferences);
_MapObject = _Resource;
_DynamicObstacles.Add(_Object, _Resource.DynamicObstacle);
break;
case ScenarioObjectType.Dwelling:
case ScenarioObjectType.Mine: // Temporary
case ScenarioObjectType.AbandonedMine: // Temporary
MapDwelling _Dwelling = Instantiate(m_MapDwellingPrefab, m_MapObjectParent);
_Dwelling.Initialize(_Object, m_GameReferences);
_MapObject = _Dwelling;
break;
case ScenarioObjectType.Town:
MapTown _Town = Instantiate(m_MapTownPrefab, m_MapObjectParent);
// Determine if this town can build a shipyard, and where the ship will spawn
Vector2Int _ShipyardSpot = Vector2Int.zero;
Vector2Int _ShipyardSpot1 = new Vector2Int(_Object.PosX - 3, _Object.PosY + 2);
Vector2Int _ShipyardSpot2 = new Vector2Int(_Object.PosX - 1, _Object.PosY + 2);
int _ShipyardIndex1 = _ShipyardSpot1.x + _ShipyardSpot1.y * _Size;
int _ShipyardIndex2 = _ShipyardSpot2.x + _ShipyardSpot2.y * _Size;
if (_ShipyardIndex1 < _Size * _Size)
{
if (_Terrain[_ShipyardIndex1].TerrainType == WATER_TILE_INDEX)
{
_ShipyardSpot = _ShipyardSpot1;
}
else if (_ShipyardIndex2 < _Size * _Size &&
_Terrain[_ShipyardIndex2].TerrainType == WATER_TILE_INDEX)
{
_ShipyardSpot = _ShipyardSpot2;
}
}
// If _ShipyardSpot is still Vector2Int.zero, there's no shipyard
_Town.Initialize(_Object, m_GameReferences, _ShipyardSpot);
_MapObject = _Town;
break;
case ScenarioObjectType.Monster:
MapMonster _Monster = Instantiate(m_MapMonsterPrefab, m_MapObjectParent);
_Monster.Initialize(_Object, m_GameReferences);
_MapObject = _Monster;
_DynamicObstacles.Add(_Object, _Monster.DynamicObstacle);
break;
case ScenarioObjectType.Garrison:
MapGarrison _Garrison = Instantiate(m_MapGarrisonPrefab, m_MapObjectParent);
_Garrison.Initialize(_Object, m_GameReferences);
_MapObject = _Garrison;
break;
default:
MapObject _Obj = Instantiate(m_MapObjectPrefab, m_MapObjectParent);
_Obj.Initialize(_Object, m_GameReferences);
_MapObject = _Obj;
break;
}
_MapObject.transform.position = new Vector3(_Object.PosX + 0.5f, -_Object.PosY - 0.5f, 0);
_MapObject.MouseCollision = new byte[6];
_MapObject.MouseCollision[0] = (byte)(~_Object.Template.Passability[0] | _Object.Template.Interactability[0]);
_MapObject.MouseCollision[1] = (byte)(~_Object.Template.Passability[1] | _Object.Template.Interactability[1]);
_MapObject.MouseCollision[2] = (byte)(~_Object.Template.Passability[2] | _Object.Template.Interactability[2]);
_MapObject.MouseCollision[3] = (byte)(~_Object.Template.Passability[3] | _Object.Template.Interactability[3]);
_MapObject.MouseCollision[4] = (byte)(~_Object.Template.Passability[4] | _Object.Template.Interactability[4]);
_MapObject.MouseCollision[5] = (byte)(~_Object.Template.Passability[5] | _Object.Template.Interactability[5]);
_MapObject.InteractionCollision = _Object.Template.Interactability;
if (_Object.IsUnderground)
{
m_UndergroundObjects.Add(_MapObject.gameObject);
_MapObject.transform.parent = m_UndergroundMapObjectParent;
}
else
{
m_OverworldObjects.Add(_MapObject.gameObject);
}
_MapObjects.Add(_MapObject);
}
m_Pathfinding.Generate(m_GameSettings.Scenario, _MapObjects, _DynamicObstacles);
// Spawn starting heroes
for (int i = 0; i < m_GameSettings.Players.Count; i++)
{
PlayerInfo _PlayerInfo = m_GameSettings.Scenario.PlayerInfo[i];
if (_PlayerInfo.GenerateHeroAtMainTown)
{
MapHero _MapHero = Instantiate(m_MapHeroPrefab, m_MapObjectParent);
// Spawn map object at main town coordinates
if (_PlayerInfo.IsMainTownUnderground)
{
_MapHero.transform.parent = m_UndergroundMapObjectParent;
}
Hero _Hero;
if (_PlayerInfo.IsMainHeroRandom)
{
_Hero = HeroPool.GetRandomHero(m_GameSettings.Players[i].Index, m_GameSettings.Players[i].Faction, true);
HeroPool.ClaimHero(_Hero);
}
else
{
_Hero = m_GameSettings.Players[i].Hero;
}
_MapHero.Initialize
(
_Hero,
m_GameSettings.Players[i].Index,
m_GameSettings.Scenario.PlayerInfo[i].MainTownXCoord + 1,
m_GameSettings.Scenario.PlayerInfo[i].MainTownYCoord,
m_GameSettings.Scenario.PlayerInfo[i].IsMainTownUnderground,
m_GameReferences
);
}
}
List <MapHero> _LocalOwnership = m_LocalOwnership.GetHeroes();
if (_LocalOwnership.Count > 0)
{
m_LocalOwnership.SelectHero(_LocalOwnership[0]);
}
}
public void Initialize(int a_Index, PlayerInfo a_PlayerInfo)
{
PlayerIndex = a_Index;
m_BackgroundImage.sprite = m_BackgroundSprites[a_Index];
m_FlagButton.image.sprite = m_FlagSprites[a_Index];
SpriteState _State = m_FlagButton.spriteState;
_State.highlightedSprite = m_FlagHoverSprites[a_Index];
_State.pressedSprite = m_FlagPressedSprites[a_Index];
m_FlagButton.spriteState = _State;
m_FlagButton.gameObject.SetActive(a_PlayerInfo.HumanPlayable);
if (a_PlayerInfo.HumanPlayable)
{
m_HumanOrCPUText.text = "Human or CPU";
m_HumanOrCPUText.rectTransform.anchoredPosition = new Vector2
(
m_HumanOrCPUText.rectTransform.anchoredPosition.x,
-23
);
}
else
{
m_HumanOrCPUText.text = "CPU";
m_HumanOrCPUText.rectTransform.anchoredPosition = new Vector2
(
m_HumanOrCPUText.rectTransform.anchoredPosition.x,
-22
);
}
m_GenerateHeroAtMainTown = a_PlayerInfo.GenerateHeroAtMainTown;
m_IsHeroRandom = a_PlayerInfo.IsMainHeroRandom;
if (a_PlayerInfo.IsTownChoosable)
{
m_IsTownChoosable = true;
m_CurrentTownIndex = -1;
m_AvailableTowns = m_Factions.Factions;
}
else
{
if (a_PlayerInfo.MainTownType != 255 && a_PlayerInfo.HasMainTown)
{
m_IsTownChoosable = false;
m_CurrentTownIndex = a_PlayerInfo.MainTownType;
m_AvailableTowns = m_Factions.Factions;
}
else
{
m_IsTownChoosable = true;
m_AvailableTowns = new List <Faction>();
int _BitwiseIndex = 1;
for (int i = 0; i < m_Factions.Factions.Count; i++)
{
if ((a_PlayerInfo.AllowedTowns & _BitwiseIndex) == _BitwiseIndex)
{
m_AvailableTowns.Add(m_Factions.Factions[i]);
}
_BitwiseIndex *= 2;
}
if (m_AvailableTowns.Count > 1)
{
m_CurrentTownIndex = -1;
}
else
{
m_CurrentTownIndex = 0;
}
}
}
m_CustomHero = null;
if (!m_IsHeroRandom && !m_GenerateHeroAtMainTown)
{
if (a_PlayerInfo.MainHeroPortrait == 255 || a_PlayerInfo.MainHeroType == 255)
{
m_HeroText.text = "None";
m_HeroImage.sprite = m_NoHeroSprite;
}
else
{
Hero _BaseHero = m_Heroes.Heroes.First((a_Hero) => a_Hero.Hero.ID == a_PlayerInfo.MainHeroType).Hero;
Hero _PortraitHero = m_Heroes.Heroes.First((a_Hero) => a_Hero.Hero.ID == a_PlayerInfo.MainHeroPortrait).Hero;
m_HeroText.text = a_PlayerInfo.MainHeroName;
m_HeroImage.sprite = _PortraitHero.SmallPortrait;
m_CustomHero = new Hero();
if (a_PlayerInfo.MainHeroName != "")
{
m_CustomHero.Name = a_PlayerInfo.MainHeroName;
}
else
{
m_CustomHero.Name = _BaseHero.Name;
}
m_CustomHero.ID = a_PlayerInfo.MainHeroType;
m_CustomHero.Faction = _BaseHero.Faction;
m_CustomHero.SmallPortrait = _PortraitHero.SmallPortrait;
m_CustomHero.LargePortrait = _PortraitHero.LargePortrait;
HeroPool.ClaimHero(_BaseHero);
// TODO: Custom Hero ID probably needs to pipe through primary/secondary abilities
}
}
m_TownLeft.gameObject.SetActive(m_IsTownChoosable && m_AvailableTowns.Count > 1);
m_TownRight.gameObject.SetActive(m_IsTownChoosable && m_AvailableTowns.Count > 1);
m_HeroLeft.gameObject.SetActive(m_IsHeroRandom || m_GenerateHeroAtMainTown);
m_HeroRight.gameObject.SetActive(m_IsHeroRandom || m_GenerateHeroAtMainTown);
m_CurrentStartingBonusIndex = -1;
m_CurrentHeroIndex = -1;
if (m_CurrentTownIndex != -1)
{
m_AvailableHeroes = HeroPool.GetFactionHeroes(PlayerIndex, m_AvailableTowns[m_CurrentTownIndex], true);
}
UpdateTownSprite();
UpdateHeroSprite();
UpdateStartingBonusSprite();
}
static void Initialize()
{
s_Instance = Instantiate(Resources.Load <HeroPool>("HeroPool"), Vector3.zero, Quaternion.identity);
s_Instance.name = "HeroPool";
DontDestroyOnLoad(s_Instance);
}
void Start()
{
heroPool = HeroPool.GetInstance();
}
