public override bool AddNeighbor(BaseBuilding newNeighbor)
{
if(HasOpenConnections)
{
return base.AddNeighbor(newNeighbor);
}
else
return false;
}
public void RemoveAtBuilding(BaseBuilding building)
{
buildingTransformList.Remove(building.transform);
//Cameraの揺れ
_cameraController.ShakeCamera(1.0f);
if (buildingTransformList.Count == 0)
{
_gameEndPresenter.OnGameEnd(isClear: true);
}
}
/// <summary>
/// Called when a building was removed from our group.
/// shorten the radius.
/// </summary>
/// <param name="building">the removed building</param>
void GroupBuildingRemoved(BaseBuilding building)
{
totalVectors -= building.transform.localPosition;
float distance = (correctPosition - building.transform.position).magnitude;
distance += radiusAdjuster;
if (distance > maxPointOnGroup)
{
CalculateNewMaxPoint();
}
}
/// <summary>
/// Called when a building was added to our group.
/// extend the radius.
/// </summary>
/// <param name="building">the added building</param>
void GroupBuildingAdded(BaseBuilding building)
{
totalVectors += building.transform.localPosition;
float distance = (correctPosition - building.transform.position).magnitude;
distance += radiusAdjuster;
if (distance > maxPointOnGroup)
{
maxPointOnGroup = distance;
}
}
public GameClass()
{
MainBase = new BaseBuilding(100);
standardTurretTemp = new StandardTurret();
missleLuncherTemp = new MissleTurret();
LaserTurretTemp = new LaserTurret();
kills = 0;
score = 0;
coins = 500;
wavesPassed = 0;
startlives = 50;
Lives = startlives;
}
/// <summary>
/// Returns the best building to shoot and its score.
/// </summary>
/// <param name="enemyPlayer"></param>
/// <returns></returns>
private (BaseBuilding, int) FindBestBuilding()
{
BaseBuilding bestBuilding = null;
int bestScore = -1;
int numBuilding = enemyPlayer.buildings.Count;
foreach (BaseBuilding building in enemyPlayer.buildings)
{
float sqDist = (myTransform.position - building.GetPosition()).sqrMagnitude;
//if it's in range, then we'll give it a score
if (sqDist < mySqShootRange)
{
float sqDistFromEnemyTower = (building.GetPosition() - enemyPlayer.mainTower.GetPosition()).sqrMagnitude;
int myScore = 0;
//check in attacking range
if (sqDist < (building.GetAttackRange() * building.GetAttackRange()))
{
myScore += 15;
}
//now other things are done based on its type
switch (building.GetBuildingType())
{
case BuildingType.MAIN:
myScore += 4;
break;
case BuildingType.BARRACKS:
myScore += 3;
break;
case BuildingType.TOWER:
myScore += 1;
break;
}
if (myScore > bestScore)
{
bestBuilding = building;
bestScore = myScore;
}
}
}
return(bestBuilding, bestScore);
}
public bool CanConstructItem()
{
BaseBuilding bb = constructableItems[indexItemToConstruct].GetComponent <BaseBuilding>();
Vector3 buildingPos = placeHolderItem.transform.position;
if (bb.costWood <= Base.WoodAmount && bb.costStone <= Base.StoneAmount && bb.costIron <= Base.IronAmount && bb.costCopper <= Base.CopperAmount)
{
if (levelGenerator.gridCellOccupied[(int)buildingPos.x + (int)buildingPos.z * levelGenerator.mapSize] == false)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Quite possibly a horribly slow way of adding units.
/// </summary>
public void ProduceUnits()
{
Random randomer = new Random();
uint totalUnits = owner.CountUnits();
foreach (Graph g in owner.GetGraphs())
{
if (totalUnits >= POP_CAP_PER_PLAYER)
{
break;
}
List <Unit> res = new List <Unit>();
//TODO Remove when middle point position is implemented.
BaseBuilding b = g.baseBuilding;
if (b == null)
{
continue;
}
int unitsToProduce = b.RateOfProduction;
if (b.RateOfProduction + totalUnits > POP_CAP_PER_PLAYER)
{
unitsToProduce = (int)(POP_CAP_PER_PLAYER - totalUnits);
}
logger.Debug("Producing " + unitsToProduce + " units!");
if (unitsToProduce > 0)
{
totalUnits += (uint)unitsToProduce;
}
for (int i = 0; i < unitsToProduce; i++)
{
// Places them randomly around the fromBuilding. - John
// No, it does not. - Martin
Unit temp = new Unit(b.owner, b.position, b);
res.Add(temp);
}
b.owner.AddUnits(res);
b.AddUnits(res);
//This should not be needed but does not hurt i hope.
res.Clear();
}
}
public override void DestroyBuilding(BaseBuilding building, RaycastHit hit)
{
BoltBuilding boltBuilding = (BoltBuilding)building;
if(boltBuilding == null)
{
base.DestroyBuilding(building,hit);
return;
}
var evnt = UpdateNetworkedBuilding.Create(Bolt.GlobalTargets.OnlyServer, Bolt.ReliabilityModes.ReliableOrdered);
evnt.buildingUID = boltBuilding.networkedID;
evnt.health = 0;
evnt.Send();
}
public BaseObject OnToolBarClick(BaseObject obj)
{
Vector3 startPosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
placementObject = new BaseFactory().CreateUnit(PlayerManager.humanPlayer, obj, startPosition) as BaseBuilding;
PlacementEffect placementEffect = placementObject.GetComponent <PlacementEffect>();
if (placementObject.GetComponent <PlacementEffect>() == null)
{
placementEffect = placementObject.gameObject.AddComponent <PlacementEffect>();
}
placementEffect.Setup();
return(null); //Should not be used
}
public static void UpdateStats(BaseBuilding b)
{
_FreeCurrent.text = (b.TotalAnts - b.BuilderAnts - b.WorkerAnts - b.CarrierAnts).ToString();
_FreeSlider.maxValue = b.TotalAnts;
_FreeSlider.value = b.FreeAnts;
_FreeSlider.enabled = false;
_BuilderCurrent.text = b.BuilderAnts.ToString();
_BuilderSlider.maxValue = b.FreeAnts;
_BuilderSlider.value = b.BuilderAnts;
//transform.Find("Stats.SpawnSpeed/Current").GetComponent<Text>().text = SpawnSpeed.ToString() + "x";
//transform.Find("Stats.SpawnSpeed/Upgrade").GetComponent<Text>().text = (SpawnSpeed + 0.125f).ToString() + "x";
//transform.Find("Stats.AntSpeed/Current").GetComponent<Text>().text = AntSpeed.ToString() + "x";
//transform.Find("Stats.AntSpeed/Upgrade").GetComponent<Text>().text = (AntSpeed + 0.125f).ToString() + "x";
}
Vector3 GetBuildPos(PlayerData myPlayer, PlayerData enemyPlayer)
{
int randomBuildingIndex = Random.Range(0, myPlayer.buildings.Count);
BaseBuilding nearBuilding = myPlayer.buildings[randomBuildingIndex];
float angle = Random.value * Mathf.PI * 2;
Vector3 offset = new Vector3(Mathf.Cos(angle), 0, Mathf.Sin(angle));
offset *= nearBuilding.blockingRadius * 2;
Vector3 buildPos = nearBuilding.GetPosition() + offset;
buildPos.x = Mathf.Clamp(buildPos.x, -30, 30);
buildPos.z = Mathf.Clamp(buildPos.z, -40, 40);
return(buildPos);
}
/// <summary>
/// Calls on awake, sets up values and adds the socket to the global sockets collection.
/// </summary>
public virtual void Awake()
{
building = GetComponentInParent <BaseBuilding>();
if (!LayersData.SocketLayers.Contains(LayerMask.LayerToName(gameObject.layer)))
{
gameObject.layer = LayersData.DefaultSocketLayer;
}
if (previewInstance != null) // get rid of preview on init
{
DestroyImmediate(previewInstance.gameObject);
previewInstance = null;
PreviewObject = null;
}
}
/// <summary>
/// Called when the building is destoryed, apply networked actions.
/// </summary>
/// <param name="_building"></param>
/// <param name="hit"></param>
public override void DestroyBuilding(BaseBuilding _building, RaycastHit hit)
{
PhotonCloudBuilding building = (PhotonCloudBuilding)_building;
if (building == null)
{
base.DestroyBuilding(building, hit);
return;
}
var evnt = new uConstruct.Extensions.PCloudExtension.UpdateNetworkedBuilding();
evnt.buildingUID = building.networkedID;
evnt.health = 0;
evnt.SendToServer();
}
public override void DestroyBuilding(BaseBuilding building, RaycastHit hit)
{
ForgeBuilding boltBuilding = (ForgeBuilding)building;
if (boltBuilding == null)
{
base.DestroyBuilding(building, hit);
return;
}
var evnt = new UpdateNetworkedBuilding();
evnt.buildingUID = boltBuilding.networkedID;
evnt.health = 0;
evnt.Send(NetworkReceivers.Server);
}
/// <summary>
/// This method will handle all the building sockets and check if one of the buildings in the group are on that socket.
/// </summary>
/// <param name="building">the building you want to apply sockets check for.</param>
public virtual void HandleOccupiedSockets(BaseBuilding building)
{
BaseBuilding groupBuilding;
BaseSocket socket;
for (int i = 0; i < groupBuildings.Count; i++)
{
groupBuilding = groupBuildings.ElementAt(i);
socket = building.ReturnSocket(groupBuilding.transform.position, groupBuilding.buildingType);
if (socket != null)
{
socket.isOccupied = true;
}
}
}
protected override void Update()
{
if (!HasBeenPlaced)
{
return;
}
GridCell[] neighbours = GridManager.Instance.GetNeighbors(Coordinates);
for (int i = 0; i < neighbours.Length; i++)
{
if (neighbours[i].IsOccupied && neighbours[i].Occupant is BaseBuilding)
{
BaseBuilding bb = neighbours[i].Occupant as BaseBuilding;
bb.AddToFillAmount(bb.FillRate * Time.deltaTime);
}
}
}
public override void UnPack(GameObject target)
{
BaseBuilding building = target.GetComponentInParent <BaseBuilding>();
if (building != null)
{
BaseSocket socket = building.CreateSocket(name, SocketPositionAnchor.Center, null, receiveType, placingType);
socket.transform.localPosition = (Vector3)position;
socket.transform.localScale = (Vector3)scale;
socket.transform.localRotation = (Quaternion)rotation;
socket.center = (Vector3)this.center;
socket.size = (Vector3)this.size;
socket.isHoverTarget = isHoverTarget;
}
}
/// <summary>
/// use this with unplaced Objects
/// </summary>
/// <param name="building">the building</param>
/// <param name="location">position of placement</param>
public void SpawnBuilding(BaseBuilding building, SimpleCords location, int orientation)
{
Map[location.x, location.z].Building = building;
Map[location.x, location.z].occupation = TileOccupation.Building;
foreach (var item in building.occupying)
{
Debug.Log("Spawn Building with orientation: " + orientation);
SimpleCords c = location.OffsetBy(item.Rotate(orientation));
Map[c.x, c.z].Building = building;
Map[c.x, c.z].occupation = TileOccupation.Building;
}
building.CenterLocation = location;
building.PlaceWithOrientation(orientation, location);
Buildings.Add(building);
}
public override void PlaceBuilding()
{
BaseBuilding.CallPack(currentBuilding);
var evnt = CreateNetworkedBuilding.Create(Bolt.GlobalTargets.OnlyServer, Bolt.ReliabilityModes.Unreliable);
evnt.pos = currentBuilding.transform.position;
evnt.rot = currentBuilding.transform.rotation;
evnt.placedOnID = ((BoltBuilding)(currentBuilding)).networkedPlacedOnID;
evnt.prefabID = currentBuilding.prefabID;
evnt.requester = entity;
evnt.Send();
DestroyCurrentBuilding();
ResetBuildingInstance();
}
// Constructor needs the projectiles manager for the base class, and a home base building
public MinerShip(BaseBuilding HomeBase)
: base("Config/Ships/MinerConfig")
{
// Save given managers
this.HomeBase = HomeBase;
// Create a beam object & line
BeamObject = new GameObject("Beam Line");
BeamLine = BeamObject.AddComponent("LineRenderer") as LineRenderer;
BeamLine.material = new Material(Shader.Find("Particles/Additive"));
BeamLine.SetColors(Color.green, Color.green);
BeamLine.SetWidth(2.0f, 2.0f);
BeamLine.SetVertexCount(2);
// Randomize time
TotalTime = UnityEngine.Random.Range(-60.0f, 60.0f);
// Warp to the base
SetPos(HomeBase.Position);
}
/// <summary>
/// Adds a building to the global building pool.
/// </summary>
/// <returns>
/// A pointer to the newly created building.
/// </returns>
/// <param name='newBuilding'>
/// The new building to add to the global pool.
/// </param>
public bool AddBuilding(BaseBuilding newBuilding)
{
m_CurrBuilding = null;
bool buildingIsNew = false;
if(m_TotalBuildings.Count - m_PowerNodes.Count >= MAX_BUILDINGS)
return false;
int buildingPrice = Globals.WorldView.ResManager.ConsumeResources(newBuilding.MineralPrice);
if(buildingPrice < newBuilding.MineralPrice)
{
Globals.WorldView.OverlayView.PushMessage(Color.green, "Not enough funds!");
Globals.WorldView.ResManager.AddResources(buildingPrice);
return false;
}
Globals.WorldView.OverlayView.PushMessage(Color.green, "Placed new building: " + newBuilding.Name);
// temporarily color the sprite white (it's normal color)
//newBuilding.Sprite.SetColor(Color.white);
newBuilding.IsConstructing = true;
newBuilding.CurrConstructTime = 0.0f;
if(newBuilding is CommandCenterBuilding)
{
CommandCenterBuilding newCC = (CommandCenterBuilding)newBuilding;
if(!m_CommandCenters.Contains(newCC))
{
m_PowerNodes.Add(newCC);
m_CommandCenters.Add(newCC);
buildingIsNew = true;
}
}
else if(newBuilding is PowerNodeBuilding)
{
PowerNodeBuilding powerNode = (PowerNodeBuilding)newBuilding;
if(!m_PowerNodes.Contains(powerNode))
{
m_PowerNodes.Add(powerNode);
buildingIsNew = true;
}
}
else
{
// grey the sprite out and let the manager check
// to see that it's powered
newBuilding.Sprite.SetColor(Color.grey);
if(!m_WorldBuildings.Contains(newBuilding))
{
m_WorldBuildings.Add(newBuilding);
buildingIsNew = true;
}
}
if(buildingIsNew)
{
m_TotalBuildings.Add(newBuilding);
if(m_ClosestBuildings != null)
{
bool addedToNeighbor = false;
bool isPowerNode = newBuilding is PowerNodeBuilding;
foreach(BaseBuilding neighbor in m_ClosestBuildings)
{
if(isPowerNode && !(neighbor is PowerNodeBuilding))
addedToNeighbor = newBuilding.AddNeighbor(neighbor);
else
addedToNeighbor = neighbor.AddNeighbor(newBuilding);
if(addedToNeighbor)
{
Connection NewConnection = new Connection(neighbor.Position, newBuilding.Position, 0.0f);
m_Connections.Add(NewConnection);
NewConnection.Connect();
}
}
}
return true;
}
else
return false;
}
private bool CanConnect(PowerNodeBuilding oldBuilding, BaseBuilding newBuilding, float dist)
{
return (dist <= oldBuilding.MaxConnectiveDist &&
dist <= newBuilding.MaxConnectiveDist &&
dist >= oldBuilding.MinConnectiveDist &&
dist >= newBuilding.MinConnectiveDist &&
oldBuilding.HasOpenConnections);
}
private void BlowUpBuilding(BaseBuilding building)
{
// Create destruction geometry / animation at the old position
for(int j = 0; j < 32; j++)
{
float radius = building.Sprite.GetGeometrySize().x;
Vector2 Offset = new Vector2(UnityEngine.Random.Range(-radius, radius), UnityEngine.Random.Range(-radius, radius));
Globals.WorldView.ProjManager.AddExplosion(building.Position + Offset);
}
}
/// <summary>
/// Removes the building from the global pool.
/// </summary>
/// <returns>
/// The building to remove.
/// </returns>
/// <param name='oldBuilding'>
/// True if the building was removed, false otherwise.
/// </param>
public bool RemoveBuilding(BaseBuilding oldBuilding)
{
bool buildingRemoved = false;
if(oldBuilding is CommandCenterBuilding)
{
CommandCenterBuilding oldCC = (CommandCenterBuilding)oldBuilding;
if(m_CommandCenters.Contains(oldCC))
{
m_CommandCenters.Remove(oldCC);
m_PowerNodes.Remove(oldCC);
buildingRemoved = true;
}
}
else if(oldBuilding is PowerNodeBuilding)
{
PowerNodeBuilding powerNode = (PowerNodeBuilding)oldBuilding;
if(m_PowerNodes.Contains(powerNode))
{
m_PowerNodes.Remove(powerNode);
buildingRemoved = true;
}
}
else
{
if(m_WorldBuildings.Contains(oldBuilding))
{
m_WorldBuildings.Remove(oldBuilding);
buildingRemoved = true;
}
}
if(buildingRemoved)
m_TotalBuildings.Remove(oldBuilding);
for(int i = m_Connections.Count - 1; i >= 0; --i)
{
if(m_Connections[i].Point1 == oldBuilding.Position || m_Connections[i].Point2 == oldBuilding.Position)
{
m_Connections[i].Disconnect();
m_Connections.RemoveAt(i);
}
}
return buildingRemoved;
}
public void DestroyBuilding(BaseBuilding oldBuilding)
{
Globals.WorldView.SManager.RemoveSprite(oldBuilding.Sprite);
if(oldBuilding == m_CurrBuilding)
m_CurrBuilding = null;
oldBuilding = null;
}
public BaseBuilding CreateBuilding(string configName)
{
ConfigFile configFile = new ConfigFile(configName);
string buildingType = configFile.GetKey_String("General", "Type");
buildingType = buildingType.Trim().ToLower();
BaseBuilding newBuilding = null;
if(buildingType == "turret")
newBuilding = new TurretBuilding(configName);
else if(buildingType == "shipyard")
newBuilding = new ShipyardBuilding(configName);
else if(buildingType == "powernode")
newBuilding = new PowerNodeBuilding(configName);
else if(buildingType == "commandcenter")
newBuilding = new CommandCenterBuilding(configName);
else
newBuilding = new BaseBuilding(configName);
newBuilding.Sprite.SetColor(Color.grey);
m_CurrBuilding = newBuilding;
return newBuilding;
}
// Update is called once per frame
void Update()
{
// If not yet loaded, it should be good to go..
if(!LevelLoaded)
OnLevelWasLoaded();
// Do nothing if paused or not yet loaded
if(Paused)
return;
// DeltaTime
float dT = Time.deltaTime;
// Apply the play-speed factor
if(Globals.WorldView.PlaySpeed == GameSpeed.Fast)
dT *= 2;
else if(Globals.WorldView.PlaySpeed == GameSpeed.Faster)
dT *= 4;
TotalTime += dT;
/*** Background Update ***/
// Update background UV offsets
Vector2 CameraPos = new Vector2(Camera.main.transform.position.x, -Camera.main.transform.position.y);
for(int i = 0; i < 3; i++)
{
// Update UV pos
BackgroundSprites[i].SetSpritePos(CameraPos * (float)(i + 1) * 0.2f + new Vector2(TotalTime, TotalTime) * 0.5f);
// Update on-screen position (just follow camera)
BackgroundSprites[i].SetPosition(-BackgroundSprites[i].GetGeometrySize() / 2.0f + new Vector2(CameraPos.x, -CameraPos.y));
}
/*** Update Enemy Ship Spawning ***/
UpdateEnemySpawn();
/*** Update Buildings ***/
BuildingManager.Update();
/*** Mouse Events ***/
// Start of down press
if(Input.GetMouseButtonDown(0))
{
// Get the ship we clicked on
Vector2 WorldMousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
TargetShip = ShipManager.GetShipAt(WorldMousePos);
TargetBuilding = BuildingManager.GetBuildingAt(WorldMousePos);
}
// If the user does a full click on-screen...
else if(Input.GetMouseButtonUp(0))
{
// Get the ship we released on, if any
Vector2 WorldMousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
// Find ship and building
BaseShip ReleaseShip = ShipManager.GetShipAt(WorldMousePos);
BaseBuilding ReleaseBuilding = BuildingManager.GetBuildingAt(WorldMousePos);
// If the selected ships match, then we should show the UI
if(TargetShip != null && TargetShip == ReleaseShip)
{
Paused = true;
EntityMenu EntityView = gameObject.AddComponent(typeof(EntityMenu)) as EntityMenu;
EntityView.LoadDetails(TargetShip);
Globals.PushView(EntityView);
}
// If building..
else if(TargetBuilding != null && TargetBuilding == ReleaseBuilding)
{
ContextMenuView.Target = TargetBuilding;
ContextMenuView.enabled = true;
}
// Else, placing a building...
else if(CurrentBuilding != null)
{
bool buildingAdded = BuildingManager.AddBuilding(CurrentBuilding);
if(buildingAdded)
{
CurrentBuilding = null;
PlacingBuilding = false;
}
}
// Reset building UI
else
{
ContextMenuView.enabled = false;
}
// Always reset the ship once selected or not
TargetShip = null;
}
// Else if right-click mouse up, release building
else if(Input.GetMouseButtonUp(1) && CurrentBuilding != null)
{
BuildingManager.DestroyBuilding(CurrentBuilding);
CurrentBuilding = null;
PlacingBuilding = false;
}
/*** Music Update ***/
// Get total enemy ship count
int EnemyCount = 0;
foreach(BaseShip Ship in ShipManager.ShipsList)
{
if(Ship is EnemyShip)
EnemyCount++;
}
// If enemies are gone, transition back to normal music
if(EnemyCount <= 0)
SongManager.TransitionAudio(false);
/*** Building Placement ***/
if(PlacingBuilding && CurrentBuilding == null)
CurrentBuilding = BuildingManager.CreateBuilding("Config/Buildings/" + CurrBuildingConfig);
if(CurrentBuilding != null)
CurrentBuilding.Position = Camera.main.ScreenToWorldPoint(new Vector2(Input.mousePosition.x, Input.mousePosition.y));
/*** Win/Lose Check ***/
// Get player count: if no ships and no buildings left, we loose
int Miners = 0, Attackers = 0, Destroyers = 0, Carriers = 0;
Globals.WorldView.ShipManager.GetFriendlies(ref Miners, ref Attackers, ref Destroyers, ref Carriers);
// Lose check:
if(Miners == 0 && Attackers == 0 && Destroyers == 0 && Carriers == 0 && BuildingManager.WorldBuildings.Count == 0)
{
// Flip on pause state
Paused = true;
// Push pause menu
LoseMenu LoseView = gameObject.AddComponent(typeof(LoseMenu)) as LoseMenu;
LoseView.SetLevel(TargetLevel);
Globals.PushView(LoseView);
// Unlock the next level (if any)
LevelManager.SetLevelUnlocked(TargetLevel + 1);
}
// Win check:
else
{
// Has the player won?
bool PlayerWon = false;
// 1. Check for time
if(WinLogic.IfWinTime && (int)TotalTime > WinLogic.WinTime)
PlayerWon = true;
// 2. Check for enemy kills
if(WinLogic.IfWinKillAll)
{
// Get enemy count and make sure it is the last group
Globals.WorldView.ShipManager.GetEnemies(ref Attackers, ref Destroyers, ref Carriers);
if(GetNextEnemySpawnTime() < 0.0f && Attackers == 0 && Destroyers == 0 && Carriers == 0)
PlayerWon = true;
}
// 3. Check for resource consumption
if(WinLogic.IfWinResources && SceneManager.AllResourcesConsumed())
PlayerWon = true;
// Player win check
if(PlayerWon)
{
// Flip on pause state
Paused = true;
// Push pause menu
WinMenu WinView = gameObject.AddComponent(typeof(WinMenu)) as WinMenu;
WinView.SetLevel(TargetLevel);
Globals.PushView(WinView);
}
}
}
public virtual bool AddNeighbor(BaseBuilding newNeighbor)
{
if(!m_Neighbors.Contains(newNeighbor))
{
m_Neighbors.Add(newNeighbor);
return true;
}
else
return false;
}
