public void ShowBuildingInfo(GameBuilding building)
{
gameObject.SetActive(true);
transform.position = building.gameObject.transform.position;
transform.position += new Vector3(0, 5, 0);
m_Text.text = building.Description;
}
public void DestroyGhost(GameBuilding ghost)
{
if (ghost)
{
Destroy(ghost.gameObject);
}
}
public SleepTask(GameObject bed) : base(Task.Action.Sleep)
{
this.mBed = bed.GetComponent <Bed>();
this.mBuilding = bed.GetComponent <GameBuilding>();
this.target = bed;
this.position = target.transform.position;
}
void Start()
{
ResourceGather resource = GetComponent <ResourceGather>();
if (resource)
{
mTasks.Add(new ResourceGatherTask(gameObject));
}
GameItem item = GetComponent <GameItem>();
if (item)
{
mTasks.Add(new PickUpItemTask(gameObject));
}
Bed bed = GetComponent <Bed>();
if (bed)
{
mTasks.Add(new SleepTask(gameObject));
}
GameBuilding building = GetComponent <GameBuilding>();
if (building)
{
mTasks.Add(new DeconstructTask(gameObject));
}
mGameArea = GetComponent <GameArea>();
mTasks.Add(new MoveTask(transform.position));
mMoveActionIndex = mTasks.Count - 1;
}
public GameBuilding CreateGameObject(Vector3 position, float rotation)
{
GameBuilding gBuilding = Instantiate(prefab, FixPosition(position), Quaternion.Euler(0f, 0f, rotation)).GetComponent <GameBuilding>();
gBuilding.Configure(this);
return(gBuilding);
}
public GameBuilding CreateGhost(Vector3 position, float rotation)
{
GameBuilding ghost = Instantiate(ghostPrefab, FixPosition(position), Quaternion.Euler(0f, 0f, rotation)).GetComponent <GameBuilding>();
ghost.Configure(this);
return(ghost);
}
private void OnGameBuildingCancelled()
{
if (instancedScene != null)
{
instancedScene.QueueFree();
instancedScene = null;
}
}
void EngageCells(GameBuilding building)
{
for (int i = 0; i <= (int)(building.Type); i++)
{
for (int j = 0; j <= (int)(building.Type); j++)
{
m_Cells[building.BaseCellX + i, building.BaseCellZ + j] = true;
}
}
}
void FreeCells(GameBuilding building)
{
for (int i = 0; i <= (int)(building.Type); i++)
{
for (int j = 0; j <= (int)(building.Type); j++)
{
m_Cells[building.BaseCellX + i, building.BaseCellZ + j] = false;
}
}
}
GameBuilding SpawnBuilding(int x, int z, BuildingType mode)
{
GameBuilding cube = Instantiate(m_BuildingPrefabs[(int)mode]) as GameBuilding;
cube.transform.parent = this.gameObject.transform;
cube.Place(x, z);
GameController.Instance().ChangeGameMode(GameController.GameMode.egm_Observe);
return(cube);
}
GameBuilding TryToBuild(int x, int z, BuildingType mode)
{
GameBuilding newBuilding = null;
if (CellsCanBeEngaged(x, z, mode))
{
newBuilding = SpawnBuilding(x, z, mode);
EngageCells(newBuilding);
}
return(newBuilding);
}
private void OnGameBuildingSelected(GameBuildingType type)
{
// hide the mouse because the building becomes our mouse
Input.SetMouseMode(Input.MouseMode.Hidden);
var scene = ResourceLoader.Load <PackedScene>(type.GetScenePath());
instancedScene = (GameBuilding)scene.Instance();
instancedScene.NewlySpawned = true;
instancedScene.PlayerNum = PlayersManager.Instance.Me.Num;
instancedScene.Type = type;
AddChild(instancedScene);
}
private void OnGameBuildingPlaced(string buildingId, int playerNum, GameBuildingType type, Vector2 position)
{
var scene = ResourceLoader.Load <PackedScene>(type.GetScenePath());
GameBuilding building = (GameBuilding)scene.Instance();
building.PlayerNum = playerNum;
building.Position = position;
building.BuildingId = buildingId;
building.Active = true;
AddChild(building);
PlayersManager.Instance.GetPlayer(playerNum).AddScore(ScoreType.BuildingBuilt);
}
private void OnBuildingDestroyed(GameBuilding destroyedBuilding)
{
GameLogicMgr gameLogicMgr = GameLogicMgr.GetInstance();
if (destroyedBuilding.GetTeam() != 0)
{
// Display you won message.
gameLogicMgr.GameWon();
}
else
{
// Display the you lost message.
gameLogicMgr.GameOver();
}
}
public void InitInOrder()
{
foreach (var prePlayBuilding in PrePlayBuildings)
{
GameBuilding gameBuilding = prePlayBuilding.GetComponent <GameBuilding>();
gameBuilding.ActorAttributes.Team = Team;
gameBuilding.OnConstructionComplete();
}
foreach (var prePlayUnit in PrePlayUnits)
{
GameUnit gameUnit = prePlayUnit.GetComponent <GameUnit>();
gameUnit.ActorAttributes.Team = Team;
}
}
void InitialSpawn()
{
int cellsNumberToSpawn = (int)(FIELD_SIZE * FIELD_SIZE * DEVELOPMENT_COEFF);
int overallSquare = 0;
int steps = 0;
while (overallSquare < cellsNumberToSpawn)
{
steps++;
GameBuilding randomBuilding = SpawnRandom(cellsNumberToSpawn - overallSquare, steps);
if (randomBuilding != null)
{
overallSquare += GameBuilding.Square((int)(randomBuilding.Type));
}
}
}
int GetRandomType(int cellsLeftToSpawn, int steps)
{
int randomType = 0;
int maxType = (int)(BuildingType.ebm_max);
Random.seed = (int)(Time.time) + steps + 2;
if (cellsLeftToSpawn > GameBuilding.Square(maxType))
{
randomType = Random.Range(0, maxType);
}
else if (cellsLeftToSpawn > GameBuilding.Square(--maxType))
{
randomType = Random.Range(0, maxType);
}
return(randomType);
}
private void CmdSpawnBuilding(Vector3 position, Team team)
{
var newFactory = Instantiate(BuildingToBuild);
PlayersManager.GetInstance().Get(team).Gold -=
BuildingToBuild.GetComponent <GameBuilding>().BuildingAttributes.BuildCost;
newFactory.transform.position = position;
GameBuilding gameBuilding = newFactory.GetComponent <GameBuilding>();
gameBuilding.ActorAttributes.Team = team;
gameBuilding.UniqeNetworkId = gameBuilding.GetHashCode().ToString();
NetworkServer.SpawnWithClientAuthority(
newFactory,
PlayersManager.GetInstance().Get(team).connectionToClient
);
}
public void Init(int difficulty, Vector3[] defenderLocations, AddObject spawner)
{
// The player base is the first base.
_enemyBase = spawner.SpawnBases[0].GetComponent <GameBuilding>();
_defenderLocations = defenderLocations;
_spawner = spawner;
switch (difficulty)
{
case 0:
_coinAc = new CoinAccumulator(10);
break;
case 1:
_coinAc = new CoinAccumulator(15);
break;
default:
_coinAc = new CoinAccumulator(20);
break;
}
}
public static BuildingScript ReplaceBuilding(BuildingScript toReplace, Building newBuilding)
{
// Copy all infos from toReplace to new Building
GameBuilding toSpawn = new GameBuilding(newBuilding, toReplace.GridX, toReplace.GridY, toReplace.Orientation);
toSpawn.noTaskCurrent = toReplace.NoTaskCurrent;
toSpawn.populationCurrent = toReplace.PopulationCurrent;
toSpawn.resourceCurrent = toReplace.StorageCurrent;
toSpawn.nr = toReplace.Nr;
toSpawn.stage = toReplace.Stage;
toSpawn.childBuildingStorage = toReplace.ChildBuildingStorage;
toSpawn.childBuildingField = toReplace.ChildBuildingField;
toSpawn.SetTransform(toReplace.transform);
// destroy old building and spawn new building
//Destroy(toReplace.gameObject);
BuildingScript newBs = SpawnBuilding(toSpawn);
newBs.replacing = toReplace;
return(newBs);
}
public void Init(int difficulty, Vector3[] defenderLocations, AddObject spawner)
{
// The player base is the first base.
_enemyBase = spawner.SpawnBases[0].GetComponent<GameBuilding>();
_defenderLocations = defenderLocations;
_spawner = spawner;
switch (difficulty)
{
case 0:
_coinAc = new CoinAccumulator(10);
break;
case 1:
_coinAc = new CoinAccumulator(15);
break;
default:
_coinAc = new CoinAccumulator(20);
break;
}
}
public void ActivateMenuInMode(GameController.GameMode gameMode, GameBuilding building)
{
CloseAllMenus();
switch (gameMode)
{
case GameController.GameMode.egm_Observe:
m_BuildMenu.gameObject.SetActive(true);
break;
case GameController.GameMode.egm_Build:
break;
case GameController.GameMode.egm_Info:
if (building != null)
{
OnBuildingClickHandler(building);
}
break;
}
}
public void SetBuilding(GameBuilding building)
{
m_Building = building;
}
void DemolishBuilding(GameBuilding building)
{
FreeCells(building);
Destroy(building.gameObject);
GameController.Instance().ChangeGameMode(GameController.GameMode.egm_Observe);
}
void OnDemolishClickHandler(GameBuilding building)
{
OnDemolishClick(building);
}
public static BuildingScript SpawnBuilding(GameBuilding gameBuilding)
{
// Spawn prefab
GameObject newBuilding = Instantiate(gameBuilding.building.models,
gameBuilding.GetPosition(), gameBuilding.GetRotation(), Instance.buildingParentTransform);
// Add BuildingScript
BuildingScript bs = newBuilding.AddComponent <BuildingScript>();
bs.SetBuilding(gameBuilding);
// Add fog of war influencer if building is starter building
if (bs.Name == "Höhle")
{
SimpleFogOfWar.FogOfWarInfluence fowi = newBuilding.AddComponent <SimpleFogOfWar.FogOfWarInfluence>();
fowi.ViewDistance = bs.ViewRange;
}
Instantiate(Instance.placeParticles, bs.transform);
// Blueprint UI
GameObject canvRange = Instantiate(Instance.rangeCanvas);
canvRange.transform.SetParent(newBuilding.transform, false);
canvRange.name = "CanvasRange";
canvRange.SetActive(false);
GameObject canvBlueprint = Instantiate(Instance.blueprintCanvas);
canvBlueprint.transform.SetParent(newBuilding.transform, false);
canvBlueprint.name = "CanvasBlueprint";
if (bs.Blueprint)
{
foreach (GameResources res in bs.CostResource)
{
if (res.Amount == 0)
{
continue;
}
GameObject materialPanel = (GameObject)Instantiate(Instance.blueprintMaterialPanel, canvBlueprint.transform.Find("Cost"));
materialPanel.transform.Find("TextMat").GetComponent <Text>().text = "0/" + res.Amount;
materialPanel.transform.Find("ImageMat").GetComponent <Image>().sprite = res.Icon;
}
}
canvBlueprint.transform.Find("ButtonCancel").GetComponent <Button>().onClick.AddListener(() => bs.DestroyBuilding());
// Set Grid
int gx = gameBuilding.orientation % 2 == 0 ? bs.GridWidth : bs.GridHeight;
int gy = gameBuilding.orientation % 2 == 1 ? bs.GridWidth : bs.GridHeight;
for (int dx = 0; dx < gx; dx++)
{
for (int dy = 0; dy < gy; dy++)
{
if (!Grid.ValidNode(gameBuilding.gridX + dx, gameBuilding.gridY + dy))
{
continue;
}
Node n = Grid.GetNode(gameBuilding.gridX + dx, gameBuilding.gridY + dy);
n.SetNodeObject(newBuilding.transform);
if (!bs.Walkable)
{
n.objectWalkable = false;
}
}
}
if (bs.Name == "Höhle")
{
Instance.cave = bs;
}
return(bs);
}
void OnInfoClickHandler(GameBuilding building)
{
CloseAllMenus();
m_InfoWindow.gameObject.SetActive(true);
m_InfoWindow.SetInfo(building);
}
/*public void SetFamilyJob(Job job)
* {
* gameBuilding.familyJobId = job.id;
* }*/
public void SetBuilding(GameBuilding gameBuilding)
{
this.gameBuilding = gameBuilding;
}
public void SetInfo(GameBuilding building)
{
m_Text.text = building.Description;
}
// Instantiate a new building at the same place as the hover building and disable it
public static void PlaceBuilding()
{
// Check if we have enough coins
//if (myVillage.GetCoins() < placingBuilding.GetCost()) canBuild = false;
int gx = Instance.rotation % 2 == 0 ? placingBuilding.gridWidth : placingBuilding.gridHeight;
int gy = Instance.rotation % 2 == 1 ? placingBuilding.gridWidth : placingBuilding.gridHeight;
if (CanBuild())
{
// Disable old occupation temporary
for (int dx = 0; dx < gx; dx++)
{
for (int dy = 0; dy < gy; dy++)
{
if (!Grid.ValidNode(Instance.hoverGridX + dx, Instance.hoverGridY + dy))
{
continue;
}
Node checkNode = Grid.GetNode(Instance.hoverGridX + dx, Instance.hoverGridY + dy);
checkNode.SetTempOccupied(false, false);
}
}
BuildingScript mb = Instance.movingBuilding;
if (mb) // moving an existing building
{
int oldGx = mb.RotWidth();
int oldGy = mb.RotHeight();
for (int dx = 0; dx < oldGx; dx++)
{
for (int dy = 0; dy < oldGy; dy++)
{
if (!Grid.ValidNode(mb.GridX + dx, mb.GridY + dy))
{
continue;
}
Node n = Grid.GetNode(mb.GridX + dx, mb.GridY + dy);
n.SetNodeObject(null);
if (!mb.Walkable)
{
n.objectWalkable = true;
}
}
}
mb.RemoveTerrainGround();
mb.transform.position = Instance.hoverBuilding.position;
mb.transform.rotation = Instance.hoverBuilding.rotation;
mb.SetPosRot(Instance.hoverGridX, Instance.hoverGridY, Instance.rotation);
mb.MoveBuilding();
for (int dx = 0; dx < gx; dx++)
{
for (int dy = 0; dy < gy; dy++)
{
if (!Grid.ValidNode(Instance.hoverGridX + dx, Instance.hoverGridY + dy))
{
continue;
}
Node n = Grid.GetNode(Instance.hoverGridX + dx, Instance.hoverGridY + dy);
n.SetNodeObject(mb.transform);
if (!mb.Walkable)
{
n.objectWalkable = false;
}
}
}
}
else
{
GameBuilding toSpawn = new GameBuilding(placingBuilding, Instance.hoverGridX, Instance.hoverGridY, Instance.rotation);
if (toSpawn.building.stayInRangeOfParent)
{
toSpawn.parentBuildingNr = UIManager.Instance.GetSelectedBuilding().Nr;
}
toSpawn.SetPosition(Instance.hoverBuilding.position);
toSpawn.SetRotation(Instance.hoverBuilding.rotation);
toSpawn.blueprint = true;
/*BuildingScript bs = */ SpawnBuilding(toSpawn);
}
// Take cost for coins
//myVillage.Purchase(b);
// If shift is pressed, don't exit the placing mode
if (mb || !Input.GetKey(KeyCode.LeftShift) || !placingBuilding.multipleBuildings)
{
EndPlacing();
}
InputManager.LeftClickHandled = true;
}
}
public void ShowBuildingInfo(GameBuilding building)
{
m_WorldText.ShowBuildingInfo(building);
}
