// GameObject buildingPrefab;
//public BuildingPlot buildingPlot;
public override List <DataObject> Solve(List <DataObject> dataArray)
{
// Load a Building
DataObject dataObjectBuildingBase = BuildingBlockChain.GetLastObjectOfTypeFromDataArray(dataArray, DataObject.ObjectTypes.BuildingBase);//(GetLastObjectOfTypeFromDataArray<GameObject>(dataArray));
if (dataObjectBuildingBase == null)
{
Debug.LogError("BuildBuilding could not be resolved, because it couldnt load a dataObject with BuildingBase as its type");
return(dataArray);
}
// Load a BuildingPlot
DataObject dataObjectBuildingPlot = BuildingBlockChain.GetLastObjectOfTypeFromDataArray(dataArray, DataObject.ObjectTypes.BuildingPlot);
if (dataObjectBuildingPlot == null)
{
Debug.LogError("BuildBuilding could not be resolved, because it couldnt load a dataObject with BuildingPlot as its type");
return(dataArray);
}
// only do something and alter the dataArray if it is certain this entire action can be resolved!
BuildingBase buildingBase = (BuildingBase)dataObjectBuildingBase.objectRef;
Building nwBuilding = ((BuildingPlot)dataObjectBuildingPlot.objectRef).BuildBuilding(buildingBase);
DataObject nwDataObject = new DataObject(DataObject.ObjectTypes.Building, nwBuilding.gameObject.GetComponent <Building>());//new DataObject().Setup(DataObject.ObjectTypes.Building, nwBuilding.GetComponent<Building>());
// TODO: check if data is correctly formatted!
// TODO2: Do this in a editor
Debug.Log("TODO: check if data is correctly formatted!");
dataArray.Add(nwDataObject); //build the building and add it to the array
return(base.Solve(dataArray));
}
private void InfoPanelRaycast()
{
Ray ray = new Ray(Camera.main.transform.position, Camera.main.transform.forward);
RaycastHit hit;
Debug.DrawRay(ray.origin, ray.direction * 100);
if (Physics.Raycast(ray, out hit))
{
if (hit.collider.GetComponentInParent <BuildingBase>())
{
BuildingBase building = hit.collider.GetComponentInParent <BuildingBase>();
BuildingType type = building.type;
float profit = buildingsControllers[(int)type].Profit;
int amount = buildingsControllers[(int)type].GetBuildingsAmount();
double income = profit * amount;
double incomePercent = income / moneyPerSec;
UIController.Instance.ShowInfoPanel(type, profit, amount, income, incomePercent);
}
else
{
UIController.Instance.InfoPanelVisibility(false);
}
}
else
{
UIController.Instance.InfoPanelVisibility(false);
}
}
public void SetupItem(BuildingBase buildingBase, Action action)
{
this.text.text = buildingBase.GetComponent <HoverInfo>().displayName;
this.image.sprite = buildingBase.GetComponent <SpriteRenderer>().sprite;
this.buildingBase = buildingBase;
if (buildingBase.oreCost == 0)
{
this.oreCost.transform.parent.gameObject.SetActive(false);
}
else
{
this.oreCost.text = buildingBase.oreCost.ToString();
}
if (buildingBase.crystalCost == 0)
{
this.crystalCost.transform.parent.gameObject.SetActive(false);
}
else
{
this.crystalCost.text = buildingBase.crystalCost.ToString();
}
if (buildingBase.powerCost == 0)
{
this.powerCost.transform.parent.gameObject.SetActive(false);
}
else
{
this.powerCost.text = buildingBase.powerCost.ToString();
}
this.button.onClick.AddListener(delegate { action(buildingBase); });
}
// creates a new menu item
private BuildMenuItem CreateMenuItem(BuildingBase buildingBase)
{
BuildMenuItem item = Instantiate(menuItemPrefab, scrollZone);
item.SetupItem(buildingBase, BuildManager.instance.SelectBuild);
return(item);
}
public void Toggle()
{
if (toggle == LinkType.on)
{
GetComponent <Image>().sprite = toggleOff;
toggle = LinkType.off;
}
else if (toggle == LinkType.off)
{
GetComponent <Image>().sprite = toggleOff;
toggle = LinkType.on;
}
BuildingBase building = linkingTower.GetComponent <BuildingBase>();
if (linkingTower != null && toggle == LinkType.over)
{
if (building.GetLinksLeft() == 0 && Player.player.hasGold(100))
{
Player.player.TakeGold(100);
building.LevelUp();
toggle = LinkType.on;
//building.AddLink(linkingAugment, LinkType.on);
building.ToggleLink(linkingAugment);
building.SetLink(linkingAugment, LinkType.on);
building.ForceUpdate();
MouseHook.mousehook.UpdateLinks();
return;
}
}
building.ToggleLink(linkingAugment);
}
public override bool DoAction()
{
if (!CanHealOther())
{
return(false);
}
float hpRate = 1.1f;
BuildingBase lowestHealthBuilding = null;
foreach (var building in MapManager.Instance.GetCollectionOfItems <BuildingBase>())
{
if (Util.Get2DDistanceSquared(building.gameObject, this.gameObject) <= range)
{
if (hpRate > building.GetHitPointPercentage())
{
hpRate = building.GetHitPointPercentage();
lowestHealthBuilding = building;
}
}
}
if (lowestHealthBuilding != null && hpRate < 1.0f)
{
//Debug.LogFormat("{0},{1}", lowestHealthBuilding.name, strength);
lowestHealthBuilding.AddHitPoint(strength);
actionState = ESupportBuildingState.COOLING_DOWN;
actionCoolDownStartTime = Time.time;
return(true);
}
return(false);
}
//건물생성함수(건물타입, 생성위치) : 매개변수를 토대로 프리팹을 가져와서 인스턴스화 한다
//건물생성함수는 빌딩ID("건물타입_시간")를 생성한다
public BuildingBase BuildBuilding(BuildingType type, Vector3 position)
{
// 이 때의 시간은 WorldTime이 아닌,
// Unix time stamp를 써야한다.
string objID = $"{type.ToString()}_{s_uniqueID++}";
var resource = Resources.Load($"Prefabs/Building/{type.ToString()}");
if (resource == null)
{
Debug.Log($"{type.ToString()}가 없어..");
return(null);
}
GameObject building = Instantiate(resource, position, Quaternion.identity) as GameObject;
BuildingBase objectBase = building.GetComponent <BuildingBase>();
objectBase.ObjectID = objID;
objectBase.buildingType = type;
buildingList.Add(objID, objectBase);
return(objectBase);
}
IEnumerator CreateGhost()
{
yield return(new WaitForSeconds(0.1f));
ghost = Instantiate(mobToCreate, CalculatePosition(Vector3.zero), Quaternion.identity);
ghost.IsGhost = true;
}
public void setSelected(BuildingBase entity)
{
this.clearSelected();
if (entity != null)
{
this.selected = entity;
this.selected.outlineHelper.setVisible("selected");
}
this.setUIVisible(this.selected != null);
// UI setup for specific buildings.
if (this.selected is BuildingQueuedProducerBase)
{
BuildingQueuedProducerBase producer = (BuildingQueuedProducerBase)this.selected;
int slots = producer.getQueueSize();
for (int i = 0; i < 3; i++)
{
this.icons[i].setVisible(i < slots);
}
}
else
{
for (int i = 0; i < this.icons.Length; i++)
{
this.icons[i].setVisible(false);
}
}
}
private void InstantiateNewProductionPopup(BuildingBase building, ProductionCycleResult production)
{
ProductionEffectPopup popup = Instantiate(effect, building.transform.position, effect.transform.rotation, transform);
popup.transform.localRotation = effect.transform.rotation;
popup.InitProductionResult(building, production);
}
public override void Enter(object extraData = null)
{
base.Enter(extraData);
var data = extraData as Dictionary <string, ObjectBase>;
if (data == null)
{
Debug.LogError("Carry는 Enter로 운반할 target과 targetBuilding을 Dictionary<string, ObjectBase> 형태로 넣어주어야 한다");
return;
}
targetObject = data["target"];
targetBuilding = data["targetBuilding"] as BuildingBase;
if (targetObject != null)
{
//이미 타겟오브젝트를 들고 있는 상태라면
if (targetObject.transform.parent == owner.transform)
{
owner.Move(targetBuilding.transform.position);
currentState = "goToDestinate";
}
else
{
owner.Move(targetObject.transform.position);
currentState = "goToObject";
}
}
isWorkOver = false;
}
public void SelectTile(TaskableBase tile)
{
DeselectTile();
selectedObject = tile;
selectedIcon.SetActive(true);
selectedIcon.transform.parent = selectedObject.transform;
selectedIcon.transform.position = selectedObject.transform.position;
BuildingBase buildingObject = tile.GetComponent <BuildingBase>();
WallBase wallObject = tile.GetComponent <WallBase>();
HaulableBase haulObject = tile.GetComponent <HaulableBase>();
if (buildingObject)
{
if (buildingObject.currentTask)
{
taskActionBarInstance = Instantiate(taskActionBarPrefab, transform);
taskActionBarInstance.Setup(buildingObject);
}
else
{
buildingActionBarInstance = Instantiate(buildingActionBarPrefab, transform);
buildingActionBarInstance.Setup(buildingObject);
FactoryBase factoryObject = buildingObject.GetComponent <FactoryBase>();
if (factoryObject)
{
factoryActionBarInstance = Instantiate(factoryActionBarPrefab, transform);
factoryActionBarInstance.Setup(factoryObject);
}
}
}
else if (wallObject)
{
if (wallObject.currentTask)
{
taskActionBarInstance = Instantiate(taskActionBarPrefab, transform);
taskActionBarInstance.Setup(wallObject);
}
else
{
wallActionBarInstance = Instantiate(wallActionBarPrefab, transform);
wallActionBarInstance.Setup(wallObject);
}
}
else if (haulObject)
{
if (haulObject.currentTask)
{
taskActionBarInstance = Instantiate(taskActionBarPrefab, transform);
taskActionBarInstance.Setup(haulObject);
}
else
{
haulableActionBarInstance = Instantiate(haulableActionBarPrefab, transform);
haulableActionBarInstance.Setup(haulObject);
}
}
}
private void InstantiateNewBuildingCostsPopup(BuildingBase building, ClimateBuildingsData data)
{
ProductionEffectPopup popup = Instantiate(effect, building.tilesStandingOn[0, 0].transform.position, effect.transform.rotation, transform);
popup.transform.localRotation = effect.transform.rotation;
popup.Init(building, data);
}
public void SaveSceneData()
{
SceneInfoBean sceneInfo = new SceneInfoBean();
sceneInfo.id = sceneId;
sceneInfo.valid = 1;
SceneDetailsBean sceneDetails = new SceneDetailsBean();
for (int i = 0; i < BuildingHandler.Instance.transform.childCount; i++)
{
Transform tfItem = BuildingHandler.Instance.transform.GetChild(i);
BuildingBase baseBuilding = tfItem.GetComponent <BuildingBase>();
if (baseBuilding == null)
{
continue;
}
SceneDetailsItemBean sceneDetailsItem = new SceneDetailsItemBean();
sceneDetailsItem.buildingId = baseBuilding.buildingInfo.id;
sceneDetailsItem.position = new Vector3Bean(tfItem.position);
sceneDetailsItem.size = new Vector3Bean(tfItem.localScale);
sceneDetailsItem.angle = new Vector3Bean(tfItem.eulerAngles);
sceneDetails.listBuildingData.Add(sceneDetailsItem);
}
sceneInfo.SetSceneDetilas(sceneDetails);
sceneInfoService.UpdateData(sceneInfo);
}
/// <summary>
/// Checks if the unit is next to the passed building.
/// </summary>
protected bool nextToBuilding(BuildingBase building)
{
Vector2 v = building.getFootprintSize();
Bounds b = new Bounds(building.getPos(), new Vector3(v.x + 1f, 4, v.y + 1f));
return(b.Intersects(this.unit.GetComponent <Collider>().bounds));
}
public void RequestCatchFish(BuildingBase pond)
{
jobs[JobType.CatchFishingInPond].Enqueue(new JobInfo()
{
targetBuilding = pond
});
}
public void FindTarget(MotionType fallBack = MotionType.move)
{
RaycastHit hit;
Vector3 castPos = TerrainGen.GetAsGridPosition(this.transform.position);
castPos.y += 1;
if (Physics.Raycast(castPos, Vector3.down, out hit, 3, buildingMask))
{
if (!hit.collider.transform.parent.name.Contains("Copse"))
{
BuildingBase hitTarget;
hitTarget = hit.collider.transform.GetComponentInParent <BuildingBase>();
if (hitTarget != null)
{
motionType = MotionType.attack;
attackTarget = hitTarget;
}
}
else
{
motionType = fallBack;
}
}
else
{
motionType = fallBack;
}
}
/// <summary>
/// Returns a random non major building, if any exists.
/// </summary>
/// <param name="stateHelper"></param>
/// <param name="playerIndex"></param>
/// <returns></returns>
private BuildingBase GetRandomOwnedNonMajorBuidling(StateHelper stateHelper, int?playerIndex = null)
{
GamePlayer p = stateHelper.Player.GetPlayer(playerIndex);
// Build a list of building the player owns and matches our filter.
List <int> buildingIndex = new List <int>();
for (int b = 0; b < stateHelper.BuildingRules.GetCountOfUniqueTypes(); b++)
{
BuildingBase building = stateHelper.BuildingRules[b];
if (p.OwnedBuildings[b] > 0)
{
if (building.GetEstablishmentColor() != EstablishmentColor.Landmark && building.GetEstablishmentColor() != EstablishmentColor.Purple)
{
buildingIndex.Add(b);
}
}
}
// Make sure there are buildings.
if (buildingIndex.Count == 0)
{
return(null);
}
// Now get a random int index into the build index array, and get the building.
return(stateHelper.BuildingRules[buildingIndex[m_random.RandomInt(0, buildingIndex.Count - 1)]]);
}
public void Run(UnitAction action)
{
if (action.target != null && action.target == m_action.target)
{
// continue action;
m_action.status = UnitAction.ActionStatus.Planned;
return;
}
else
{
// reserve a new cell for the interaction
/*if (m_action.interactionCell != action.interactionCell)
* {
* World.instance.ReleaseCell(m_controller.unit, m_action.interactionCell);
* World.instance.ReserveCell(m_controller.unit, action.interactionCell);
* }*/
m_action = action;
m_navigation.isStopped = false;
m_action.status = UnitAction.ActionStatus.Planned;
m_time = 0;
if (action.target)
{
building = action.target as BuildingBase;
unit = action.target as Unit;
resource = action.target as ResourceSource;
}
}
}
// Update is called once per frame
void Update()
{
Vector3 worldPoint = Camera.main.ScreenToWorldPoint(Input.mousePosition);
worldPoint = new Vector3(Mathf.Floor(worldPoint.x), Mathf.Floor(worldPoint.y), -1);
this.transform.position = worldPoint + new Vector3(0.5f, 0.5f, 0);
Vector3Int floorPosition = TilemapManager.instance.floorTilemap.WorldToCell(worldPoint);
GameObject floor = TilemapManager.instance.floorTilemap.GetInstantiatedObject(floorPosition);
Vector3Int wallPosition = TilemapManager.instance.wallTilemap.WorldToCell(worldPoint);
GameObject wall = TilemapManager.instance.wallTilemap.GetInstantiatedObject(wallPosition);
if (buildingType.CanBuildHere(floor, wall))
{
spriteRenderer.color = buildColor;
if (Input.GetMouseButtonDown(0))
{
TilemapManager.instance.wallTilemap.SetTile(wallPosition, buildingType.tileType);
BuildingBase newBuilding = TilemapManager.instance.wallTilemap.GetInstantiatedObject(wallPosition).GetComponent <BuildingBase>();
DestroySelf();
}
}
else
{
spriteRenderer.color = noBuildColor;
}
if (Input.GetMouseButtonDown(1))
{
DestroySelf();
}
}
private void InstantiateDemolishEffect(BuildingBase building)
{
BuildingDestroyEffect effect = Instantiate(destroyEffectPrefab);
effect.transform.position = building.transform.position;
effect.Init(building);
}
void Start()
{
building = GetComponent <BuildingBase>();
collider = GetComponent <Collider2D>();
collider.isTrigger = true;
Allow();
}
public void Init(BuildingBase building, ClimateBuildingsData data)
{
transform.position = new Vector3(building.transform.position.x, building.tilesStandingOn[0, 0].transform.position.y + spawnHeight, building.transform.position.z);
transform.SetAsFirstSibling();
CreatePopupItems(data);
StartCoroutine(Move());
StartCoroutine(WaitForFade());
}
public void InitProductionResult(BuildingBase building, ProductionCycleResult production)
{
transform.position = new Vector3(building.transform.position.x, building.transform.position.y + spawnHeight, building.transform.position.z);
transform.SetAsFirstSibling();
CreateOutputPopupItems(production);
StartCoroutine(Move());
StartCoroutine(WaitForFade());
}
public IEnumerator DeconstructBuilding(BuildingBase building)
{
while (building.buildAmount > 0)
{
building.AddConstruction(-buildSpeed);
yield return(new WaitForFixedUpdate());
}
}
public IEnumerator RepairBuilding(BuildingBase building)
{
while (building.life < building.lifeMax)
{
building.AddLife(buildSpeed);
yield return(new WaitForFixedUpdate());
}
}
private void Update()
{
if (Pause.isPaused())
{
return;
}
if (this.selected)
{
string s = this.selected.getHealth() + "/" + this.selected.getMaxHealth() + (this.selected.isConstructing() ? " (Building)" : string.Empty);
this.infoText.text = this.selected.getData().getName() + "\n" + s;
if (this.selected is BuildingQueuedProducerBase)
{
BuildingQueuedProducerBase producer = (BuildingQueuedProducerBase)this.selected;
float trainTime = 0;
int queueCount = producer.trainingQueue.Count;
for (int i = 0; i < 3; i++)
{
if (i < queueCount)
{
/*
* ed = producer.trainingQueue[i].getPrefab().GetComponent<UnitBase>().getData();
* if(i == 0) {
* trainTime = ed.getProductionTime();
* }
* this.icons[i].setText(ed.getUnitTypeName());
*/
}
else
{
this.icons[i].setText(null);
}
}
this.otherText.text = queueCount == 0 ? "Empty" : Mathf.Floor(trainTime - producer.getTrainingProgress()) + 1 + " Seconds";
}
else if (this.selected is IResourceHolder)
{
IResourceHolder holder = (IResourceHolder)this.selected;
int held = holder.getHeldResources();
int limit = holder.getHoldLimit();
string color = held >= limit ? "red" : "black";
this.otherText.text = "<color=" + color + ">Storage:\n" + held + "/" + limit + "</color>";
}
else
{
this.otherText.text = string.Empty;
}
}
else
{
this.setUIVisible(false);
this.selected = null; // Be sure to set selected at null if it's dead.
}
}
public override void clearSelected()
{
if (Util.isAlive(this.selected))
{
this.selected.outlineHelper.setInvisible("selected");
}
this.selected = null;
this.setUIVisible(false);
}
public bool CanBuild(BuildingBase building)
{
/* ActionCost cost = building.cost;
* return cost.food < this.food
* && cost.wood < this.wood
* && cost.gold < this.gold
* && cost.stone < this.stone;*/
return(true);
}
public void Setup(BuildingBase building)
{
this.building = building;
buildButton.onClick.AddListener(() => BuildAction());
repairButton.onClick.AddListener(() => RepairAction());
sellButton.onClick.AddListener(() => DeconstructAction());
RefreshUI();
}
