public void Awake()
{
_buildingManager = BuildingManager.Instance;
_fightSimulator = FightSimulator.Instance;
state = Hero.State.Idle;
dying = false;
}
public override void OnCreated(IThreading threading)
{
_citizenManager = Singleton<CitizenManager>.instance;
_buildingManager = Singleton<BuildingManager>.instance;
base.OnCreated(threading);
}
void Start()
{
buildingManager = GetComponent<BuildingManager>();
hasPlaced = true;
Wohnwagen = 1;
Wohnhaus = 1;
Store = 1;
}
// Use this for initialization
void Start () {
weaponhandler = GameObject.FindGameObjectWithTag ("WeaponHandler").GetComponent<WeaponHandler> ();
itemAmount = gameObject.transform.GetChild (1).GetComponent<Text> ();
inventory = GameObject.FindGameObjectWithTag ("Inventory").GetComponent<Inventory>();
itemImage = gameObject.transform.GetChild (0).GetComponent<Image> ();
buildingManager = GameObject.FindGameObjectWithTag("Player").GetComponentInChildren<BuildingManager>();
stats = GameObject.FindGameObjectWithTag ("Player").GetComponent<PlayerStats> ();
}
public Player()
{
_soundManager = SoundManager.Instance;
_comboManager = ComboManager.Instance;
_inputController = InputController.Instance;
_gameManager = GameManager.Instance;
_buildingManager = BuildingManager.Instance;
_eventManager = EventManager.Instance;
heroManager = new HeroManager();
}
void Awake ()
{
if (Instance == null)
{
Instance = this;
}
else
{
Debug.LogError ("There is more than one BuildingManager in the scene!");
}
}
void Awake () {
if(_instance == null) {
_instance = this;
DontDestroyOnLoad(this);
}
else {
if(this != _instance) {
Destroy(this.gameObject);
}
}
}
void Start()
{
state = State.Idle;
_flyingOff = false;
lastHitTime = Time.time;
_poweredUp = false;
_isReadyToSend = false;
_isWalking = false;
_togglePose = false;
_spriteRenderer = GetComponentInChildren<SpriteRenderer>();
_buildingManager = BuildingManager.Instance;
_fightSimulator = FightSimulator.Instance;
}
public SeniorCitizenManager()
{
Logger.logInfo(LOG_SENIORS, "SeniorCitizenManager Created");
instance = this;
this.randomizer = new Randomizer((uint) 73);
this.citizenManager = Singleton<CitizenManager>.instance;
this.buildingManager = Singleton<BuildingManager>.instance;
// TODO: This array size is excessive but will allow for never worrying about resizing, should consider allowing for resizing instead
this.familiesWithSeniors = new uint[CitizenManager.MAX_UNIT_COUNT];
this.seniorCitizensBeingProcessed = new HashSet<uint>();
}
public static BuildingManager Instance()
{
if (_instance == null)
{
_instance = (BuildingManager)FindObjectOfType(typeof(BuildingManager));
if (_instance == null)
{
GameObject singleton = new GameObject();
_instance = singleton.AddComponent<BuildingManager>();
singleton.name = "BuildingManagerContainer" + typeof(BuildingManager).ToString();
DontDestroyOnLoad(singleton);
}
}
return _instance;
}
public StrategyManager()
{
Camera = new Camera2D(new Vector2(450, 450), Settings.ScreenResolution.X, Settings.ScreenResolution.Y);
CreatureManager = new CreatureManager();
GameField = new GameField(100, 100);
BuildingManager = new BuildingManager();
_guiManager = new GUIManager();
ConstructionMenu constructionMenu = new ConstructionMenu(1,new Size(64,64));
constructionMenu.ButtonSize = new Size(64, 64);
constructionMenu.Position = new Vector2(0, Settings.ScreenResolution.Y - 64);
constructionMenu.AddElement(SpriteType.SawmillMenuElement, "Sawmill", typeof(Sawmill));
_guiManager.Add(constructionMenu);
Castle castle = new Castle(new Point(3, 3));
castle.ResoursesStorage.AddResourse(Resourses.Wood, 50);
BuildingManager.Add(castle);
Sawmill sawmill = new Sawmill(new Point(10, 10));
BuildingManager.Add(sawmill);
for (int i = 0; i < 6; i++)
{
Creature creature = CreatureFabric.CreateHuman(this, CreatureRelation.Friendly);
creature.Position = new Vector2(RandomTool.RandInt(0, 200), RandomTool.RandInt(0, 100));
creature.SetBehaviour(new CarpenterBehaviour());
CreatureManager.Add(creature);
}
for (int i = 0; i < 40; i++)
{
Creature creature = CreatureFabric.CreateHuman(this, CreatureRelation.Friendly);
creature.Position = new Vector2(RandomTool.RandInt(0, 2000), RandomTool.RandInt(0, 2000));
creature.SetBehaviour(new WoodcutterBehavior());
CreatureManager.Add(creature);
}
}
void Awake()
{
renderManager = Singleton<RenderManager>.instance;
buildingManager = Singleton<BuildingManager>.instance;
var cameraController = FindObjectOfType<CameraController>();
mainCamera = cameraController.GetComponent<Camera>();
var mat = new Material(Shaders.buildingReplacementV2);
buildingWindowsReplacement = mat.shader;
buildingsGlowPP = new Material(Shaders.buildingGlowPPv5);
glowBlurPP = new Material(Shaders.glowBlurPP);
int w = Camera.main.pixelWidth/blurDownscale;
int h = Camera.main.pixelHeight/blurDownscale;
rt = new RenderTexture(w, h, 24, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
rtBlurH = new RenderTexture(w, h, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
rtBlurV = new RenderTexture(w, h, 0, RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
dummyGO = new GameObject();
dummyCamera = dummyGO.AddComponent<Camera>();
dummyCamera.enabled = false;
buildingsCullingMask = 1 << LayerMask.NameToLayer("Buildings");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Props");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Terrain");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Decoration");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Trees");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Vehicles");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Citizens");
occludersCullingMask |= 1 << LayerMask.NameToLayer("PowerLines");
occludersCullingMask |= 1 << LayerMask.NameToLayer("Road");
renderManagerLateUpdate = typeof(RenderManager).GetMethod("LateUpdate", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
}
public static void Postfix(uint citizenID, ref Citizen data)
{
BuildingManager instance = Singleton <BuildingManager> .instance;
ushort homeBuilding = data.m_homeBuilding;
uint homeId = data.GetContainingUnit(citizenID, instance.m_buildings.m_buffer[homeBuilding].m_citizenUnits, CitizenUnit.Flags.Home);
if (homeId != 0)
{
//Change wealth
if (CitizenUnitData.familyMoney[homeId] > MainDataStore.highWealth)
{
data.WealthLevel = Citizen.Wealth.High;
}
else if (CitizenUnitData.familyMoney[homeId] < MainDataStore.lowWealth)
{
data.WealthLevel = Citizen.Wealth.Low;
}
else
{
data.WealthLevel = Citizen.Wealth.Medium;
}
}
}
protected override bool StartPathFind(ushort vehicleID, ref Vehicle vehicleData)
{
if ((int)vehicleData.m_leadingVehicle == 0)
{
Vector3 startPos = (vehicleData.m_flags & Vehicle.Flags.Reversed) == (Vehicle.Flags) 0 ? (Vector3)vehicleData.m_targetPos0 : (Vector3)Singleton <VehicleManager> .instance.m_vehicles.m_buffer[(int)vehicleData.GetLastVehicle(vehicleID)].m_targetPos0;
BuildingManager instance = Singleton <BuildingManager> .instance;
NetManager netInstance = Singleton <NetManager> .instance;
if ((vehicleData.m_flags & Vehicle.Flags.GoingBack) != (Vehicle.Flags) 0)
{
if ((int)vehicleData.m_sourceBuilding != 0)
{
//begin mod
BuildingInfo info = instance.m_buildings.m_buffer[(int)vehicleData.m_sourceBuilding].Info;
Randomizer randomizer = new Randomizer((int)vehicleID);
Vector3 position;
Vector3 target;
info.m_buildingAI.CalculateUnspawnPosition(vehicleData.m_sourceBuilding, ref instance.m_buildings.m_buffer[(int)vehicleData.m_sourceBuilding], ref randomizer, this.m_info, out position, out target);
return(this.StartPathFind(vehicleID, ref vehicleData, startPos, position));
//end mod
}
}
else if ((int)vehicleData.m_targetBuilding < netInstance.m_nodes.m_buffer.Length && (vehicleData.m_flags & Vehicle.Flags.DummyTraffic) != (Vehicle.Flags) 0)
{
if ((int)vehicleData.m_targetBuilding != 0)
{
Vector3 endPos = instance.m_buildings.m_buffer[(int)vehicleData.m_targetBuilding].m_position;
return(this.StartPathFind(vehicleID, ref vehicleData, (Vector3)vehicleData.m_targetPos0, endPos));
}
}
else if ((int)vehicleData.m_targetBuilding < netInstance.m_nodes.m_buffer.Length && (int)vehicleData.m_targetBuilding != 0)
{
Vector3 endPos = netInstance.m_nodes.m_buffer[(int)vehicleData.m_targetBuilding].m_position;
return(this.StartPathFind(vehicleID, ref vehicleData, startPos, endPos));
}
}
return(false);
}
/*
* Private unmodified methods
*/
private void TryCollectCrime(ushort vehicleID, ref Vehicle vehicleData, ref Vehicle.Frame frameData)
{
if ((vehicleData.m_flags & (Vehicle.Flags.Underground | Vehicle.Flags.Transition)) == Vehicle.Flags.Underground)
{
return;
}
Vector3 position = frameData.m_position;
float num = position.x - 32f;
float num2 = position.z - 32f;
float num3 = position.x + 32f;
float num4 = position.z + 32f;
int num5 = Mathf.Max((int)((num - 72f) / 64f + 135f), 0);
int num6 = Mathf.Max((int)((num2 - 72f) / 64f + 135f), 0);
int num7 = Mathf.Min((int)((num3 + 72f) / 64f + 135f), 269);
int num8 = Mathf.Min((int)((num4 + 72f) / 64f + 135f), 269);
BuildingManager instance = Singleton <BuildingManager> .instance;
for (int i = num6; i <= num8; i++)
{
for (int j = num5; j <= num7; j++)
{
ushort num9 = instance.m_buildingGrid[i * 270 + j];
int num10 = 0;
while (num9 != 0)
{
this.TryCollectCrime(vehicleID, ref vehicleData, ref frameData, num9, ref instance.m_buildings.m_buffer[(int)num9]);
num9 = instance.m_buildings.m_buffer[(int)num9].m_nextGridBuilding;
if (++num10 >= 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
public static ushort FindNextCargoParent(ushort sourceBuilding, ItemClass.Service service, ItemClass.SubService subService)
{
BuildingManager instance = Singleton <BuildingManager> .instance;
VehicleManager instance2 = Singleton <VehicleManager> .instance;
ushort num = instance.m_buildings.m_buffer [(int)sourceBuilding].m_ownVehicles;
ushort result = 0;
int num2 = -1;
int num3 = 0;
while (num != 0)
{
if ((instance2.m_vehicles.m_buffer [(int)num].m_flags & Vehicle.Flags.WaitingCargo) != Vehicle.Flags.None)
{
VehicleInfo info = instance2.m_vehicles.m_buffer [(int)num].Info;
if (info.m_class.m_service == service && info.m_class.m_subService == subService)
{
int num4;
int b;
info.m_vehicleAI.GetSize(num, ref instance2.m_vehicles.m_buffer [(int)num], out num4, out b);
int num5 = Mathf.Max(num4 * 255 / Mathf.Max(1, b), (int)instance2.m_vehicles.m_buffer [(int)num].m_waitCounter);
if (num5 > num2)
{
result = num;
num2 = num5;
}
}
}
num = instance2.m_vehicles.m_buffer [(int)num].m_nextOwnVehicle;
if (++num3 >= 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
return(result);
}
public static void ProcessGarbageIncomeArriveAtTarget(ushort vehicleID, ref Vehicle data, int num)
{
BuildingManager instance = Singleton <BuildingManager> .instance;
Building building = instance.m_buildings.m_buffer[(int)data.m_sourceBuilding];
Building building1 = instance.m_buildings.m_buffer[(int)data.m_targetBuilding];
BuildingInfo info = instance.m_buildings.m_buffer[(int)data.m_targetBuilding].Info;
if ((data.m_flags & Vehicle.Flags.TransferToTarget) != (Vehicle.Flags) 0)
{
if (building.m_flags.IsFlagSet(Building.Flags.Untouchable))
{
// Garbage income is based on distance.
if ((data.m_flags & Vehicle.Flags.Importing) != (Vehicle.Flags) 0)
{
if (Loader.isRealCityRunning)
{
double x = instance.m_buildings.m_buffer[(int)data.m_targetBuilding].m_position.x - instance.m_buildings.m_buffer[(int)data.m_sourceBuilding].m_position.x;
double z = instance.m_buildings.m_buffer[(int)data.m_targetBuilding].m_position.z - instance.m_buildings.m_buffer[(int)data.m_sourceBuilding].m_position.z;
x = (x > 0) ? x : -x;
z = (z > 0) ? z : -z;
double distance = (x + z);
int money = (int)(num * (distance / 4000f));
Singleton <EconomyManager> .instance.AddPrivateIncome(money, ItemClass.Service.Garbage, ItemClass.SubService.None, ItemClass.Level.Level3, 115333);
if (Loader.isRealCityV10)
{
RealCityUtil.InitDelegate();
if (RealCityUtil.GetRealCityV10())
{
RealCityUtil.SetOutsideGovermentMoney(RealCityUtil.GetOutsideGovermentMoney() - money);
}
}
}
}
}
}
}
public void GetAJob(uint citizenIndex)
{
CitizenManager citizenManager = Singleton <CitizenManager> .instance;
if (citizenManager.m_citizens.m_buffer[citizenIndex].m_workBuilding == 0 && citizenManager.m_citizens.m_buffer[citizenIndex].m_homeBuilding != 0)
{
SimulationManager simulationManager = Singleton <SimulationManager> .instance;
BuildingManager buildingManager = Singleton <BuildingManager> .instance;
TransferManager transferManager = Singleton <TransferManager> .instance;
Vector3 position = buildingManager.m_buildings.m_buffer[citizenManager.m_citizens.m_buffer[citizenIndex].m_homeBuilding].m_position;
TransferManager.TransferOffer offer = default(TransferManager.TransferOffer);
offer.Priority = simulationManager.m_randomizer.Int32(8);
offer.Citizen = citizenIndex;
offer.Position = position;
offer.Amount = 1;
offer.Active = true;
switch (citizenManager.m_citizens.m_buffer[citizenIndex].EducationLevel)
{
case Citizen.Education.Uneducated:
transferManager.AddOutgoingOffer(TransferManager.TransferReason.Worker0, offer);
break;
case Citizen.Education.OneSchool:
transferManager.AddOutgoingOffer(TransferManager.TransferReason.Worker1, offer);
break;
case Citizen.Education.TwoSchools:
transferManager.AddOutgoingOffer(TransferManager.TransferReason.Worker2, offer);
break;
case Citizen.Education.ThreeSchools:
transferManager.AddOutgoingOffer(TransferManager.TransferReason.Worker3, offer);
break;
}
}
}
public static void AfterPopulateGroupData(BuildingManager __instance, int groupX, int groupZ, int layer, ref int vertexIndex, ref int triangleIndex, ref Vector3 groupPosition, RenderGroup.MeshData data, ref Vector3 min, ref Vector3 max, ref float maxRenderDistance, ref float maxInstanceDistance)
{
if (LoadingManager.instance.m_currentlyLoading)
{
return;
}
if (WriteTheSignsMod.Controller?.BuildingPropsSingleton == null)
{
return;
}
int num = groupX * 270 / 45;
int num2 = groupZ * 270 / 45;
int num3 = (groupX + 1) * 270 / 45 - 1;
int num4 = (groupZ + 1) * 270 / 45 - 1;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
int num5 = i * 270 + j;
ushort num6 = __instance.m_buildingGrid[num5];
int num7 = 0;
while (num6 != 0)
{
WriteTheSignsMod.Controller.BuildingPropsSingleton.PopulateGroupData(num6, layer, ref vertexIndex, ref triangleIndex, groupPosition, data, ref min, ref max, ref maxRenderDistance, ref maxInstanceDistance);
num6 = __instance.m_buildings.m_buffer[num6].m_nextGridBuilding;
if (++num7 >= 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
private static ushort FindLeisure(ref ResidentAI thisAI, uint citizenID, ref Citizen person, ushort buildingID)
{
ushort foundLeisure = 0;
if ((person.m_instance != 0 || NewResidentAI.DoRandomMove(thisAI)))
{
BuildingManager _buildingManager = Singleton <BuildingManager> .instance;
SimulationManager _simulationManager = Singleton <SimulationManager> .instance;
Building _currentBuilding = _buildingManager.m_buildings.m_buffer[buildingID];
foundLeisure = _buildingManager.FindBuilding(_currentBuilding.m_position, 1000f, ItemClass.Service.Commercial, ItemClass.SubService.CommercialLeisure, Building.Flags.Created | Building.Flags.Active, Building.Flags.Deleted);
if (foundLeisure != 0)
{
if (_simulationManager.m_randomizer.Int32(0, 10) > 2)
{
thisAI.StartMoving(citizenID, ref person, buildingID, foundLeisure);
person.SetVisitplace(citizenID, foundLeisure, 0U);
person.m_visitBuilding = foundLeisure;
LoggingWrapper.Log("Citizen " + citizenID + " found leisure.");
}
else
{
LoggingWrapper.Log("Citizen " + citizenID + " found leisure, but chose not to bother.");
NewResidentAI.FindVisitPlace(thisAI, citizenID, buildingID, NewResidentAI.GetEntertainmentReason(thisAI));
}
}
else
{
LoggingWrapper.Log("Citizen " + citizenID + " couldn't find leisure.");
NewResidentAI.FindVisitPlace(thisAI, citizenID, buildingID, NewResidentAI.GetEntertainmentReason(thisAI));
}
}
return(foundLeisure);
}
/// <summary>
/// Saves the objects.
/// </summary>
public void SaveObjects()
{
try
{
Configuration config = new Configuration(Configuration.ItemTypes.Objects, Configuration.AssetTypes.Buildings, null);
BuildingManager buildingManager = Singleton <BuildingManager> .instance;
Building[] buildings = buildingManager.m_buildings.m_buffer;
for (ushort id = 0; id < buildings.Length; id++)
{
if (buildings[id].Info != null && (buildings[id].m_flags & Building.Flags.Created) != Building.Flags.None)
{
config.Add(this.NewItem(buildingManager, config, "Object", id, buildings[id].Info));
}
}
config.Save();
}
catch (Exception ex)
{
Log.Error(this, "SaveObjects", ex);
}
}
public void PickUpPassenger(Building fromBuilding) //Hides all requests from screen, spawns taxi and passenger relative to the fromBuilding's position
{
for (int i = 0; i < currentlyActiveRequests.Count; i++)
{
if (currentlyActiveRequests[i] == fromBuilding)
{
currentlyActiveRequests[i].buildingSelected = true;
_originBuilding = currentlyActiveRequests[i];
_destinationBuilding = BuildingManager.GetBuildingById(currentlyActiveRequests[i].buildingIdToDriveTowards);
}
//Hide all taxi request indicators
currentlyActiveRequests[i].requestIndicatorInstance.SetActive(false);
}
//Spawn taxi and passenger
_taxiInstance = fromBuilding.referencedStreet.PlaceVehicle(taxiPrefab, _originBuilding.transform.position);
_taxiInstance.GetComponent <Taxi>().callingPassenger = true;
_passengerInstance = Instantiate(passengerPrefab, _originBuilding.pedestrianSpawnPosition.position, _originBuilding.pedestrianSpawnPosition.rotation).GetComponent <Passenger>();
isSelectingBuilding = true;
}
public static void CargoTruckAIArriveAtTargetForRealGasStationPost(ref Vehicle vehicleData)
{
BuildingManager instance = Singleton <BuildingManager> .instance;
if (vehicleData.m_targetBuilding != 0)
{
Building buildingData = instance.m_buildings.m_buffer[vehicleData.m_targetBuilding];
if (!(buildingData.Info.m_buildingAI is OutsideConnectionAI))
{
if (GasStationAI.IsGasBuilding(vehicleData.m_targetBuilding) == true)
{
switch ((TransferManager.TransferReason)vehicleData.m_transferType)
{
case TransferManager.TransferReason.Petrol:
if (MainDataStore.petrolBuffer[vehicleData.m_targetBuilding] <= 57000)
{
MainDataStore.petrolBuffer[vehicleData.m_targetBuilding] += vehicleData.m_transferSize;
}
if (Loader.isRealCityRunning)
{
RealCityUtil.InitDelegate();
float productionValue = vehicleData.m_transferSize * RealCityUtil.GetResourcePrice((TransferManager.TransferReason)vehicleData.m_transferType);
Singleton <EconomyManager> .instance.FetchResource(EconomyManager.Resource.ResourcePrice, (int)productionValue, ItemClass.Service.PlayerIndustry, ItemClass.SubService.PlayerIndustryOil, ItemClass.Level.Level1);
}
vehicleData.m_transferSize = 0;
break;
default:
DebugLog.LogToFileOnly("Error: Find a import trade m_transferType = " + vehicleData.m_transferType.ToString()); break;
}
}
}
}
}
void Awake()
{
var buildingManagerTransform = Instantiate(buildingManagerPrefab) as Transform;
BuildingManager buildingManager = buildingManagerTransform.GetComponent <BuildingManager>();
if (buildingManager != null)
{
buildingManager.init(this);
buildingManager.transform.SetParent(this.transform);
this.buildingManager = buildingManager;
}
var resourceManagerTransform = Instantiate(resourceManagerPrefab) as Transform;
ResourceManager resourceManager = resourceManagerTransform.GetComponent <ResourceManager>();
if (resourceManager != null)
{
resourceManager.init(this);
resourceManager.transform.SetParent(this.transform);
this.resourceManager = resourceManager;
}
displayPopup("C'est parti !", 3);
}
private void OnMouseUp()
{
if (ScoreManager.StillPlaying() && upgradeCost > 0)
{
BuildingManager bm = GameObject.FindObjectOfType <BuildingManager>();
bm.SelectInstance(this);
switch (id)
{
case 0:
GetComponent <Skeleton>().RangeGO().SetActive(true);
//Debug.Log("set active");
break;
case 2:
GetComponent <Witch>().RangeGO().SetActive(true);
break;
case 5:
GetComponent <Skeleton>().RangeGO().SetActive(true);
break;
}
}
}
/**
* Formats the allows/required identifiers to be nice strings, coloured correctly.
* Returns the identifiers.
*/
private string FormatIds(List <string> allowIds, bool redIfNotPresent)
{
BuildingManager manager = BuildingManager.GetInstance();
string result = "";
foreach (string id in allowIds)
{
if (redIfNotPresent && !manager.PlayerHasBuilding(id))
{
result += "[ff0000]";
}
else
{
result += "[000000]";
}
BuildingTypeData type = manager.GetBuildingTypeData(id);
if (type != null)
{
result += manager.GetBuildingTypeData(id).name + ", ";
}
else
{
Debug.LogWarning("No building type data found for id:" + id);
result += id + ", ";
}
}
if (result.Length > 2)
{
result = result.Substring(0, result.Length - 2);
}
else
{
return("Nothing");
}
return(result);
}
// Update is called once per frame
void Update()
{
BuildingManager bm = GameObject.Find("_Scripts_").GetComponent <BuildingManager>();
if (TowerPrefab == null)
{
if (healthBar != null)
{
healthBar.fillAmount = KinectButton.CDtTime / KinectButton.CDcTime;
Debug.Log(healthBar.fillAmount);
}
}
else
{
if (bm != null)
{
if (bm.selectedTower == TowerPrefab)
{
if (healthBar != null)
{
healthBar.fillAmount = 1;
Debug.Log(healthBar.fillAmount);
}
}
else
{
if (healthBar != null)
{
healthBar.fillAmount = KinectButton.CDtTime / KinectButton.CDcTime;
Debug.Log(healthBar.fillAmount);
}
}
}
}
}
public override void OnAfterSimulationFrame()
{
base.OnAfterSimulationFrame();
if (Loader.CurrentLoadMode == LoadMode.LoadGame || Loader.CurrentLoadMode == LoadMode.NewGame)
{
uint currentFrameIndex = Singleton <SimulationManager> .instance.m_currentFrameIndex;
int num4 = (int)(currentFrameIndex & 255u);
if (RealConstruction.IsEnabled)
{
BuildingManager instance = Singleton <BuildingManager> .instance;
if (num4 == 255)
{
PlayerBuildingUI.refeshOnce = true;
UniqueFactoryUI.refeshOnce = true;
UniqueFactoryButton.refeshOnce = true;
WarehouseButton.refeshOnce = true;
WareHouseUI.refeshOnce = true;
PlayerBuildingButton.refeshOnce = true;
}
//CustomSimulationStepImpl for 124 125 TransferReason
CustomTransferManager.CustomSimulationStepImpl();
}
}
}
public override void SimulationStep(ushort eventID, ref EventData data)
{
//begin mod
var crawlerVehicle = Configuration.Get(eventID).Crawler;
var rocketVehicle = Configuration.Get(eventID).Rocket;
//end mod
VehicleManager instance1 = Singleton <VehicleManager> .instance;
BuildingManager instance2 = Singleton <BuildingManager> .instance;
EventManager instance3 = Singleton <EventManager> .instance;
ushort vehicleID1;
ushort vehicleID2;
this.FindVehicles(eventID, ref data, out vehicleID1, out vehicleID2);
bool flag1 = false;
if ((data.m_flags & (EventData.Flags.Active | EventData.Flags.Expired | EventData.Flags.Completed | EventData.Flags.Disorganizing | EventData.Flags.Cancelled)) == EventData.Flags.None)
{
if ((data.m_flags & EventData.Flags.Ready) == EventData.Flags.None && this.m_resourceConsumption != 0)
{
int num1 = (int)data.m_popularityDelta * 10;
int num2 = Mathf.Clamp(num1 / this.m_resourceConsumption, 0, 256);
data.m_startFrame += (uint)(256 - num2);
data.m_expireFrame += (uint)(256 - num2);
int num3 = num1 - num2 * this.m_resourceConsumption;
data.m_popularityDelta = (short)Mathf.Clamp(num3 / 10, 0, (int)short.MaxValue);
int num4 = 0;
uint currentFrameIndex = Singleton <SimulationManager> .instance.m_currentFrameIndex;
if (data.m_startFrame > currentFrameIndex)
{
num4 = ((int)data.m_startFrame - (int)currentFrameIndex) * this.m_resourceConsumption;
}
if ((int)data.m_building != 0 && num4 > num3)
{
int num5 = 100000;
ushort vehicleID3 = instance2.m_buildings.m_buffer[(int)data.m_building].m_guestVehicles;
int num6 = 0;
while ((int)vehicleID3 != 0)
{
switch ((TransferManager.TransferReason)instance1.m_vehicles.m_buffer[(int)vehicleID3].m_transferType)
{
case TransferManager.TransferReason.Coal:
case TransferManager.TransferReason.Petrol:
int size;
int max;
instance1.m_vehicles.m_buffer[(int)vehicleID3].Info.m_vehicleAI.GetSize(vehicleID3, ref instance1.m_vehicles.m_buffer[(int)vehicleID3], out size, out max);
num3 += Mathf.Min(size, max);
break;
}
vehicleID3 = instance1.m_vehicles.m_buffer[(int)vehicleID3].m_nextGuestVehicle;
if (++num6 > 16384)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
if (num3 <= num5 - 8000)
{
Singleton <TransferManager> .instance.AddIncomingOffer((data.m_flags & EventData.Flags.Preparing) == EventData.Flags.None?TransferManager.TransferReason.Coal : TransferManager.TransferReason.Petrol, new TransferManager.TransferOffer()
{
Priority = Mathf.Max(1, (num5 - num3) * 8 / num5),
Building = data.m_building,
Position = instance2.m_buildings.m_buffer[(int)data.m_building].m_position,
Amount = 1,
Active = false
});
}
if (num3 < 16000)
{
flag1 = true;
}
}
}
if ((data.m_flags & (EventData.Flags.Preparing | EventData.Flags.Ready)) != EventData.Flags.None && (int)data.m_building != 0)
{
if ((int)vehicleID1 == 0 && crawlerVehicle != null)
{
Vector3 position = instance2.m_buildings.m_buffer[(int)data.m_building].CalculatePosition(this.m_rocketSpawnPosition);
if (instance1.CreateVehicle(out vehicleID1, ref Singleton <SimulationManager> .instance.m_randomizer, crawlerVehicle, position, TransferManager.TransferReason.None, false, false))
{
crawlerVehicle.m_vehicleAI.SetSource(vehicleID1, ref instance1.m_vehicles.m_buffer[(int)vehicleID1], data.m_building);
crawlerVehicle.m_vehicleAI.SetTarget(vehicleID1, ref instance1.m_vehicles.m_buffer[(int)vehicleID1], data.m_building);
}
}
if ((int)vehicleID1 != 0 && (int)vehicleID2 == 0 && rocketVehicle != null)
{
Vector3 position = instance2.m_buildings.m_buffer[(int)data.m_building].CalculatePosition(this.m_rocketSpawnPosition);
if (instance1.CreateVehicle(out vehicleID2, ref Singleton <SimulationManager> .instance.m_randomizer, rocketVehicle, position, TransferManager.TransferReason.None, false, false))
{
rocketVehicle.m_vehicleAI.SetSource(vehicleID2, ref instance1.m_vehicles.m_buffer[(int)vehicleID2], data.m_building);
rocketVehicle.m_vehicleAI.SetTarget(vehicleID2, ref instance1.m_vehicles.m_buffer[(int)vehicleID2], data.m_building);
ushort lastVehicle = instance1.m_vehicles.m_buffer[(int)vehicleID1].GetLastVehicle(vehicleID1);
if ((int)lastVehicle != 0)
{
instance1.m_vehicles.m_buffer[(int)vehicleID2].m_leadingVehicle = lastVehicle;
instance1.m_vehicles.m_buffer[(int)lastVehicle].m_trailingVehicle = vehicleID2;
}
}
}
}
}
if ((int)data.m_building != 0)
{
ushort num = instance2.m_buildings.m_buffer[(int)data.m_building].m_eventIndex;
if ((int)num == (int)eventID)
{
Notification.Problem problems = instance2.m_buildings.m_buffer[(int)data.m_building].m_problems;
Notification.Problem problem = Notification.RemoveProblems(problems, Notification.Problem.NoResources);
if (flag1)
{
instance2.m_buildings.m_buffer[(int)data.m_building].m_incomingProblemTimer = (byte)Mathf.Min((int)byte.MaxValue, (int)instance2.m_buildings.m_buffer[(int)data.m_building].m_incomingProblemTimer + 1);
if ((int)instance2.m_buildings.m_buffer[(int)data.m_building].m_incomingProblemTimer >= 4)
{
problem = Notification.AddProblems(problem, Notification.Problem.NoResources);
}
}
else
{
instance2.m_buildings.m_buffer[(int)data.m_building].m_incomingProblemTimer = (byte)0;
}
if (problem != problems)
{
instance2.m_buildings.m_buffer[(int)data.m_building].m_problems = problem;
Singleton <BuildingManager> .instance.UpdateNotifications(data.m_building, problems, problem);
}
GuideController properties = Singleton <GuideManager> .instance.m_properties;
if (properties != null)
{
Singleton <BuildingManager> .instance.m_rocketLaunchSite.Activate(properties.m_rocketLaunchSite, data.m_building);
}
}
if ((int)num != 0 && (instance3.m_events.m_buffer[(int)num].m_flags & (EventData.Flags.Preparing | EventData.Flags.Active | EventData.Flags.Completed | EventData.Flags.Cancelled | EventData.Flags.Ready)) == EventData.Flags.None)
{
num = instance3.m_events.m_buffer[(int)num].m_nextBuildingEvent;
}
bool flag2 = false;
if ((int)vehicleID1 != 0 && crawlerVehicle != null)
{
Vector3 position = instance2.m_buildings.m_buffer[(int)data.m_building].CalculatePosition(this.m_doorPosition);
Vector3 lastFramePosition = instance1.m_vehicles.m_buffer[(int)vehicleID1].GetLastFramePosition();
Vector3 targetPos0 = (Vector3)instance1.m_vehicles.m_buffer[(int)vehicleID1].m_targetPos0;
Vector3 b = lastFramePosition + Vector3.ClampMagnitude(targetPos0 - lastFramePosition, crawlerVehicle.m_maxSpeed * 16f);
flag2 = (double)Vector3.Distance(position, b) < 40.0;
}
if (flag2)
{
if ((data.m_flags & EventData.Flags.Loading) == EventData.Flags.None)
{
data.m_flags |= EventData.Flags.Loading;
if (this.m_doorOpenEffect != null && (int)num == (int)eventID)
{
InstanceID instance4 = new InstanceID();
instance4.Event = eventID;
EffectInfo.SpawnArea spawnArea = new EffectInfo.SpawnArea(Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)data.m_building].CalculatePosition(this.m_doorPosition), Vector3.up, 10f);
Singleton <EffectManager> .instance.DispatchEffect(this.m_doorOpenEffect, instance4, spawnArea, Vector3.zero, 0.0f, 1f, Singleton <AudioManager> .instance.DefaultGroup);
}
}
}
else if ((data.m_flags & EventData.Flags.Loading) != EventData.Flags.None)
{
data.m_flags &= ~EventData.Flags.Loading;
if (this.m_doorCloseEffect != null && (int)num == (int)eventID)
{
InstanceID instance4 = new InstanceID();
instance4.Event = eventID;
EffectInfo.SpawnArea spawnArea = new EffectInfo.SpawnArea(Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)data.m_building].CalculatePosition(this.m_doorPosition), Vector3.up, 10f);
Singleton <EffectManager> .instance.DispatchEffect(this.m_doorCloseEffect, instance4, spawnArea, Vector3.zero, 0.0f, 1f, Singleton <AudioManager> .instance.DefaultGroup);
}
}
}
base.SimulationStep(eventID, ref data);
}
void Awake()
{
instance = this;
worker = GetComponent <BuildingWorker> ();
playerMoney = GetComponent <PlayerConfig>().money;
}
public bool TryBuild(BuildingType type, Tile leftDownCorner, UnitBase builder) {
switch (type) {
case BuildingType.House:
var go = (GameObject)Instantiate(Resources.Load("HouseBuilding"));
var bm = go.GetComponent<BuildingManager>();
bm.Data = new BuildingData();
bm.Data.Size = new Vector2(2, 2);
bm.Data.State = BuildingState.BeingBuilt;
bm.builder = builder;
bm.BuildEndCallback = MakeUnitActive;
MakeUnitBusy(builder);
currentBuildingPrototype = bm;
MakeTilesBlocked(leftDownCorner,2,2);
go.transform.localPosition = new Vector3(leftDownCorner.center.x + (Grid.tileSize/2f)
, leftDownCorner.center.y, leftDownCorner.center.z + (Grid.tileSize/2f));
break;
default:
return false;
}
return false;
}
public void EnterBuildingMode() {
UnselectAllUnits();
Situation = GameSituation.Building;
var go = (GameObject)Instantiate(Resources.Load("TownHallBuilding"));
var bm = go.GetComponent<BuildingManager>();
bm.Data = new BuildingData();
bm.Data.Size = new Vector2(5, 5);
bm.Data.State = BuildingState.Prototype;
currentBuildingPrototype = bm;
}
private void Awake()
{
Instance = this;
buildingTypeList = Resources.Load <BuildingTypeListSO>(typeof(BuildingTypeListSO).Name);
}
public void SetBM(BuildingManager BM)
{
buildingmanager = BM;
}
/**
* Initializes BuildingManager as a singleton
*
* Initializes fields
*/
public override void Start()
{
if (buildingManager == null)
{
DontDestroyOnLoad(gameObject);
buildingManager = this;
}
else if (buildingManager != this)
{
Destroy(gameObject);
}
alreadyPlacedDownBuildings = new List<string>();
buildings = new GameObject();
buildings.name = "Buildings";
buildingTypeDict = new Dictionary<string, Building>();
existingBuildingDict = new Dictionary<Tuple, Building>();
}
// Use this for initialization
void Start()
{
bm = GameObject.FindObjectOfType<BuildingManager>();
tileAbove = GameObject.Find("Tile: " + (gameObject.transform.position.x + 1) + "_" + gameObject.transform.position.z);
mr = this.gameObject.GetComponent<MeshRenderer>();
}
public void SetManager(BuildingManager man)
{
this.manager = man;
}
private void Update()
{
if (!this._initialized)
{
this._cityServiceWorldInfoPanel = GameObject.Find("(Library) CityServiceWorldInfoPanel").GetComponent <CityServiceWorldInfoPanel>();
if (!((UnityEngine.Object) this._cityServiceWorldInfoPanel != (UnityEngine.Object)null))
{
return;
}
this.CreateStopsPanel();
this._initialized = true;
}
else
{
if (!this._initialized || !this._cityServiceWorldInfoPanel.component.isVisible)
{
return;
}
BuildingManager instance1 = Singleton <BuildingManager> .instance;
ushort building = Utils.GetPrivate <InstanceID>((object)this._cityServiceWorldInfoPanel, "m_InstanceID").Building;
ItemClass.SubService subService = instance1.m_buildings.m_buffer[(int)building].Info.GetSubService();
switch (subService)
{
case ItemClass.SubService.PublicTransportBus:
case ItemClass.SubService.PublicTransportMetro:
case ItemClass.SubService.PublicTransportTrain:
case ItemClass.SubService.PublicTransportShip:
case ItemClass.SubService.PublicTransportPlane:
this._vehicleListBox.Hide();
this._stopsListBox.Show();
ushort[] numArray = PanelExtenderCityService.GetStationStops(building);
BuildingInfo.SubInfo[] subBuildings = instance1.m_buildings.m_buffer[(int)building].Info.m_subBuildings;
if (subBuildings != null && subBuildings.Length != 0)
{
Vector3 position = instance1.m_buildings.m_buffer[(int)building].m_position;
building = instance1.FindBuilding(position, 100f, ItemClass.Service.PublicTransport, ItemClass.SubService.None, Building.Flags.Untouchable, Building.Flags.None);
if ((int)building != 0)
{
ushort[] stationStops = PanelExtenderCityService.GetStationStops(building);
if (stationStops.Length != 0)
{
numArray = ((IEnumerable <ushort>)numArray).Concat <ushort>((IEnumerable <ushort>)stationStops).ToArray <ushort>();
}
}
}
int length = numArray.Length;
if (length > 0)
{
this._titleLabel.text = Localization.Get("CITY_SERVICE_PANEL_TITLE_STATION_STOPS");
this._listBoxPanel.relativePosition = new Vector3(this._listBoxPanel.parent.width + 1f, 0.0f);
this._listBoxPanel.Show();
if ((int)this._cachedBuildingID != (int)building || this._cachedStopCount != length)
{
this._stopsListBox.ClearItems();
for (int index = 0; index < length; ++index)
{
this._stopsListBox.AddItem(numArray[index], -1);
}
}
}
else
{
this._listBoxPanel.Hide();
}
this._cachedStopCount = length;
break;
case ItemClass.SubService.PublicTransportTaxi:
this._vehicleListBox.Show();
this._stopsListBox.Hide();
UIPanel uiPanel = this._cityServiceWorldInfoPanel.Find <UIPanel>("SvsVehicleTypes");
if ((UnityEngine.Object)uiPanel != (UnityEngine.Object)null)
{
this._listBoxPanel.relativePosition = new Vector3((float)((double)this._listBoxPanel.parent.width + (double)uiPanel.width + 2.0), 0.0f);
}
List <ushort> depotVehicles = PanelExtenderCityService.GetDepotVehicles(building);
int count = depotVehicles.Count;
if (count > 0)
{
this._titleLabel.text = Localization.Get("CITY_SERVICE_PANEL_TITLE_DEPOT_VEHICLES");
this._listBoxPanel.Show();
if ((int)this._cachedBuildingID != (int)building || this._cachedVehicleCount != count)
{
this._vehicleListBox.ClearItems();
PrefabData[] prefabs = VehiclePrefabs.instance.GetPrefabs(subService);
VehicleManager instance2 = Singleton <VehicleManager> .instance;
foreach (ushort vehicleID in depotVehicles)
{
VehicleInfo info = instance2.m_vehicles.m_buffer[(int)vehicleID].Info;
for (int index = 0; index < prefabs.Length; ++index)
{
PrefabData data = prefabs[index];
if (info.name == data.ObjectName)
{
this._vehicleListBox.AddItem(data, vehicleID);
break;
}
}
}
}
}
else
{
this._listBoxPanel.Hide();
}
this._cachedVehicleCount = count;
break;
default:
this._listBoxPanel.Hide();
break;
}
this._cachedBuildingID = building;
}
}
public PlayerUpgradeBuildingState(GameManager gameManager, BuildingManager buildingManager, IResourceManager resourceManager)
: base(gameManager, buildingManager, resourceManager)
{
}
// public void PlaceFeedbackText(int i)
// {
// Transform tileTransform = tiles_[i].transform;
// Canvas canvas = GameObject.Find("Canvas");
// Text feedback = (Text)Instantiate(textPrefab, tileTransform.position, tileTransform.rotation);
// feedback.transform.SetParent(canvas.transform, false);
// feedback.fontSize = 14;
// feedback.text = "asdlfkjsdfkj";
// }
public void Update()
{
// The mouse position is in screen pixel coordinates, and we need to
// center it relative to the world.
Vector3 mouse_in_world = MouseInWorld();
BuildingManager active = GetActiveTile(mouse_in_world.x, mouse_in_world.y);
if (activeTile != null)
{
activeTile.Highlight(false); // Turn off previously active tile.
}
activeTile = active;
activeTile.Highlight(true);
// if the mouse button is held down, create a disaster in the correct section
if (Input.GetMouseButtonDown(0))
{
if (selectedDisaster == DisasterType.Meteor)
{
SceneManager.LoadScene("winScene");
}
int activeI = GetActiveIndex(mouse_in_world.x, mouse_in_world.y);
Vector2 mouse_in_world_2d = new Vector2(mouse_in_world.x, mouse_in_world.y);
float clickRadius = mouse_in_world_2d.magnitude;
if (selectedDisaster != DisasterType.NotSelected &&
clickRadius >= earthRadius &&
clickRadius <= 2 * earthRadius)
{
PlaceDisaster(activeI);
Type SelectedDisasterT = DisasterTypeToClass[selectedDisaster];
Disaster instance = (Disaster)Activator.CreateInstance(SelectedDisasterT);
// Start the disaster cooldown.
if (enableCooldown)
{
selectedButton.DisableForCountdown(instance.cooldownTime);
selectedDisaster = DisasterType.NotSelected;
}
bool destroyed = active.Attack(instance);
if (destroyed)
{
XPSystem system = xpSlider.GetComponent <XPSystem>();
float xpLevel = system.EarnXP(active.building.xpGain);
simulator.KillPopulation(active.building.populationPct);
simulator.KillTechnology(active.building.technologyPct);
activeTile.Destroy(instance);
ToolbarManager tManager = toolbar.GetComponent <ToolbarManager>();
if (xpLevel >= 1.0f)
{
tManager.UnlockButton(4);
}
else if (xpLevel >= 0.60f)
{
tManager.UnlockButton(3);
}
else if (xpLevel >= 0.25f)
{
tManager.UnlockButton(2);
}
else if (xpLevel >= 0.1f)
{
tManager.UnlockButton(1);
}
}
}
}
}
void Start()
{
tileMap = GameObject.FindGameObjectWithTag("TileMap");
createTileMap = tileMap.GetComponent <CreateTileMap>();
buildingManager = GameObject.FindGameObjectWithTag("BuildingManager").GetComponent <BuildingManager>();
}
/// <summary>
/// Start this instance.
/// </summary>
void Start()
{
AndroidJNI.AttachCurrentThread();
//gpsActivityJavaClass = new AndroidJavaClass ("com.TeamWARIS.WARISProject.CustomGPS");
_camLoc = gameObject.AddComponent<Geolocation>();
_camLoc.initGPS();
_directionx = 0;
_directiony = 1;
setCamVecLength(0.00015);
checkGPS();
gcs = GetComponent<GUIControllerScript>();
_location = "";
_GUIWindow = new Rect(Screen.width / 4 + 10, (Screen.height / 2) + 10, Screen.width / 4 - 20, (Screen.height / 2) - 35);
rc = (ResourceController)GameObject.Find ("Resource Controller").GetComponent<ResourceController> ();
buildingManager = rc.GetBuildingManager ();
staffManager = rc.GetStaffManager ();
lectureManager = rc.GetLectureManager ();
gpsActivityJavaClass = new AndroidJavaClass ("com.TeamWARIS.WARISProject.CustomGPS");
}
public void SetBuilding(int i, Building instance)
{
BuildingManager manager = tiles_[i].GetComponent <BuildingManager>();
manager.SetBuilding(instance);
}
/*** Script Methods ***/
// Use this for initialization
void Start()
{
/*** Init. Game System ***/
// Default camera zoom
Camera.main.orthographicSize = Globals.MinCameraSize + (Globals.MaxCameraSize - Globals.MinCameraSize) / 2.0f;
// Instantiate all game-level objects
SManager = gameObject.AddComponent(typeof(SpriteManager)) as SpriteManager;
ProjManager = gameObject.AddComponent(typeof(ProjectileManager)) as ProjectileManager;
ShipManager = gameObject.AddComponent(typeof(ShipsManager)) as ShipsManager;
SceneManager = gameObject.AddComponent(typeof(SceneryManager)) as SceneryManager;
ResManager = gameObject.AddComponent(typeof(ResourceManager)) as ResourceManager;
BuildingManager = gameObject.AddComponent(typeof(BuildingManager)) as BuildingManager;
AManager = gameObject.AddComponent(typeof(AudioManager)) as AudioManager;
SongManager = gameObject.AddComponent(typeof(AudioSystem)) as AudioSystem;
OverlayView = gameObject.AddComponent(typeof(GameOverlay)) as GameOverlay;
ContextMenuView = gameObject.AddComponent(typeof(GameContextMenu)) as GameContextMenu;
/*** Background System ***/
// Allocate the background sprites
BackgroundSprites = new Sprite[BackgroundLayerCount];
for(int i = 0; i < BackgroundLayerCount; i++)
{
// Alloc and retain
Sprite Background = new Sprite("Textures/BGLayer" + i);
BackgroundSprites[i] = Background;
// Make the sprite geometry as big as the max camera, and center it on the camera
BackgroundSprites[i].SetGeometrySize(new Vector2(Globals.MaxCameraSize, Globals.MaxCameraSize) * 2.5f * Camera.main.aspect);
BackgroundSprites[i].SetPosition(-BackgroundSprites[i].GetGeometrySize() / 2.0f);
BackgroundSprites[i].SetDepth(Globals.BackgroundDepth - i); // Each layet is closer to the camera
// Register sprite
SManager.AddSprite(Background);
}
/*** Add Scene Elements & Load Enemey Spawn List ***/
// Load the level gen. (note that we finish loading in the "OnLevelWasLoaded" because
// of a Unity3D-specific design issue
LevelLoaded = false;
LevelGen = new LevelManager(TargetLevel);
/*** TESTING: Add temp ships ***/
// Create a few ships destroyers bottom right
for(int i = 0; i < 6; i++)
{
int x = UnityEngine.Random.Range(-500, 500);
int y = UnityEngine.Random.Range(-500, 500);
BaseShip Friendly = null;
if(i == 0)
Friendly = new CarrierShip();
else if(i == 1)
Friendly = new DestroyerShip();
else
Friendly = new FighterShip();
Friendly.SetPos(new Vector2(x, y));
ShipManager.ShipsList.Add(Friendly);
}
}
/// <summary>
/// Check the household numbers
/// </summary>
/// <param name="buildings"></param>
/// <param name="citizens"></param>
/// <param name="i"></param>
private void checkResidentialHouseholds(BuildingManager buildings, CitizenManager citizens, int i)
{
Building building = buildings.m_buildings.m_buffer[i];
BuildingInfo info = building.Info;
int width = building.Width;
int length = building.Length;
if ((info != null) && (info.m_buildingAI is ResidentialBuildingAI))
{
int modHomeCount = ((ResidentialBuildingAI)info.m_buildingAI).CalculateHomeCount(new ColossalFramework.Math.Randomizer(i), width, length);
// If the modded home count is meant to be less than the original
if (modHomeCount < Game_ResidentialAI.CalculateHomeCount(new ColossalFramework.Math.Randomizer(i), width, length, info.m_class.m_subService, info.m_class.m_level))
{
int houseHoldCount = 0;
uint citizenIndex = building.m_citizenUnits;
while (houseHoldCount < modHomeCount) // Fast forward
{
citizenIndex = citizens.m_units.m_buffer[(int)((UIntPtr)citizenIndex)].m_nextUnit;
houseHoldCount++;
}
// Disconnect the rest
while (citizenIndex != 0u)
{
CitizenUnit c = citizens.m_units.m_buffer[(int)((UIntPtr)citizenIndex)];
citizens.ReleaseUnits(citizenIndex);
citizenIndex = c.m_nextUnit;
// Reset the flags which could make the game think this group has connections to a home
c.m_nextUnit = 0u;
c.m_building = 0;
c.m_flags = CitizenUnit.Flags.None;
}
}
}
}
private static bool isBuildingCreated(BuildingManager bMgr, ushort iBuildingIndex)
{
if ((bMgr.m_buildings.m_buffer[iBuildingIndex].m_flags & Building.Flags.Created) == Building.Flags.Created)
{
return true;
}
return false;
}
void Awake()
{
instance = this;
}
public Building selectedBuilding = null; //Bulding which the player wants to build
#endregion Fields
#region Methods
public void Start()
{
instance = this;
}
public void EnterFreeMode() {
Situation = GameSituation.Free;
ZonesParentGO.SetActive (false);
if (currentBuildingPrototype != null)
{
Destroy(currentBuildingPrototype.MainTransform.gameObject);
currentBuildingPrototype = null;
}
}
private void Initialize()
{
this._buildingManager = Singleton<BuildingManager>.instance;
this._simulationManager = Singleton<SimulationManager>.instance;
this._effectManager = Singleton<EffectManager>.instance;
this._economyManager = Singleton<EconomyManager>.instance;
this._coverageManager = Singleton<CoverageManager>.instance;
this._nullAudioGroup = new AudioGroup(0, new SavedFloat("NOTEXISTINGELEMENT", Settings.gameSettingsFile, 0f, false));
}
public PlayerSelectionState(GameManager gameManager, BuildingManager buildingManager, IResourceManager resourceManager)
: base(gameManager, buildingManager, resourceManager)
{
}
public PlayerBuildingSingleStructureState(GameManager gameManager, BuildingManager buildingManager) : base(gameManager)
{
this.buildingManager = buildingManager;
}
private void Awake()
{
bM = FindObjectOfType <BuildingManager> ();
gM = FindObjectOfType <GameManager> ();
}
private static void HandleFireSpread(CommonBuildingAI CBAI, ushort buildingID, ref Building buildingData, int fireDamage)
{
unsafe
{
Quad2 quad2 = new Quad2();
int width = buildingData.Width;
int length = buildingData.Length;
Vector2 vector2 = VectorUtils.XZ(buildingData.m_position);
Vector2 vector21 = new Vector2(Mathf.Cos(buildingData.m_angle), Mathf.Sin(buildingData.m_angle));
Vector2 vector22 = new Vector2(vector21.y, -vector21.x);
float single = (float)Singleton <SimulationManager> .instance.m_randomizer.Int32(8, 32);
quad2.a = (vector2 - (((float)width * 4f + single) * vector21)) - (((float)length * 4f + single) * vector22);
quad2.b = (vector2 + (((float)width * 4f + single) * vector21)) - (((float)length * 4f + single) * vector22);
quad2.c = (vector2 + (((float)width * 4f + single) * vector21)) + (((float)length * 4f + single) * vector22);
quad2.d = (vector2 - (((float)width * 4f + single) * vector21)) + (((float)length * 4f + single) * vector22);
Vector2 vector23 = quad2.Min();
Vector2 vector24 = quad2.Max();
float mPosition = buildingData.m_position.y - (float)buildingData.m_baseHeight;
//krn
//CBAI.m_info is private\instance /use reflection, should do reverse redirect.
BuildingInfo bldgInfo;
bldgInfo = (BuildingInfo)CBAI.GetType().GetField("m_info", BindingFlags.Instance | BindingFlags.Public).GetValue(CBAI);
if (bldgInfo == null && bldgInfo.m_size == null)
{
Logger.dbgLog("bldgInfo was null");
}
float mPosition1 = buildingData.m_position.y + bldgInfo.m_size.y;
//org
//float mPosition1 = buildingData.m_position.y + this.m_info.m_size.y;
//end org
float mFireIntensity = (float)(buildingData.m_fireIntensity * (64 - Mathf.Abs(fireDamage - 192)));
InstanceID instanceID = new InstanceID()
{
Building = buildingID
};
InstanceManager.Group group = Singleton <InstanceManager> .instance.GetGroup(instanceID);
if (group != null)
{
ushort disaster = group.m_ownerInstance.Disaster;
if (disaster != 0)
{
DisasterManager disasterManager = Singleton <DisasterManager> .instance;
DisasterInfo info = disasterManager.m_disasters.m_buffer[disaster].Info;
int fireSpreadProbability = info.m_disasterAI.GetFireSpreadProbability(disaster, ref disasterManager.m_disasters.m_buffer[disaster]);
mFireIntensity = mFireIntensity * ((float)fireSpreadProbability * 0.01f);
}
}
int num = Mathf.Max((int)((vector23.x - 72f) / 64f + 135f), 0);
int num1 = Mathf.Max((int)((vector23.y - 72f) / 64f + 135f), 0);
int num2 = Mathf.Min((int)((vector24.x + 72f) / 64f + 135f), 269);
int num3 = Mathf.Min((int)((vector24.y + 72f) / 64f + 135f), 269);
BuildingManager buildingManager = Singleton <BuildingManager> .instance;
for (int i = num1; i <= num3; i++)
{
for (int j = num; j <= num2; j++)
{
ushort mBuildingGrid = buildingManager.m_buildingGrid[i * 270 + j];
int num4 = 0;
object[] paramcall;
while (mBuildingGrid != 0)
{
//Should we change this 262144?
if (mBuildingGrid != buildingID && (float)Singleton <SimulationManager> .instance.m_randomizer.Int32(262144) * single < mFireIntensity)
{
//Logger.dbgLog("Handlefire1");
paramcall = new object[] { quad2, mPosition, mPosition1, mBuildingGrid, buildingManager.m_buildings.m_buffer[mBuildingGrid], group };
//var x = CBAI.GetType().GetMethod("TrySpreadFire", BindingFlags.Static | BindingFlags.NonPublic).Invoke(CBAI, paramcall);
LimitCommonBuildingAI.TrySpreadFire(quad2, mPosition, mPosition1, mBuildingGrid, ref buildingManager.m_buildings.m_buffer[mBuildingGrid], group);
//Logger.dbgLog("Handlefire2");
//orginal
//CommonBuildingAI.TrySpreadFire(quad2, mPosition, mPosition1, mBuildingGrid, ref buildingManager.m_buildings.m_buffer[mBuildingGrid], group);
}
mBuildingGrid = buildingManager.m_buildings.m_buffer[mBuildingGrid].m_nextGridBuilding;
int num5 = num4 + 1;
num4 = num5;
if (num5 < 49152)
{
continue;
}
CODebugBase <LogChannel> .Error(LogChannel.Core, string.Concat("Invalid list detected!\n", Environment.StackTrace));
break;
}
}
}
Vector3 vector3 = VectorUtils.X_Y(vector21);
Vector3 vector31 = VectorUtils.X_Y(vector22);
int num6 = Mathf.Max((int)((vector23.x - 32f) / 32f + 270f), 0);
int num7 = Mathf.Max((int)((vector23.y - 32f) / 32f + 270f), 0);
int num8 = Mathf.Min((int)((vector24.x + 32f) / 32f + 270f), 539);
int num9 = Mathf.Min((int)((vector24.y + 32f) / 32f + 270f), 539);
TreeManager treeManager = Singleton <TreeManager> .instance;
for (int k = num7; k <= num9; k++)
{
for (int l = num6; l <= num8; l++)
{
uint mTreeGrid = treeManager.m_treeGrid[k * 540 + l];
int num10 = 0;
while (mTreeGrid != 0)
{
Vector3 position = treeManager.m_trees.m_buffer[mTreeGrid].Position;
Vector3 mPosition2 = position - buildingData.m_position;
mPosition2 = mPosition2 - (Mathf.Clamp(Vector3.Dot(mPosition2, vector3), (float)(-width) * 4f, (float)width * 4f) * vector3);
mPosition2 = mPosition2 - (Mathf.Clamp(Vector3.Dot(mPosition2, vector31), (float)(-length) * 4f, (float)length * 4f) * vector31);
float single1 = mPosition2.magnitude;
//Should we change this 131072?
//Logger.dbgLog("Handlefire3");
if (single1 < 32f && (float)Singleton <SimulationManager> .instance.m_randomizer.Int32(131072) * single1 < mFireIntensity)
{
treeManager.BurnTree(mTreeGrid, group, (int)buildingData.m_fireIntensity);
}
mTreeGrid = treeManager.m_trees.m_buffer[mTreeGrid].m_nextGridTree;
int num11 = num10 + 1;
num10 = num11;
if (num11 < LimitTreeManager.Helper.TreeLimit)
{
continue;
}
CODebugBase <LogChannel> .Error(LogChannel.Core, string.Concat("Invalid list detected!\n", Environment.StackTrace));
break;
}
}
}
}
}
void Start()
{
KeyPressed = new EconEvent();
// TODO: move these to respective managers
KeyPressed.AddListener((args) =>
{
if (args.IsPressed(KeyCode.B))
{
BuildingManager.StartPlacingHouse();
}
return(args.RemoveKeys(KeyCode.B));
});
KeyPressed.AddListener((args) =>
{
if (args.IsPressed(KeyCode.Q))
{
UserActionManager.Chop();
}
return(args.RemoveKeys(KeyCode.Q));
});
KeyPressed.AddListener((args) =>
{
if (args.IsPressed(KeyCode.E))
{
UserActionManager.Interact();
}
return(args.RemoveKeys(KeyCode.E));
});
KeyPressed.AddListener((args) =>
{
if (args.IsPressed(KeyCode.Escape))
{
//if (UIManager.Dialog.activeInHierarchy)
//{
// // We have an active dialog - dismiss it
// UIManager.Dialog.SetActive(false);
//}
//else
{
UIManager.ToggleSettingsDialog();
}
}
return(args.RemoveKeys(KeyCode.Escape));
});
KeyPressed.AddListener((args) =>
{
if (ChatManager.IsActive)
{
return(args.ClearKeys());
}
return(args);
});
KeyPressed.AddListener((args) =>
{
if (args.IsPressed(KeyCode.I))
{
UIManager.TogglePlayerInventory();
}
return(args.RemoveKeys(KeyCode.I));
});
}
/*
* Handles removal of buildings and status changes
*
* Note: Just because a building has been removed visually, it does not mean
* it is removed as far as the game is concerned. The building is only truly removed
* when the frame covers the building's id, and that's when we will remove the
* building from our records.
*/
public override void OnUpdate(float realTimeDelta, float simulationTimeDelta)
{
if (_terminated) return;
if (!_helper.BuildingMonitorSpinnable) return;
if (!_settings.Enable._BuildingMonitor) return;
try
{
if (!_initialized)
{
_data = Data.Instance;
_mapping = new BuildingPrefabMapping();
_paused = false;
_instance = Singleton<BuildingManager>.instance;
_capacity = _instance.m_buildings.m_buffer.Length;
_id = (ushort)_capacity;
_added.Clear();
_removed.Clear();
for (ushort i = 0; i < _capacity; i++)
{
if (ProcessBuilding(i))
UpdateBuilding();
}
_lastProcessedFrame = GetFrame();
_initialized = true;
_helper.BuildingMonitorSpun = true;
_helper.BuildingMonitor = this;
_helper.NotifyPlayer("Building monitor initialized");
}
else if (!SimulationManager.instance.SimulationPaused)
{
_data._BuildingsAdded.Clear();
_data._BuildingsUpdated.Clear();
_data._BuildingsRemoved.Clear();
foreach (ushort i in _added)
_data._BuildingsAdded.Add(i);
_added.Clear();
foreach (ushort i in _removed)
_data._BuildingsRemoved.Add(i);
_removed.Clear();
int end = GetFrame();
while (_lastProcessedFrame != end)
{
_lastProcessedFrame = GetFrame(_lastProcessedFrame + 1);
int[] boundaries = GetFrameBoundaries(_lastProcessedFrame);
ushort id;
for (int i = boundaries[0]; i <= boundaries[1]; i++)
{
id = (ushort)i;
if (UpdateBuilding(id))
_data._BuildingsUpdated.Add(id);
else if (_data._Buildings.Contains(id))
{
_data._BuildingsRemoved.Add(id);
RemoveBuilding(id);
}
}
}
}
OutputDebugLog();
}
catch (Exception e)
{
string error = "Building monitor failed to initialize\r\n";
error += String.Format("Error: {0}\r\n", e.Message);
error += "\r\n";
error += "==== STACK TRACE ====\r\n";
error += e.StackTrace;
_helper.Log(error);
_terminated = true;
}
base.OnUpdate(realTimeDelta, simulationTimeDelta);
}
