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; }