//****************************************************************************************************************************** // // FUNCTIONS // //****************************************************************************************************************************** //////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Called when the player presses a button on the selection wheel with this world object // linked to the button. /// </summary> /// <param name="buildingSlot"> // The building slot that instigated the selection wheel. // (EG: If you're making a building, this is the building slot thats being used.) /// </param> public override void OnWheelSelect(BuildingSlot buildingSlot) { // Update building reference _BuildingToRecycle = buildingSlot.GetBuildingOnSlot(); // Valid building check if (_BuildingToRecycle != null) { // Show the confirm screen popup GameObject confirmScreen = GameManager.Instance.ConfirmRecycleScreen; if (confirmScreen != null) { UI_RecycleScreenConfirmation recycleScreen = confirmScreen.GetComponent <UI_RecycleScreenConfirmation>(); if (recycleScreen != null) { recycleScreen.SetBuildingSlotInFocus(buildingSlot); recycleScreen.SetBuildingToRecycle(_BuildingToRecycle); recycleScreen.SetRecycleClass(this); recycleScreen.gameObject.SetActive(true); } } } else { Debug.Log("_BuildingToRecycle == null"); } }
public void BuildGroundBuildingSlots() { Debug.Log("Building building slots."); float stepAngle = 2 * Mathf.PI / nbStartBuildingSlots; float radius = mainPlanet.transform.localScale.x / 2; //Debug.Log("StepAngle: " + stepAngle + " | Rayon: " + radius); for (int i = 0; i < nbStartBuildingSlots; i++) { float angle = stepAngle * i; Vector3 pos = new Vector3(Mathf.Cos(angle) * radius, Mathf.Sin(angle) * radius, mainPlanet.transform.position.z); GameObject instantiatedSlot = Instantiate(buildingSlotPrefab, pos, Quaternion.identity); instantiatedSlot.transform.SetParent(buildingSlotsParent.transform); groundBuildingSlots.Add(instantiatedSlot); allBuildingSlots.Add(instantiatedSlot); BuildingSlot bs = instantiatedSlot.GetComponent <BuildingSlot>(); bs.id = (100 + i); bs.locationType = BuildingManager.BuildingType.BuildingLocationType.Planet; bs.SetDefaultColor(); bs.angleRad = stepAngle * i; } ResetAllBuildingSlotsColor(); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // /// </summary> /// <param name="buildingSlot"></param> private void AddBaseToQueue(BuildingSlot buildingSlot) { // Create the base and initialize it base.OnWheelSelect(buildingSlot); _ClonedWorldObject.SetClonedObject(_ClonedWorldObject); _ClonedWorldObject.GetComponent <Base>()._PreviousBase = _PreviousBase; // Start building the base (if were meant to) Base attachedBase = buildingSlot.AttachedBase; /// previous base if (attachedBase != null) { // This base is at the front of the queue if (attachedBase.GetBuildingQueue()[0] == _ClonedWorldObject) { // Start building it StartBuildingObject(buildingSlot); } } // Set matching team for all the building slots for (int i = 0; i < DepotSlots.Count; i++) { DepotSlots[i].Team = Team; DepotSlots[i]._Player = _Player; } for (int i = 0; i < TowerSlots.Count; i++) { TowerSlots[i].Team = Team; TowerSlots[i]._Player = _Player; } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Called when the player presses a button on the selection wheel with this world object // linked to the button. /// </summary> /// <param name="buildingSlot"> // The building slot that instigated the selection wheel. // (EG: If you're making a building, this is the building slot thats being used.) /// </param> public override void OnWheelSelect(BuildingSlot buildingSlot) { // Gets reference to the original base (before the upgrade) if (buildingSlot != null) { if (buildingSlot.AttachedBase != null) { _PreviousBase = buildingSlot.AttachedBase; } } if (_PreviousBase != null) { // Cant stack base upgrades if (!_PreviousBase._UpgradingBase) { AddBaseToQueue(buildingSlot); } _PreviousBase._UpgradingBase = true; } else { AddBaseToQueue(buildingSlot); } }
public void SelectBuildingLocation(BuildingSlot buildingSpot = null) { // Tutorial indicator // TutorialManager.instance.DisplayIndicator(TutorialManager.IndicatorID.select_building_spot, false); //TutorialManager.instance.DisplayIndicator(TutorialManager.IndicatorID.protect_people, false); //TutorialManager.instance.DisplayIndicator(TutorialManager.IndicatorID.protect_people, false); TutorialManager.instance.DisplayIndicatorIfNotDisplayedYet(TutorialManager.IndicatorID.select_building); // ------------------ // // Chose Building Spot //chosenBuildingSlot = SelectBuildingSpotFromTouch(); // OLD if (buildingSpot != null) { chosenBuildingSlot = buildingSpot.gameObject; } if (chosenBuildingSlot != null) { BuildingSlotManager.instance.ResetAllBuildingSlotsColor(); SurroundingAreasManager.instance.ResetAllSatelliteBuildingSlotsColor(); buildingSpot.SetSelectionColor(); // Display Build button if we can pay for the building UpdateBuildingState(1); } else { Debug.Log("SelectBuildingLocation | chosenBuildingSlot null"); } }
private void BuildBuildingOption(BuildingSlot bs) { //Create the UI: GameObject panelBuildingDetails = (GameObject)Instantiate(panelBuildingDetailsPrefab); panelBuildingDetails.transform.SetParent(content.transform); BuildingOption buildingOption = panelBuildingDetails.GetComponent <BuildingOption>(); //Get the BuildingOption script and set Gameplay values: buildingOption.buildingSlotInfos = bs; buildingOption.setBuildingName(bs.Name); buildingOption.setBuildingSprite(Resources.Load <Sprite>(bs.Image)); int numberOfResourcesNeedeed = bs.Resources.Resource.Count; for (int i = 0; i < numberOfResourcesNeedeed; i++) { GameObject panelResourcesNeededGo = panelResourcesNeededGo = (GameObject)Instantiate(panelResourcesNeedeedPrefab); panelResourcesNeededGo.transform.SetParent(panelBuildingDetails.transform); panelResourcesNeededGo.transform.localPosition = new Vector2(200 + (i * 80), -20); buildingOption.addPanelResourcesNeeded(panelResourcesNeededGo.GetComponent <PanelResourceNeeded>()); BuildingResource br = bs.Resources.Resource[i]; buildingOption.addResource((UsableObject)Activator.CreateInstance(Type.GetType(br.Text), 4), Convert.ToInt32(br.Quantity)); } //Populate the UI: buildingOption.populateUI(); }
public BuildingSlot GetClosestSlot(Vector3 position, BuildingSlotType slotType, bool forPlacement, out float closestDistance) { closestDistance = float.MaxValue; BuildingSlot closestSlot = null; foreach (var slot in _slots) { if (slot.type != slotType && slotType != BuildingSlotType.All) { continue; } if (forPlacement && slot.ignoreForPlacement) { continue; } var dist = (slot.transform.position - position).sqrMagnitude; if (dist < closestDistance) { closestDistance = dist; closestSlot = slot; } } return(closestSlot); }
public void Build(BuildingSlot buildingSlotInfos) { GameObject bulidingToBuild = null; if (buildingSlotInfos.Prefab != null) { bulidingToBuild = Resources.Load <GameObject>("BuildingPrefabs/" + buildingSlotInfos.Prefab); } if (bulidingToBuild != null) { GameObject building = GameObject.Instantiate(bulidingToBuild); Vector3 buildingModificators = building.transform.position; building.transform.position = this.lastSelectedBuilding.transform.position + buildingModificators; Vector3 lastSelectedBuildingRotation = this.lastSelectedBuilding.transform.eulerAngles; building.transform.Rotate(lastSelectedBuildingRotation); GameObject.Destroy(this.lastSelectedBuilding.gameObject); OptionalBuilding ob = building.GetComponent <OptionalBuilding>(); ob.InitBuilding(EntitiesController.INSTANCE.getPlayer()); } else { Debug.LogWarning("Prefab not found for " + buildingSlotInfos.Name); } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // /// </summary> public void HideWidget() { _BuildingToRecycle = null; _BuildingSlotInFocus = null; _RecycleBuildingClass = null; gameObject.SetActive(false); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Starts the construction process of this abstraction. /// </summary> public virtual void StartBuildingObject(BuildingSlot buildingSlot = null) { _ObjectState = WorldObjectStates.Building; // Send message to match feed MatchFeed.Instance.AddMessage(string.Concat(ObjectName, " started construction.")); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// /// </summary> /// <param name="selectable"></param> public void UpdateListWithBuildables(List <Abstraction> selectable, BuildingSlot buildingSlotInFocus) { _BuildingSlotInstigator = buildingSlotInFocus; // Reset button click events for all buttons foreach (var button in _WheelButtons) { // Icon button defaults button.onClick.RemoveAllListeners(); button.onClick.AddListener(() => RefreshButtons(selectable)); // Update slice button defaults Button slice = button.GetComponent <SelectionWheelUnitRef>().RadialSliceButton; slice.onClick.RemoveAllListeners(); slice.onClick.AddListener(() => RefreshButtons(selectable)); } // Clear list & update _BuildingList.Clear(); int i = 0; foreach (var obj in selectable) { if (obj != null) { // If slot is an upgrade UpgradeTree upgrade = obj.GetComponent <UpgradeTree>(); if (upgrade != null) { // Dont update wheel with this button since its the upgrade is maxed out if (upgrade.HasMaxUpgrade()) { continue; } } // Update list with new slots _BuildingList.Add(obj); // Update reference unit SelectionWheelUnitRef unitRef = _WheelButtons[i].GetComponent <SelectionWheelUnitRef>(); unitRef.AbstractRef = obj.GetComponent <Abstraction>(); // Update button click event _WheelButtons[i].onClick.AddListener(delegate { unitRef.AbstractRef.OnWheelSelect(buildingSlotInFocus); }); unitRef.RadialSliceButton.onClick.AddListener(delegate { unitRef.AbstractRef.OnWheelSelect(buildingSlotInFocus); }); } // No selectable reference for this button item so give it an empty slot description else { // Update reference unit SelectionWheelUnitRef unitRef = _WheelButtons[i].GetComponent <SelectionWheelUnitRef>(); unitRef.AbstractRef = null; } ++i; } RefreshButtons(selectable); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Sets the position of the object based on what building slot has been passed through. /// </summary> /// <param name="buildingSlot">< // The building slot that is being used as reference for positioning. /// /param> protected void SetBuildingPosition(BuildingSlot buildingSlot) { // Initial transform update transform.SetPositionAndRotation(buildingSlot.transform.position, buildingSlot.transform.rotation); // Add offset transform.position = new Vector3(transform.position.x, transform.position.y + _OffsetY, transform.position.z); }
public static void RegisterBuildingSlot(BuildingSlot buildingSlot) { if (instance.buildingSlots == null) { instance.buildingSlots = new List <BuildingSlot>(); } instance.buildingSlots.Add(buildingSlot); }
private void Deselect() { _selectedBuildingSlot.Deselect(); _gameSystem.UIController.HideBuildMenu(); _gameSystem.UIController.HideUpgradeMenu(); _isBuildingSlotSelected = false; _selectedBuildingSlot = null; }
public void ClearBuildingModules() { foreach (GameObject go in mSlots) { BuildingSlot slot = go.GetComponent <BuildingSlot>(); slot.ClearSlot(); } mEmptySlots = mBuildingWidth * mBuildingHeight; // reinit to empty }
public SlotViewModel(Province province, Region region, BuildingSlot slot) { this.slot = slot; this.region = region; this.province = province; this.Buildings = new ObservableCollection <BuildingLevel>(); this.selectedBuilding = slot.Building; this.seek = false; }
//****************************************************************************************************************************** // // FUNCTIONS // //****************************************************************************************************************************** //////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Called when the player presses a button on the selection wheel with this world object // linked to the button. /// </summary> /// <param name="buildingSlot"> // The building slot that instigated the selection wheel. // (EG: If you're making a building, this is the building slot thats being used.) /// </param> public override void OnWheelSelect(BuildingSlot buildingSlot) { base.OnWheelSelect(buildingSlot); // Call the OnWheelSelect() function in the attached minefield wrapper if (_MineFieldAttached != null) { _MineFieldAttached.OnWheelSelect(buildingSlot); } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Called when the player presses a button on the selection wheel with this world object // linked to the button. /// </summary> /// <param name="buildingSlot"> // The building slot that instigated the selection wheel. // (EG: If you're making a building, this is the building slot thats being used.) /// </param> public override void OnWheelSelect(BuildingSlot buildingSlot) { // Gets reference to the original turret (before the upgrade) BaseTurret originalTurret = null; if (buildingSlot != null) { if (buildingSlot.GetBuildingOnSlot() != null) { originalTurret = buildingSlot.GetBuildingOnSlot().GetComponent <BaseTurret>(); } } // Remove old healthbar (if valid) float hitpoints = MaxHitPoints; if (originalTurret != null) { hitpoints = originalTurret.GetHitPoints(); if (originalTurret._HealthBar != null) { ObjectPooling.Despawn(originalTurret._HealthBar.gameObject); } } // Create weapon if (_TowerWeapon != null) { _TowerWeapon = ObjectPooling.Spawn(_TowerWeapon.gameObject).GetComponent <Weapon>(); } // Start building process base.OnWheelSelect(buildingSlot); if (_ClonedWorldObject != null) { // Only proceed if there was a previous building & we're upgrading from that if (originalTurret != null) { // Update player ref _ClonedWorldObject.SetPlayer(originalTurret._Player); // Set the new base's building state object to be the currently active object _ClonedWorldObject.BuildingState = originalTurret.gameObject; } // Update attached building slot turret reference if (buildingSlot != null) { buildingSlot.SetBuildingOnSlot(_ClonedWorldObject.GetComponent <BaseTurret>()); } // Reset turret's health _ClonedWorldObject.SetHitPoints(_ClonedWorldObject.MaxHitPoints); } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Starts the construction process of this building. /// </summary> /// <param name="buildingSlot"></param> public override void StartBuildingObject(BuildingSlot buildingSlot = null) { base.StartBuildingObject(buildingSlot); // Determine build time if (_Player != null) { UpgradeManager upgradeManager = _Player.GetUpgradeManager(); BuildingTime *= (int)upgradeManager._BuildingSpeedMultiplier; } }
private void SetPlaceability() { isPlaceable = false; Vector3 origin = new Vector3(transform.position.x, 100f, transform.position.z); RaycastHit hit; if (Physics.Raycast(origin, Vector3.down, out hit, 200f, LayerMask.GetMask(new string[] { "BuildingArea" }))) { BuildingSlot bS = hit.collider.GetComponent <BuildingSlot> (); if (bS.species == player.species && !bS.isOccupied) { transform.position = bS.transform.position; currBuildingSlot = bS; Collider[] colls = Physics.OverlapSphere(transform.position, buildingRadius, GameManager.woLayerMask); if (colls.Length == 0) { isPlaceable = true; } else if (searchTimer > 1f) { foreach (Collider coll in colls) { MobileWorldObject wO = coll.GetComponent <MobileWorldObject>(); if (wO && wO.GetSpecies() == player.species && !wO.isMoving && !wO.attacking) { Vector3 buildingPos = new Vector3(transform.position.x, 0f, transform.position.z); Vector3 woPos = new Vector3(wO.transform.position.x, 0f, wO.transform.position.z); if (woPos == buildingPos) { woPos += new Vector3(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f)); } Vector3 moveVector = woPos - buildingPos; float distance = buildingRadius + (wO.mainCollider as SphereCollider).radius - moveVector.magnitude + 1f; Vector3 destination = wO.transform.position + moveVector.normalized * distance; wO.SetNavAgentDestination(destination, distance + moveVector.magnitude); } } searchTimer = 0f; } } } else { currBuildingSlot = null; } if (isPlaceable) { thisRenderer.material.color = activeSpriteColor; } else { thisRenderer.material.color = inactiveSpriteColor; } }
private void InitializeBuildingSlotes() { _buildingSlotsContainer = _gameSystem.MapController.CurrentLevel.BuildingSlots; foreach (Transform go in _buildingSlotsContainer) { BuildingSlot buildingSlot = go.GetComponent <BuildingSlot>(); buildingSlot.Initialize(_gameSystem); _buildingSlots.Add(buildingSlot); } }
public void EnableTempBuilding(string buildingname) { gameObject.SetActive(true); Building newBuilding = GameManager.GetGameObject(buildingname).GetComponent <Building>(); spriteRenderer.sprite = GameManager.mainSpriteDick[newBuilding.name]; buildingRadius = newBuilding.GetComponent <SphereCollider> ().radius; transform.localScale = newBuilding.GetComponentsInChildren <SpriteParent> (true) [0].transform.localScale; name = buildingname; currBuildingSlot = null; GameManager.HumanPlayer.userInput.enabled = false; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// /// </summary> /// <param name="selectables"></param> public void UpdateListWithBuildings(List <Abstraction> selectables, BuildingSlot buildingSlotInFocus) { _BuildingSlotInstigator = buildingSlotInFocus; // Reset button click events for all buttons foreach (var button in _WheelButtons) { // Icon button defaults button.onClick.RemoveAllListeners(); button.onClick.AddListener(() => HideSelectionWheel()); // Update slice button defaults Button slice = button.GetComponent <SelectionWheelUnitRef>().RadialSliceButton; slice.onClick.RemoveAllListeners(); slice.onClick.AddListener(() => HideSelectionWheel()); } // Clear list & update _BuildingList.Clear(); int i = 0; foreach (var obj in selectables) { if (obj != null) { // Update list with new slots Building building = obj.GetComponent <Building>(); if (building != null) { _BuildingList.Add(building); // Update reference unit SelectionWheelUnitRef unitRef = _WheelButtons[i].GetComponent <SelectionWheelUnitRef>(); unitRef.AbstractRef = building; // Update button click event _WheelButtons[i].onClick.AddListener(delegate { unitRef.AbstractRef.OnWheelSelect(buildingSlotInFocus); }); unitRef.RadialSliceButton.onClick.AddListener(delegate { unitRef.AbstractRef.OnWheelSelect(buildingSlotInFocus); }); } } // No selectable reference for this button item so give it an empty slot description else { // Update reference unit SelectionWheelUnitRef unitRef = _WheelButtons[i].GetComponent <SelectionWheelUnitRef>(); unitRef.AbstractRef = null; } ++i; } RefreshButtons(selectables); }
public void DisplayBuilding(BuildingSlot buildingSlot) { this.currentSlot = buildingSlot; BuildingName.text = buildingSlot.Name; BuildingDesc.text = buildingSlot.building.Description; buildButton.interactable = buildingSlot.IsAvailable; ClearResourceRows(); foreach (Building.BuildingCost cost in currentSlot.building.buildingCosts) { CreateResourceRow(cost.resource, cost.amount); } }
//****************************************************************************************************************************** // // FUNCTIONS // //****************************************************************************************************************************** //////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Called when the player presses a button on the selection wheel with this world object linked to the button. /// </summary> /// <param name="buildingSlot"> // The building slot that instigated the selection wheel. // (EG: If you're making a building, this is the building slot thats being used.) /// </param> public override void OnWheelSelect(BuildingSlot buildingSlot) { base.OnWheelSelect(buildingSlot); // Detonate all known mines on the attached minefield MineField mineField = buildingSlot.GetBuildingOnSlot() as MineField; for (int i = 0; i < mineField.GetUndetonatedMines().Count; i++) { Mine mine = mineField.GetUndetonatedMines()[i]; mine.DetonateMine(); } }
public void Select(BuildingSlot buildingSlot) { touchMode = TouchMode.BUILDING_SELECTED; selectedBuildingSlot = buildingSlot; foreach (BuildingSlot buildingSlotToHide in buildingSlots) { buildingSlotToHide.HideIndicator(); } selectedBuildingSlot.ShowIndicator(); UIController.SetUpgradeButton(selectedBuildingSlot.child); UIController.SetPanel(UIController.Panel.BUILDING_SELECTED); }
private BuildMenuData GetMenuData(BuildingSlot slot) { BuildMenuData menuData = new BuildMenuData(); menuData.position = Camera.main.WorldToScreenPoint(slot.transform.position); if (slot.Occupied) { menuData.BuildingData = _buildingsData[slot.Building.Type]; menuData.BuildingLevel = slot.Building.Level; menuData.MaxBuildingLevel = _buildingsData[slot.Building.Type].MaxLevel; } return(menuData); }
// Start is called before the first frame update void Start() { for (int i = contentList.transform.childCount - 1; i >= 0; i--) { Destroy(contentList.transform.GetChild(i).gameObject); } foreach (var building in buildings) { BuildingSlot slot = Instantiate(buildingSlotPrefab, contentList.transform); slot.SetBuilding(building); slot.Init(); } }
private void InitPlants() { PlantPanel = GameObject.Find("PlantPanel"); plantSlots = new List <BuildingSlot>(); for (int i = 0; i < GameManager.instance.GetPlantCount(); i++) { GameObject slot = Instantiate(prefabBuildingSlot, PlantPanel.transform); BuildingSlot plantSlot = slot.GetComponent <BuildingSlot>(); Button slotButton = slot.GetComponent <Button>(); slotButton.onClick.AddListener(delegate { CreatePlant(plantSlot.objectId); }); plantSlot.InitPlant(GameManager.instance.Plants[i].GetComponent <AbstractPlant>().buildingData); plantSlots.Add(plantSlot); } }
//****************************************************************************************************************************** // // FUNCTIONS // //****************************************************************************************************************************** //////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> // Called when the player presses a button on the selection wheel with this world object // linked to the button. /// </summary> /// <param name="buildingSlot"> // The building slot that instigated the selection wheel. // (EG: If you're making a building, this is the building slot thats being used.) /// </param> public override void OnWheelSelect(BuildingSlot buildingSlot) { // Gets reference to the original generator (before the upgrade) Generator originalGenerator = null; if (buildingSlot != null) { if (buildingSlot.GetBuildingOnSlot() != null) { originalGenerator = buildingSlot.GetBuildingOnSlot().GetComponent <Generator>(); } } // Remove old healthbar (if valid) float hitpoints = MaxHitPoints; if (originalGenerator != null) { hitpoints = originalGenerator.GetHitPoints(); if (originalGenerator._HealthBar != null) { ObjectPooling.Despawn(originalGenerator._HealthBar.gameObject); } } // Start building process base.OnWheelSelect(buildingSlot); if (_ClonedWorldObject != null) { // Only proceed if there was a previous building and we are upgrading from that if (originalGenerator != null) { // Update player ref _ClonedWorldObject.SetPlayer(originalGenerator._Player); // Set the new bases building state object to be the currently active object _ClonedWorldObject.BuildingState = originalGenerator.gameObject; } // Update attached buildingSlot generator reference if (buildingSlot != null) { buildingSlot.SetBuildingOnSlot(_ClonedWorldObject.GetComponent <Generator>()); } // Reset building's health _ClonedWorldObject.SetHitPoints(_ClonedWorldObject.MaxHitPoints); } }