void Awake()
{
photonView = GetComponent <PhotonView>();
agent = GetComponent <Slime>().GetAgent();
gameManager = GameManager.Instance;
buildingUI = BuildingUI.Instance;
}
public MapView(Game game)
: base(game)
{
PlayerList players = ((XnaUITestGame)game).Model.GetScenario().GetGameWorld().GetPlayerList();
foreach (PlayerComponent player in players.GetChildren())
{
UnitList unitList = player.GetUnitList();
unitList.UnitAddedEvent += onUnitAdded;
unitList.UnitRemovedEvent += onUnitRemoved;
ZRTSCompositeViewUIFactory factory = ZRTSCompositeViewUIFactory.Instance;
foreach (UnitComponent unit in unitList.GetChildren())
{
UnitUI unitUI = factory.BuildUnitUI(unit);
unitUI.DrawBox = new Rectangle((int)(unit.PointLocation.X * cellDimension), (int)(unit.PointLocation.Y * cellDimension), unitUI.DrawBox.Width, unitUI.DrawBox.Height);
AddChild(unitUI);
componentToUI.Add(unit, unitUI);
unit.MovedEventHandlers += updateLocationOfUnit;
unit.HPChangedEventHandlers += killUnit;
}
BuildingList buildingList = player.BuildingList;
foreach (Building b in buildingList.GetChildren())
{
BuildingUI buildingUI = factory.BuildBuildingUI(b);
buildingUI.DrawBox = new Rectangle((int)b.PointLocation.X * cellDimension, (int)b.PointLocation.Y * cellDimension, buildingUI.DrawBox.Width, buildingUI.DrawBox.Height);
AddChild(buildingUI);
}
buildingList.BuildingAddedEventHandlers += this.onBuildingAdded;
}
leftButtonStrategy = new DrawSelectionBoxStrategy(this);
OnClick += moveSelectedUnits;
}
void Awake()
{
buildingUI = GetComponent <BuildingUI>();
buildingRevenue = GetComponent <BuildingRevenue>();
buildingExports = GetComponent <BuildingExports>();
sphereOfInfluence = GetComponent <SphereOfInfluence>();
}
/**
* <summary>
* Set health
* </summary>
*
* <param name="health">Health</param>
*
* <returns>
* void
* </returns>
*/
public void SetHealth(float health)
{
this.health = health;
BuildingUI buildingUI = this.UI.GetComponent <BuildingUI>();
buildingUI.SetHealth(health, this.maxHealth);
}
private void OnEnable()
{
_buildingUI = FindObjectOfType <BuildingUI>();
_buildingUI.SetEnabledValue(true);
_camera = Camera.main;
_charOwner = CharacterOwner.Instance;
canBuild = true;
}
/// <summary>
/// Trigger funciton in the event of a new building being added
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void onBuildingAdded(Object sender, BuildingAddedEventArgs e)
{
ZRTSCompositeViewUIFactory factory = ZRTSCompositeViewUIFactory.Instance;
BuildingUI buildingUI = factory.BuildBuildingUI(e.Building);
buildingUI.DrawBox = new Rectangle((int)e.Building.PointLocation.X * cellDimension, (int)e.Building.PointLocation.Y * cellDimension, buildingUI.DrawBox.Width, buildingUI.DrawBox.Height);
AddChild(buildingUI);
}
public void openBuildMenu()
{
buildingUI = canvas.GetComponent <BuildingUI>();
buildingUI.checkBought();
buildObject.SetActive(true);
openObjects.Add(buildObject);
setTask(true);
removeActionMenu();
}
void Awake()
{
_ui = GetComponent <BuildingUI>();
_state = State.Instantiated;
_ui.description.text = description;
// After the building was created start placeing
StartCoroutine(PlaceBuilding());
}
void CheckUIOBJ(GameObject hitObject)
{
BuildingUI buildUI = hitObject.GetComponent <BuildingUI>();
if (buildUI != null)
{
Debug.Log("Click Building UI!!!");
buildUI.StartCoroutine(buildUI.GetClicked(this));
}
}
/**
* <summary>
* Set max health
* </summary>
*
* <param name="maxHealth">maxHealth</param>
*
* <returns>
* void
* </returns>
*/
public void SetMaxHealth(float maxHealth)
{
float currentHealth = this.GetHealth();
this.maxHealth = maxHealth;
BuildingUI buildingUI = this.UI.GetComponent <BuildingUI>();
buildingUI.SetMaxHealth(currentHealth, maxHealth);
}
public static void SetupBuidingGui()
{
BuildingWindowGameObject = new GameObject("buildingWindowObject");
buildingPanel = (BuildingUI)BuildingWindowGameObject.AddComponent(typeof(BuildingUI));
buildingInfo = UIView.Find <UIPanel>("(Library) ZonedBuildingWorldInfoPanel");
if (buildingInfo == null)
{
DebugLog.LogToFileOnly("UIPanel not found (update broke the mod!): (Library) ZonedBuildingWorldInfoPanel\nAvailable panels are:\n");
}
buildingPanel.transform.parent = buildingInfo.transform;
buildingPanel.size = new Vector3(buildingInfo.size.x, buildingInfo.size.y / 2f);
buildingPanel.baseBuildingWindow = buildingInfo.gameObject.transform.GetComponentInChildren <ZonedBuildingWorldInfoPanel>();
buildingPanel.position = new Vector3(buildingInfo.size.x, 0);
buildingInfo.eventVisibilityChanged += buildingInfo_eventVisibilityChanged;
}
/**
* <summary>
* Select a given building
* </summary>
*
* <param name="building"></param>
*
* <returns>
* void
* </returns>
*/
public static void SelectBuilding(GameObject building)
{
// Unselect previous building
BuildingsManagerBehaviour.UnselectBuilding();
// Unselect units
if (UnitsManagerBehaviour.SelectedUnits != null)
{
UnitsManagerBehaviour.UnselectGameObjects();
}
// Unselect previous resource
if (ResourcesManagerBehaviour.SelectedResource != null)
{
ResourcesManagerBehaviour.UnselectResource();
}
BuildingBehaviour buildingBehaviour = building.GetComponent <BuildingBehaviour>();
buildingBehaviour.SetSelect(true);
// Show info component panel
Self.infoComponentPanel.SetActive(true);
Self.infoComponentPanel
.transform
.Find("Single")
.gameObject
.SetActive(true);
BuildingUI buildingUI = buildingBehaviour.GetUI()
.GetComponent <BuildingUI>();
InfoComponentPanelUI infoComponentPanelUI = Self.infoComponentPanel.GetComponent <InfoComponentPanelUI>();
infoComponentPanelUI.SetName(building.name);
infoComponentPanelUI.SetHealth(buildingBehaviour.GetHealth(), buildingBehaviour.GetMaxHealth());
infoComponentPanelUI.SetIcon(buildingUI.GetIcon());
// Show action component panel
Self.actionComponentPanel.SetActive(true);
// Set selected building
BuildingsManagerBehaviour.SelectedBuilding = building;
}
/**
* <summary>
* Refresh or update the selected building information
* </summary>
*
* <returns>
* void
* </returns>
*/
public static void UpdateSelectedBuildingInfo()
{
if (!BuildingsManagerBehaviour.SelectedBuilding)
{
return;
}
BuildingBehaviour buildingBehaviour = BuildingsManagerBehaviour.SelectedBuilding
.GetComponent <BuildingBehaviour>();
BuildingUI buildingUI = buildingBehaviour.GetUI()
.GetComponent <BuildingUI>();
InfoComponentPanelUI infoComponentPanelUI = Self.infoComponentPanel.GetComponent <InfoComponentPanelUI>();
infoComponentPanelUI.SetName(BuildingsManagerBehaviour.SelectedBuilding.name);
infoComponentPanelUI.SetHealth(buildingBehaviour.GetHealth(), buildingBehaviour.GetMaxHealth());
infoComponentPanelUI.SetIcon(buildingUI.GetIcon());
}
public void ShowBuildInterface()
{
int height = Screen.height / COUNT_BUILD_BUTTONS_IN_HEIGHT;
float widthPanelInPixels = Screen.width * WIDTH_PANEL_IN_NORMALIZED_PERCENT - INDENT_PANEL_X;
float indentButtonYNormalized = INDENT_BUTTON_Y_IN_PIXELS / Screen.height;
float gapButtonYNormalized = GAP_BUTTON_IN_PIXELS / Screen.width;
int countBuildingInPanel = (int)Mathf.Floor((widthPanelInPixels + GAP_BUTTON_IN_PIXELS - 2 * INDENT_PANEL_Y_IN_PIXELS) / (height + GAP_BUTTON_IN_PIXELS));
widthPanelInPixels = countBuildingInPanel * (GAP_BUTTON_IN_PIXELS + height) + 2 * INDENT_PANEL_Y_IN_PIXELS - GAP_BUTTON_IN_PIXELS;
RectTransform rt = buildingPrefab.GetComponent <RectTransform>();
rt.sizeDelta = new Vector2(height, height);
var buttonGameobject = buildingPrefab.transform.GetChild(0);
var buttonRect = buttonGameobject.GetComponent <RectTransform>();
buttonRect.sizeDelta = new Vector2(height, height);
float normalizedWidth = (float)height / Screen.width;
float normalizedHeight = (float)height / Screen.height;
buildingPool = BuildingPool.GetObjectPool(buildingPrefab, countBuildingInPanel);
var buildings = BuildingsList.GetBuildingDictionary();
int countBuilding = buildings.Count;
int countFilled;
Building[] buildingList = new Building[buildings.Keys.Count];
buildings.Keys.CopyTo(buildingList, 0);
if (page != 0)
{
if (buildings.Count / page >= countBuildingInPanel)
{
countFilled = countBuildingInPanel;
}
else
{
countFilled = buildings.Count - page * countBuildingInPanel;
}
}
else
{
countFilled = buildings.Count - page * countBuildingInPanel;
}
float normalizedIndentY = INDENT_PANEL_Y_IN_PIXELS / (float)Screen.height;
for (int i = 0; i < countBuildingInPanel; i++)
{
BuildingObject building = buildingPool.Pop();
Button button = building.instance.GetComponentInChildren <Button>();
BuildingUI buildingUI = building.instance.GetComponentInChildren <BuildingUI>();
// buildingUI.uiController = FindObjectOfType<UIOilController>();
var buttonGO = building.instance.transform.GetChild(0);
var buttonScript = buttonGO.GetComponent <Button>();
var colors = buttonScript.colors;
var tooltip = building.instance.GetComponentInChildren <Tooltip>();
if (countFilled > 0)
{
countFilled--;
buildingUI.building = buildingList[page * countBuildingInPanel + i];
GeneralBuilding generalBuilding;
buildings.TryGetValue(buildingUI.building, out generalBuilding);
buildingUI.generalBuilding = generalBuilding;
button.image.sprite = generalBuilding.GetSpriteIcon();
colors.normalColor = new Color(255, 255, 255, 255);
buttonScript.colors = colors;
button.onClick.AddListener(buildingUI.TaskOnClick);
tooltip.Enable();
tooltip.buiding = generalBuilding;
}
else
{
tooltip.Disable();
buildingUI.building = Building.none;
button.image.sprite = emptyIcon;
colors.normalColor = new Color(255, 255, 255, 255);
buttonScript.colors = colors;
}
var rectTransform = building.instance.GetComponent <RectTransform>();
float normalizedGap = GAP_BUTTON_IN_PIXELS / (float)Screen.width;
float normalizedIndentX = INDENT_PANEL_X_IN_PIXELS / (float)Screen.width;
rectTransform.anchorMax = new Vector2(INDENT_PANEL_X + normalizedIndentX + (normalizedWidth + normalizedGap) * i + normalizedWidth / 2,
INDENT_PANEL_Y + normalizedIndentY + normalizedHeight / 2);
rectTransform.anchorMin = rectTransform.anchorMax;
rectTransform.sizeDelta = new Vector2(height, height);
//rectTransform.position=new Vector3(0,0,0);
rectTransform.anchoredPosition = new Vector2(0, 0);
}
var backgroundRect = background.GetComponent <RectTransform>();
//backgroundRect.sizeDelta = new Vector2(widthPanelInPixels, height+50);
float widthPanelInNormalizedPercent = widthPanelInPixels / (float)Screen.width;
backgroundRect.anchorMax = new Vector2(INDENT_PANEL_X + widthPanelInNormalizedPercent, INDENT_PANEL_Y + normalizedHeight + 2 * normalizedIndentY);
backgroundRect.anchorMin = new Vector2(INDENT_PANEL_X, INDENT_PANEL_Y);
/* private const int COUNT_COPY_OBJECT_IN_POOLS = 30;
* [SerializeField]
* private GameObject[] obstacles;
* [SerializeField]
* float g;
* [SerializeField]
* Sprite backGround;
* private ObstaclePool[] obstaclePools;
*
* public IEnumerator GenerateObstacles()
* {
* if ((obstaclePools == null) || (obstaclePools.Length) < obstacles.Length)
* {
* obstaclePools = new ObstaclePool[obstacles.Length];
* }
* for (int i = 0; i < obstacles.Length; i++)
* {
* if (obstaclePools[i] == null)
* {
* obstaclePools[i] = ObstaclePool.GetObjectPool(obstacles[i], COUNT_COPY_OBJECT_IN_POOLS);
* }
* }
*
* while (Game.Instance.State == State.Game)
* {
* int nextObstacle = UnityEngine.Random.Range(0, obstacles.Length);
* Obstacle obstacle = obstacles[nextObstacle].GetComponent<Obstacle>();
* obstaclePools[nextObstacle].Pop(obstacle.StartPosition);
* yield return new WaitForSeconds(4f);
* }
* }*/
}
//make a sound effect for buying building, and not being able to buy building
void Start()
{
gameManager = GetComponent <GameManager>();
buildingUI = canvas.GetComponent <BuildingUI>();
}
public static void ProcessBuildingDataFinal(ushort buildingID, ref Building buildingData)
{
if (RealCityPrivateBuildingAI.preBuidlingId > buildingID)
{
RealCityPrivateBuildingAI.allOfficeHighTechWorkCountFinal = RealCityPrivateBuildingAI.allOfficeHighTechWorkCount;
RealCityPrivateBuildingAI.allOfficeLevel1WorkCountFinal = RealCityPrivateBuildingAI.allOfficeLevel1WorkCount;
RealCityPrivateBuildingAI.allOfficeLevel2WorkCountFinal = RealCityPrivateBuildingAI.allOfficeLevel2WorkCount;
RealCityPrivateBuildingAI.allOfficeLevel3WorkCountFinal = RealCityPrivateBuildingAI.allOfficeLevel3WorkCount;
RealCityPrivateBuildingAI.profitBuildingCountFinal = RealCityPrivateBuildingAI.profitBuildingCount;
BuildingData.commBuildingNumFinal = BuildingData.commBuildingNum;
BuildingData.commBuildingNum = 0;
RealCityPrivateBuildingAI.profitBuildingCount = 0;
RealCityPrivateBuildingAI.allOfficeLevel1WorkCount = 0;
RealCityPrivateBuildingAI.allOfficeLevel2WorkCount = 0;
RealCityPrivateBuildingAI.allOfficeLevel3WorkCount = 0;
RealCityPrivateBuildingAI.allOfficeHighTechWorkCount = 0;
}
RealCityPrivateBuildingAI.preBuidlingId = buildingID;
if (buildingData.Info.m_class.m_service == ItemClass.Service.Residential)
{
BuildingData.buildingMoney[buildingID] = 0;
}
float building_money = BuildingData.buildingMoney[buildingID];
if (buildingData.Info.m_class.m_service == ItemClass.Service.Industrial)
{
if (building_money < 0)
{
RealCityEconomyExtension.industrialLackMoneyCount++;
}
else
{
RealCityEconomyExtension.industrialEarnMoneyCount++;
}
}
if (building_money < 0)
{
BuildingData.buildingMoneyThreat[buildingID] = 1.0f;
}
switch (buildingData.Info.m_class.m_service)
{
case ItemClass.Service.Residential:
float familyMoney = GetResidentialBuildingAverageMoney(buildingData);
if (familyMoney < (MainDataStore.highWealth >> 1))
{
BuildingData.buildingMoneyThreat[buildingID] = 1.0f - familyMoney / MainDataStore.highWealth;
}
else
{
BuildingData.buildingMoneyThreat[buildingID] = (((MainDataStore.highWealth << 1) - (MainDataStore.highWealth >> 1)) - familyMoney) / (MainDataStore.highWealth << 1);
}
if (BuildingData.buildingMoneyThreat[buildingID] < 0)
{
BuildingData.buildingMoneyThreat[buildingID] = 0;
}
break;
case ItemClass.Service.Commercial:
case ItemClass.Service.Industrial:
case ItemClass.Service.Office:
float averageBuildingSalary = BuildingUI.CaculateEmployeeOutcome(buildingData, out _);
if (MainDataStore.citizenCount > 0.0)
{
float averageCitySalary = MainDataStore.citizenSalaryTotal / MainDataStore.citizenCount;
float salaryFactor = averageBuildingSalary / averageCitySalary;
if (salaryFactor > 3f)
{
salaryFactor = 3f;
}
else if (salaryFactor < 0.0f)
{
salaryFactor = 0.0f;
}
BuildingData.buildingMoneyThreat[buildingID] = (1.0f - salaryFactor / 3f);
}
else
{
BuildingData.buildingMoneyThreat[buildingID] = 1.0f;
}
break;
}
if (buildingData.Info.m_class.m_service == ItemClass.Service.Commercial)
{
//get all commercial building for resident.
if (buildingData.m_customBuffer2 > 2000)
{
BuildingData.commBuildingNum++;
BuildingData.commBuildingID[BuildingData.commBuildingNum] = buildingID;
}
if (BuildingData.buildingMoney[buildingID] < 0)
{
RealCityEconomyExtension.commercialLackMoneyCount++;
}
else
{
RealCityEconomyExtension.commercialEarnMoneyCount++;
}
}
if (buildingData.m_problems == Notification.Problem.None)
{
//mark no good
if ((buildingData.Info.m_class.m_service == ItemClass.Service.Commercial) && (RealCity.debugMode))
{
Notification.Problem problem = Notification.RemoveProblems(buildingData.m_problems, Notification.Problem.NoGoods);
if (buildingData.m_customBuffer2 < 500)
{
problem = Notification.AddProblems(problem, Notification.Problem.NoGoods | Notification.Problem.MajorProblem);
}
else if (buildingData.m_customBuffer2 < 1000)
{
problem = Notification.AddProblems(problem, Notification.Problem.NoGoods);
}
else
{
problem = Notification.Problem.None;
}
buildingData.m_problems = problem;
}
}
}
public void OnDestroy()
{
Instance = null;
}
void Awake()
{
Instance = this;
}
