public void InitializeSpawnInvasion(BaseTravellerData newTravellerData)
{
myTravellerData = new BaseTravellerData();
myTravellerData = newTravellerData;
myTravellerData.currentScenePoint = newTravellerData.currentScenePoint;
myTravellerData.currentSceneTargetPoint = newTravellerData.currentSceneTargetPoint;
myTravellerData.originalSpawnPoint = newTravellerData.originalSpawnPoint;
carriedTroopsList = myTravellerData.troopsCarried;
armySpeed = myTravellerData.travellerSpeed;
leaderUnit = myTravellerData.leaderUnit;
if (!string.IsNullOrEmpty(myTravellerData.currentScenePoint))
{
spawnPoint = ScenePointPathfinder.GetInstance.ObtainNearestScenePoint(newTravellerData.currentScenePoint);
armyMovement.SetPosition(spawnPoint, true);
}
if (!string.IsNullOrEmpty(myTravellerData.currentSceneTargetPoint))
{
targetPoint = ScenePointPathfinder.GetInstance.ObtainNearestScenePoint(newTravellerData.currentSceneTargetPoint);
TravelMovement(targetPoint);
}
myTravellerData.originalSpawnPoint = spawnPoint.gameObject.name;
myTravellerData.currentScenePoint = spawnPoint.gameObject.name;
if (PlayerGameManager.GetInstance != null)
{
myTravellerData.weekSpawned = PlayerGameManager.GetInstance.playerData.weekCount;
PlayerGameManager.GetInstance.SaveTraveller(myTravellerData);
}
}
// Campaign Mode
public void SetupPlayerCommander(BaseTravellerData troopsInformations, bool isAttacker = true)
{
BattlefieldCommander currentCommander = new BattlefieldCommander();
currentCommander.unitsCarried = new List <TroopsInformation>();
currentCommander.teamAffiliation = Maps.TerritoryOwners.Player;
currentCommander.heroesCarried = new List <BaseHeroInformationData>();
currentCommander.heroesCarried.AddRange(troopsInformations.leaderUnit);
for (int i = 0; i < troopsInformations.troopsCarried.Count; i++)
{
currentCommander.unitsCarried.Add(troopsInformations.troopsCarried[i]);
}
currentCommander = ImplementTechnology(currentCommander);
currentCommander.spawnBuffsList = new List <BaseBuffInformationData>();
currentCommander.spawnBuffsList.AddRange(CheckCampaignPlayerBuffPenalties());
if (isAttacker)
{
attackingCommander = new BattlefieldCommander();
attackingCommander = currentCommander;
}
else
{
defendingCommander = new BattlefieldCommander();
defendingCommander = currentCommander;
}
}
public void ReceiveTraveller(BaseTravellerData thisTraveller)
{
BaseTravellerData temp = new BaseTravellerData();
temp = thisTraveller;
myPointInformation.travellersOnPoint.Add(temp);
}
public void FaceTravellerInBattle(BaseTravellerData thisTraveller, bool isAttacker = false)
{
attackedTravellerData = new BaseTravellerData();
attackedTravellerData = thisTraveller;
isEngagedWithTraveller = true;
isPlayerAttacker = isAttacker;
LoadScene(SceneType.Battlefield);
HideTabCover();
}
public void MoveThisTravellerToNeighbor(BaseTravellerData thisTraveller)
{
int moveToIdx = 0;
if (neighborPoints != null && neighborPoints.Count > 0)
{
moveToIdx = UnityEngine.Random.Range(0, neighborPoints.Count - 1);
}
neighborPoints[moveToIdx].ReceiveTraveller(thisTraveller);
thisTraveller.currentScenePoint = neighborPoints[moveToIdx].myPointInformation.pointName;
}
public static BattlefieldCommander ConvertTravellerToCommander(BaseTravellerData thisTraveller)
{
BattlefieldCommander tmp = new BattlefieldCommander();
tmp.heroesCarried = new List <BaseHeroInformationData>();
tmp.unitsCarried = new List <TroopsInformation>();
tmp.unitsCarried.AddRange(thisTraveller.troopsCarried);
tmp.unitMindset = thisTraveller.leaderMindset;
if (thisTraveller.leaderUnit != null)
{
tmp.heroesCarried.AddRange(thisTraveller.leaderUnit);
}
return(tmp);
}
public BattlefieldCommander ObtainCampaignMapPointEnemyCommander()
{
BattlefieldCommander enemyCommander = new BattlefieldCommander();
List <BaseTravellerData> enemyOnPointTravellerList = new List <BaseTravellerData>();
enemyOnPointTravellerList.AddRange(TransitionManager.GetInstance.attackedPointInformationData.travellersOnPoint.FindAll(x => x.relationship < 0));
enemyCommander.teamAffiliation = TransitionManager.GetInstance.attackedPointInformationData.ownedBy;
// CONVERT ALL HATEFUL UNITS IN THE POINT TO 1 TRAVELLER
BaseTravellerData enemyTravellers = new BaseTravellerData();
enemyTravellers.troopsCarried = new List <TroopsInformation>();
enemyTravellers.leaderUnit = new List <BaseHeroInformationData>();
if (enemyOnPointTravellerList.Count > 0)
{
for (int i = 0; i < enemyOnPointTravellerList.Count; i++)
{
enemyTravellers.leaderUnit.AddRange(enemyOnPointTravellerList[i].leaderUnit);
for (int x = 0; x < enemyOnPointTravellerList[i].troopsCarried.Count; x++)
{
if (enemyTravellers.troopsCarried.Count > 0)
{
int idx = -1;
idx = enemyTravellers.troopsCarried.FindIndex(y => y.unitInformation.unitName == enemyOnPointTravellerList[i].troopsCarried[i].unitInformation.unitName);
if (idx != -1)
{
enemyTravellers.troopsCarried[idx].totalUnitCount += enemyOnPointTravellerList[i].troopsCarried[i].totalUnitCount;
}
else
{
enemyTravellers.troopsCarried.Add(enemyOnPointTravellerList[i].troopsCarried[i]);
}
}
else
{
enemyTravellers.troopsCarried.Add(enemyOnPointTravellerList[i].troopsCarried[i]);
}
}
}
}
enemyCommander = BattlefieldCommander.ConvertTravellerToCommander(enemyTravellers);
return(enemyCommander);
}
public BaseTravellerData ConvertWholeGarrisonAsTraveller()
{
BaseTravellerData wholeKingdom = new BaseTravellerData();
wholeKingdom.troopsCarried = new List <TroopsInformation>();
if (playerData.troopsList != null && playerData.troopsList.Count > 0)
{
for (int i = 0; i < playerData.troopsList.Count; i++)
{
wholeKingdom.troopsCarried.Add(playerData.troopsList[i]);
}
}
wholeKingdom.leaderUnit = new List <BaseHeroInformationData>();
wholeKingdom.leaderUnit.Add(playerData.myHeroes.Find(x => x.unitInformation.unitName == "Player"));
return(wholeKingdom);
}
public void SpawnThisTravelerUnitToVisibleMap(BaseTravellerData thisTraveller, MapType startingLocation)
{
switch (startingLocation)
{
case MapType.ForestOfRetsnom:
thisTraveller.currentScenePoint = BalconySceneManager.GetInstance.travelSystem.forestSpawn.gameObject.name;
break;
case MapType.Gates:
thisTraveller.currentScenePoint = BalconySceneManager.GetInstance.travelSystem.pilgrimSpawn.gameObject.name;
break;
case MapType.MountAli:
thisTraveller.currentScenePoint = BalconySceneManager.GetInstance.travelSystem.mountainSpawn.gameObject.name;
break;
default:
break;
}
BalconySceneManager.GetInstance.travelSystem.SummonSpecificTraveller(thisTraveller, true);
}
public void SaveTraveller(BaseTravellerData thisTraveller)
{
int idx = -1;
if (campaignData.travellerList == null)
{
campaignData.travellerList = new List <BaseTravellerData>();
}
if (campaignData.travellerList != null && campaignData.travellerList.Count > 0)
{
idx = campaignData.travellerList.FindIndex(x => x.travellersName == thisTraveller.travellersName);
}
if (idx != -1)
{
campaignData.travellerList[idx] = thisTraveller;
}
else
{
campaignData.travellerList.Add(thisTraveller);
}
}
IEnumerator DelayTravellerGeneration(int idx)
{
yield return(0);
if (!playerCampaignData.mapPointList[idx].isKingdomPoint)
{
for (int x = 0; x < playerCampaignData.mapPointList[idx].spawnableTravellers.Count; x++)
{
bool spawnNewTraveller = false;
BaseTravellerData newTraveller = new BaseTravellerData();
if (playerCampaignData.mapPointList[idx].travellersOnPoint == null)
{
playerCampaignData.mapPointList[idx].travellersOnPoint = new List <BaseTravellerData>();
}
switch (playerCampaignData.mapPointList[idx].spawnableTravellers[x])
{
case TravellerType.Invader:
spawnNewTraveller = ShouldSpawnThisUnit(playerKingdomData.ObtainChances(PotentialTravellers.mercenaries) + invaderFlatChance);
if (spawnNewTraveller)
{
newTraveller = travellerGenerator.GenerateRandomWarbandTraveller(20, -100);
}
break;
case TravellerType.Merchant:
spawnNewTraveller = ShouldSpawnThisUnit(playerKingdomData.ObtainChances(PotentialTravellers.randomMerchant) + merchantFlatChance);
if (spawnNewTraveller)
{
newTraveller = travellerGenerator.GenerateRandomMerchantTraveller(20, 0);
}
break;
case TravellerType.Hero:
spawnNewTraveller = ShouldSpawnThisUnit(playerKingdomData.ObtainChances(PotentialTravellers.RandomHero) + heroFlatChance);
// FIX HERO UNITS FIRST
break;
case TravellerType.Warband:
spawnNewTraveller = ShouldSpawnThisUnit(playerKingdomData.ObtainChances(PotentialTravellers.mercenaries) + mercenaryFlatChance);
if (spawnNewTraveller)
{
newTraveller = travellerGenerator.GenerateRandomWarbandTraveller(20, 0);
}
break;
case TravellerType.Creatures:
spawnNewTraveller = ShouldSpawnThisUnit(creaturesFlatChance);
break;
default:
break;
}
if (spawnNewTraveller)
{
newTraveller.affiliatedTeam = playerCampaignData.mapPointList[idx].ownedBy;
newTraveller.originalSpawnPoint = playerCampaignData.mapPointList[idx].pointName;
playerCampaignData.mapPointList[idx].travellersOnPoint.Add(newTraveller);
Debug.Log("Spawned New Traveller in Area : " + playerCampaignData.mapPointList[idx].pointName + " Spawned this Kind : " + playerCampaignData.mapPointList[idx].spawnableTravellers[x]);
}
}
}
if (idx < playerCampaignData.mapPointList.Count - 1)
{
idx += 1;
StartCoroutine(DelayTravellerGeneration(idx));
}
else
{
SaveData.SaveLoadManager.GetInstance.SaveCurrentCampaignData();
}
}
public void InitializeCampaignBattles(bool isFromCreationScene = false)
{
if (!TransitionManager.GetInstance.isEngagedWithTraveller &&
!TransitionManager.GetInstance.isEngagedWithMapPoint)
{
return;
}
BattlefieldCommander enemyCommander = new BattlefieldCommander();
BaseTravellerData tmp = new BaseTravellerData();
tmp = PlayerGameManager.GetInstance.unitsToSend;
// If He's the defender
if (!TransitionManager.GetInstance.isPlayerAttacker)
{
// MAP NODE
if (TransitionManager.GetInstance.isEngagedWithMapPoint)
{
if (!string.IsNullOrEmpty(TransitionManager.GetInstance.attackedPointInformationData.pointName))
{
tmp.troopsCarried.AddRange(TransitionManager.GetInstance.attackedPointInformationData.troopsStationed);
tmp.leaderUnit.Add(TransitionManager.GetInstance.attackedPointInformationData.leaderUnit);
}
if (TransitionManager.GetInstance.attackedPointInformationData.travellersOnPoint != null &&
TransitionManager.GetInstance.attackedPointInformationData.travellersOnPoint.Count > 0)
{
enemyCommander = ObtainCampaignMapPointEnemyCommander();
}
}
// TRAVELLER
else
{
if (TransitionManager.GetInstance.attackedTravellerData.ObtainTotalUnitCount() > 0)
{
Debug.Log("Initializing Battle Thru Traveller");
enemyCommander = BattlefieldCommander.ConvertTravellerToCommander(TransitionManager.GetInstance.attackedTravellerData);
}
}
}
else // If He's the attacker
{
// MAP NODE
if (TransitionManager.GetInstance.isEngagedWithMapPoint)
{
if (!string.IsNullOrEmpty(TransitionManager.GetInstance.attackedPointInformationData.pointName))
{
Debug.Log("Initializing Battle Thru Map Point");
enemyCommander = BattlefieldCommander.ConvertTravellerToCommander(TransitionManager.GetInstance.attackedPointInformationData);
}
}
else
{
if (!string.IsNullOrEmpty(TransitionManager.GetInstance.attackedTravellerData.travellersName))
{
Debug.Log("Initializing Battle Thru Traveller");
enemyCommander = BattlefieldCommander.ConvertTravellerToCommander(TransitionManager.GetInstance.attackedTravellerData);
}
}
}
spawnManager.SetupPlayerCommander(tmp, TransitionManager.GetInstance.isPlayerAttacker);
if (TransitionManager.GetInstance.isPlayerAttacker)
{
SwitchAttackerControls(PlayerControlType.PlayerOne);
SwitchDefenderControls(PlayerControlType.Computer);
BattlefieldSystemsManager.GetInstance.playerTeam = TeamType.Attacker;
spawnManager.ImplementTechnology(spawnManager.attackingCommander);
spawnManager.SetupDefendingCommander(enemyCommander);
}
else
{
SwitchAttackerControls(PlayerControlType.Computer);
SwitchDefenderControls(PlayerControlType.PlayerOne);
BattlefieldSystemsManager.GetInstance.playerTeam = TeamType.Defender;
spawnManager.ImplementTechnology(spawnManager.defendingCommander);
spawnManager.SetupAttackingCommander(enemyCommander);
}
InitializeArea(isFromCreationScene);
}
public BaseTravellerData ObtainTraveller(BaseHeroInformationData thisTraveller)
{
BaseTravellerData tmp = campaignData.travellerList.Find(x => x.leaderUnit.Contains(thisTraveller));
return(tmp);
}
