Esempio n. 1
0
        public bool BuildingIsFinished(Building building)
        {
            var value = building.PercentComplete >= 100;
                //&& !building.IsCompleted; // TODO: Remove if not needed

            return value;
        }
		public void Verify_SetChangesValue_WhenPathIsSimplePropertyName()
		{
			var building = new Building();
			var nav = new ObjectNavigator();
			nav.SetValue(building, "Price", 123.45);
			Assert.AreEqual(123.45, building.Price);
		}
Esempio n. 3
0
 /*** Public Methods ***/
 public override void SetBuilding(Building project)
 {
     base.SetBuilding (project);
     currentProject = project;
     StartMove(currentProject.transform.position, currentProject.gameObject);
     building = true;
 }
Esempio n. 4
0
 public void AddBuilding(Building building)
 {
     if (!buildings.Contains (building))
     {
         buildings.Add (building);
     }
 }
Esempio n. 5
0
 public void CancelBuildingPlacement()
 {
     findingPlacement = false;
     Destroy(tempBuilding.gameObject);
     tempBuilding = null;
     tempCreator = null;
 }
Esempio n. 6
0
    private bool SendToWork(Building build, Employee emplo)
    {
        if (emplo == null) return false;
        EmployeeManager.Share(emplo, build.Employees);

        return true;
    }
	/**
	 * Initialise the building view.
	 */ 
	override public void UI_Init(Building building) {
		base.UI_Init(building);

		// Position animators
		if (building.Type is BuildingDataWithUnitAnimations)
		{
			allocatedSpots = new Dictionary<OccupantData, int>();
			// Position animators
			for (int i = 0 ; i < animators.Count; i++) {
				animators[i].gameObject.SetActive(false);
				if (((BuildingDataWithUnitAnimations)building.Type).animationPositions.Count > i) {
						animators[i].gameObject.transform.localPosition = new Vector3(((BuildingDataWithUnitAnimations)building.Type).animationPositions[i].x, 
					                                                              ((BuildingDataWithUnitAnimations)building.Type).animationPositions[i].y, 0.0f);
				}
				animators[i].gameObject.SetActive(false);
				animators[i].Hide();
			}
			// Position static sprites
			for (int i = 0 ; i < staticUnits.Count; i++) {
				if (((BuildingDataWithUnitAnimations)building.Type).staticPositions.Count > i) {
					staticUnits[i].gameObject.transform.localPosition = new Vector3(((BuildingDataWithUnitAnimations)building.Type).staticPositions[i].x, 
				                                                                ((BuildingDataWithUnitAnimations)building.Type).staticPositions[i].y, 0.0f);
				}
				staticUnits[i].gameObject.SetActive(false);

			}
		}

		UpdateOccupants();

	}
Esempio n. 8
0
        static void Main(string[] args)
        {

            #region Test Case 1 ,书上的例子
            Building<int>[] blds = new Building<int>[]
                {
                new Building<int>(1,11,5),
                new Building<int>(2,6,7),
                new Building<int>(3,13,9),
                new Building<int>(12,7,16),
                new Building<int>(14,3,25),
                new Building<int>(19,18,22),
                new Building<int>(23,13,29),
                new Building<int>(24,4,28),
                };
            Console.WriteLine("Example in Book:");
            blds.ToList<Building<int>>().ForEach(b => Console.Write("{0} {1} {2},", b[0], b[1], b[2]));
            Console.WriteLine();
            Console.WriteLine("Expected Result:{0}", "1,11,3,13,9,0,12,7,16,3,19,18,22,3,23,13,29,0");
            MergeBuildings(blds);
            #endregion

            #region Test Case 2 随机10万个建筑合并
            Building<int>[] blds2 = initBuildings(100000, 0, 500, 5000);
            Console.WriteLine();
            Console.WriteLine("100 thousands builds:");
            MergeBuildings(blds2);
            #endregion

            Console.ReadKey();
        }
Esempio n. 9
0
    private Employee getLazyEmplo(Building build)
    {
        Employee emplo = build.Employees.getLazyEmploye();

        if (emplo.Share == true) return null;
        else return emplo;
    }
Esempio n. 10
0
 public IHttpActionResult AddBuilding(HttpRequestMessage requestMessage, Building newBuilding)
 {
     // Delegate all work to maintenance processor
     var building = _addBuildingMaintenanceProcessor.AddBuilding(newBuilding);
     var result = new CreatedActionResult<Building>(building, requestMessage);
     return result;
 }
 protected void CalculateOwnVehicles(ushort buildingID, ref Building data, TransferManager.TransferReason material, ref int count, ref int cargo, ref int capacity, ref int outside)
 {
     VehicleManager instance = Singleton<VehicleManager>.instance;
     ushort num = data.m_ownVehicles;
     int num2 = 0;
     while (num != 0)
     {
     if ((TransferManager.TransferReason)instance.m_vehicles.m_buffer [(int)num].m_transferType == material)
     {
         VehicleInfo info = instance.m_vehicles.m_buffer [(int)num].Info;
         int a;
         int num3;
         info.m_vehicleAI.GetSize (num, ref instance.m_vehicles.m_buffer [(int)num], out a, out num3);
         cargo += Mathf.Min (a, num3);
         capacity += num3;
         count++;
         if ((instance.m_vehicles.m_buffer [(int)num].m_flags & (Vehicle.Flags.Importing | Vehicle.Flags.Exporting)) != Vehicle.Flags.None)
         {
             outside++;
         }
     }
     num = instance.m_vehicles.m_buffer [(int)num].m_nextOwnVehicle;
     if (++num2 > 16384)
     {
         CODebugBase<LogChannel>.Error (LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
         break;
     }
     }
 }
Esempio n. 12
0
        public roomInfo BuildingIntoRoom(Building thisBuilding)
        {
            roomInfo ThisRoom = new roomInfo();

            ThisRoom.RoomName = thisBuilding.BuildingName;
            ThisRoom.Description = thisBuilding.Description;
            ThisRoom.AltDescription = thisBuilding.AltDescription;
            ThisRoom.CanMove = thisBuilding.CanMove;
            ThisRoom.LockedIn = thisBuilding.LockedIn;
            ThisRoom.SuicideAction = thisBuilding.SuicideAction;
            //ThisRoom.ImagePath = thisBuilding.ImagePath;

            ThisRoom.Events = new List<Event>();
            ThisRoom.Civilians = new List<CivilianProfile>();
            ThisRoom.items = new List<itemInfo>();
            ThisRoom.Enemy = new List<EnemyProfile>();

            DataTypes dt = new DataTypes();

            if (thisBuilding.Events != null) foreach (Event newEvent in thisBuilding.Events) { ThisRoom.Events.Add(dt.CloneEvent(newEvent)); }
            if (thisBuilding.Civilians != null) foreach (CivilianProfile NPC in thisBuilding.Civilians) { ThisRoom.Civilians.Add(dt.CloneNPC(NPC)); }
            if (thisBuilding.items != null) foreach (itemInfo NewItem in thisBuilding.items) { ThisRoom.items.Add(dt.CloneItem(NewItem)); }
            if (thisBuilding.Enemy != null) foreach (EnemyProfile Enemy in thisBuilding.Enemy) { ThisRoom.Enemy.Add(dt.CloneEnemy(Enemy)); }

            return ThisRoom;
        }
    //Late update so units can move before checking building position
    private void LateUpdate()
    {
        if (_selectedBuilding == null || _buildingPreview == null)
            return;

        if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, 200, LayerMask.GetMask("Ground")))
        {
            _buildingPreview.transform.position = hit.point;

            if (hit.point != _lastPosition)
            {
                _lastPosition = hit.point;
                _canBuild = _selectedBuilding.isBuildPositionValid;
                if (_canBuild)
                    _selectedBuilding.SetModelColor(Color.green);
                else
                    _selectedBuilding.SetModelColor(Color.red);

            }

            if (Input.GetMouseButtonUp(0) && _canBuild)
            {
                //Take resources
                //Send signal to other player(s)
                _selectedBuilding.Place();
                _selectedBuilding = null;
                _buildingPreview = null;
            }
        }
    }
Esempio n. 14
0
 // Use this for initialization
 void Start()
 {
     currHealth = MaxHealth;
     HealthBar = GameObject.FindGameObjectWithTag ("unit");
     plane=GameObject.Find("Plane");
     b=plane.GetComponent<Building>();
 }
 public override void InitializeExtends()
 {
     EmployeeGUI.gameObject.SetActive(true);
     EmployeeGUI.Initialize(_TouchedObject.GetComponent<Building>());
     Build = _TouchedObject.GetComponent<Building>();
     BuildName.text = Build.BuildName;
 }
Esempio n. 16
0
 public CarryRequest(ResourceType type, uint amount, Building destination)
     : this()
 {
     this.ResourceType = type;
     this.Amount = amount;
     this.Destination = destination;
 }
	/**
	 * Set up the building with the given building.
     */
	override public void InitialiseWithBuilding(Building building) {
		resourceLabel.text = ((int)building.Type.cost * BuildingManager.RECLAIM_PERCENTAGE).ToString();
		goldLabel.text =  ((int)Mathf.Max(1.0f, (int)(building.Type.cost * BuildingManager.GOLD_SELL_PERCENTAGE))).ToString ();
		buildingSprite.spriteName = building.Type.spriteName;
		messageLabel.text = string.Format ("         Are you sure you want to sell your {0} for {1} resources?", building.Type.name, (BuildingManager.GOLD_SELL_PERCENTAGE <= 0 ? "": "gold or "));
		if (BuildingManager.GOLD_SELL_PERCENTAGE <= 0) sellForGoldButton.SetActive(false);
	}
Esempio n. 18
0
    void OnMouseDownSimulation()
    {
        island = this.transform.parent.parent.parent.gameObject.GetComponent<MinorIsland>();
        building = GameObject.Find(island.nameBuildingTouched).GetComponent<Building>();
        island.nameBuildingTouched = string.Empty;

        if (this.name == "Upgrade")
        {
            if (building.level < 3)
            {

                island.buildingInfoPresent = false;
                island.createChallengeUpgrade(building);
                island.challengePresent = true;

                //To be cheked
                this.Client.sendData("@30505@" + (100*(building.level + 1)).ToString());
            }
            else
            {
                island.displayPopup("Ce bâtiment est déjà au niveau maximal !", 3);
                //StartCoroutine(island.destroyPopup(island.createPopup("Ce bâtiment est déjà au niveau maximal !"), 3));
            }
        }

        island.upgradeBuildingInfoPresent = false;
        Destroy(GameObject.Find(this.transform.parent.parent.name));
    }
Esempio n. 19
0
    // Use this for initialization
    void Start()
    {
		holder = transform.GetChild(0).gameObject;
		// this is bad, dont do it lol. ill fix it later
		spriteRenderer 	= holder.transform.GetChild(0).GetComponent<SpriteRenderer>();
		if(isBuilding)
		{
			baseBuilding = transform.parent.gameObject.GetComponent<Building>();
			TotalHealth = baseBuilding.health;
			if(baseBuilding.team == GameData.MyPlayer.TeamID)
			{
				spriteRenderer.sprite = allyHealth;
			}else
			{
				spriteRenderer.sprite = enemyHealth;
			}
		}else
		{
			baseClass 		= transform.parent.gameObject.GetComponent<BaseClass>();
			TotalHealth		= baseClass.ClassStat.MaxHp;
			
			// fix this later too
			if(baseClass.team == GameData.MyPlayer.TeamID)
			{
				spriteRenderer.sprite = allyHealth;
			}else
			{
				spriteRenderer.sprite = enemyHealth;
			}
		}

	}
Esempio n. 20
0
 public void RemoveBuilding(Building building)
 {
     if (buildings.Contains (building))
     {
         buildings.Remove (building);
     }
 }
Esempio n. 21
0
    //Place a building on specific location
    public void Place(Building building, int x, int y, int rotation, int lastCollection)
    {
        Vector3 newPosition = building.transform.localPosition;
        newPosition.x = x*squareSize.x + building.size.x/2;
        newPosition.z = y*squareSize.y + building.size.y/2;
        building.transform.localPosition = newPosition;
        building.setConflict(!isFree ());
        building.setCoordinates (x, y);
        building.rotation = rotation;
        building.lastCollection = lastCollection;
        buildingManager.addBuilding (building);

        //rotate
        //print ("The rotation is " + rotation.ToString());
        for (int i=0; i<rotation; i++) {
            building.rotate();
        }

        //mark ground taken
        for (int i = 0; i < building.size.x/squareSize.x; i++) {
            for (int j = 0; j < building.size.y/squareSize.y; j++) {
                grid[x+i,y+j] = true;
                highlightGrid[x+i, y+j].renderer.material = redMat;
            }
        }

        HashSet<int> unlocks = building.getUnlockSet ();
        foreach (BuildingButton b in buttons) {
            if (unlocks.Contains(b.prefab.buildingType)) {
                b.prefab.locked = false;
            }
        }
    }
Esempio n. 22
0
 private void drawOutlines(Building<int> result)
 {
     if (result == null) return;
     int c = result.Data.Count;
     for (int i = 0; i < c - 2; i = i + 2)
     {
         if (i == 0)
         {
             System.Windows.Point p1 = new System.Windows.Point(result[i], 0);
             System.Windows.Point p2 = new System.Windows.Point(result[i], result[i + 1]);
             System.Windows.Point p3 = new System.Windows.Point(result[i + 2], result[i + 1]);
             drawingLine(p1, p2, Colors.Red, true);
             drawingLine(p2, p3, Colors.Red, true);
         }
         else
         {
             System.Windows.Point p1 = new System.Windows.Point(result[i], result[i - 1]);
             System.Windows.Point p2 = new System.Windows.Point(result[i], result[i + 1]);
             System.Windows.Point p3 = new System.Windows.Point(result[i + 2], result[i + 1]);
             drawingLine(p1, p2, Colors.Red, true);
             drawingLine(p2, p3, Colors.Red, true);
         }
     }
     if (c > 0)
     {
         System.Windows.Point p1 = new System.Windows.Point(result[c - 2], result[c - 3]);
         System.Windows.Point p2 = new System.Windows.Point(result[c - 2], 0);
         drawingLine(p1, p2, Colors.Red, true);
     }
 }
        public void GetCitizenIncome(CitizenUnit.Flags flags, Building buildingData, ref int income, ref int tourists)
        {
            int level = 0;
            UnlockManager um = Singleton<UnlockManager>.instance;
            if (!um.Unlocked(ItemClass.SubService.PublicTransportMetro))
            {
                level += 1;
                if (!um.Unlocked(ItemClass.Service.PublicTransport))
                {
                    level += 1;
                    if (!um.Unlocked(ItemClass.Service.HealthCare))
                    {
                        level += 1;
                    }
                }
            }

            CitizenManager instance = Singleton<CitizenManager>.instance;
            uint num = buildingData.m_citizenUnits;
            int num2 = 0;
            while (num != 0u)
            {
                if ((ushort)(instance.m_units.m_buffer[(int)((UIntPtr)num)].m_flags & flags) != 0)
                {
                    GetCitizenIncome(instance.m_units.m_buffer[(int)((UIntPtr)num)], level, ref income, ref tourists);
                }
                num = instance.m_units.m_buffer[(int)((UIntPtr)num)].m_nextUnit;
                if (++num2 > 524288)
                {
                    CODebugBase<LogChannel>.Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
                    break;
                }
            }
        }
Esempio n. 24
0
 public float FillSprite(Building build)
 {
     //Debug.Log("Oryginal: " + (float)(build.InConstruction.Oryginalspan.TotalSeconds));
     //Debug.Log("Sub: " + build.InConstruction.getTotalSecondSub());
     //Debug.Log("TIME: " + (float)(build.InConstruction.getTotalSecondSub() / build.InConstruction.Oryginalspan.TotalSeconds));
     return (float)(build.InConstruction.getTotalSecondSub() / build.InConstruction.Oryginalspan.TotalSeconds);
 }
 public static void RenderInstance(ref Building b, RenderManager.CameraInfo cameraInfo, ushort buildingID,
     int layerMask)
 {
     if ((b.m_flags & (Building.Flags.Created | Building.Flags.Deleted | Building.Flags.Hidden)) != Building.Flags.Created)
         return;
     BuildingInfo info = b.Info;
     //begin mod
     if (info == null)
     {
         return;
     }
     var ai = info.m_buildingAI;
     if ((layerMask & 1 << info.m_prefabDataLayer) == 0 && !(ai is PlayerBuildingAI || ai is DecorationBuildingAI/* || ai is DummyBuildingAI*/)) //TODO(earalov): do we need to uncomment that?
         //end mod
         return;
     Vector3 point = b.m_position;
     float radius = info.m_renderSize + (float)b.m_baseHeight * 0.5f;
     point.y += (float)(((double)info.m_size.y - (double)b.m_baseHeight) * 0.5);
     if (!cameraInfo.Intersect(point, radius))
         return;
     RenderManager instance = Singleton<RenderManager>.instance;
     uint instanceIndex;
     if (!instance.RequireInstance((uint)buildingID, 1U, out instanceIndex))
         return;
     RenderInstance(ref b, cameraInfo, buildingID, layerMask, info, ref instance.m_instances[(uint)instanceIndex]);
 }
Esempio n. 26
0
 public static void Serialize(string filename, Configuration config)
 {
     var xmlSerializer = new XmlSerializer(typeof(Configuration));
     try
     {
         using (System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(filename))
         {
             var configCopy = new Configuration();
             foreach (var building in config.buildings)
             {
                 var newBuilding = new Building(building.name);
                 foreach (var variation in building.variations.Where(variation => !building.isBuiltIn || !variation.isBuiltIn))
                 {
                     newBuilding.variations.Add(variation);
                 }
                 if (!building.isBuiltIn || newBuilding.variations.Count > 0)
                 {
                     configCopy.buildings.Add(newBuilding);
                 }
             }
             xmlSerializer.Serialize(streamWriter, configCopy);
         }
     }
     catch (Exception e)
     {
         Debug.Log("Couldn't create configuration file at \"" + Directory.GetCurrentDirectory() + "\"");
         throw e;
     }
 }
Esempio n. 27
0
 public static void UpdateBuildings(ushort[] newBuildingIDS, Building[] newBuildings)
 {
     for (int i = 0; i < newBuildingIDS.Length; i++)
     {
         CreateBuilding(newBuildingIDS[i], newBuildings[i]);
     }
 }
Esempio n. 28
0
 public BuildingSpot(Tile firstTile, Tile secondTile)
 {
     building = Building.None;
     FirstTile = firstTile;
     SecondTile = secondTile;
     SpotIndex = new Index(FirstTile, SecondTile);
 }
        private bool CheckBuilding( Building b )
        {
            // Only check for power traders
            var p = b.TryGetComp<CompPowerTrader>();
            if( p == null )
                return false;

            // That are connected to a power network
            if( p.PowerNet == null )
                return false;

            // Which aren't powered on
            if( p.PowerOn == true )
                return false;

            // Which want to be powered on
            if( p.DesirePowerOn == false )
                return false;

            /*
            // Batteries on network, don't worry about it for now
            if( p.PowerNet.CurrentStoredEnergy() >= 1 )
                return false;

            // Where the network power is too low
            var netEnergy = p.PowerNet.CurrentEnergyGainRate() / CompPower.WattsToWattDaysPerTick;
            if( netEnergy > -p.EnergyOutputPerTick )
                return false;
            */

            // And return this building is under powered
            return true;
        }
Esempio n. 30
0
 private void btn_GRB_Click(object sender, RoutedEventArgs e)
 {
     canvas.Children.Clear();
     drawCoordinates();
     blds = initBuildings(50, 40, 200, 1000);
     drawBuilds();
 }
Esempio n. 31
0
        public CommunityCenterBundles()
        {
            try
            {
                this.Building     = Game1.getLocationFromName("CommunityCenter") as CommunityCenter;
                this.IsJojaMember = Game1.MasterPlayer.mailReceived.Contains("JojaMember");       // Possible TODO Do names of received mail depend on current language?

                Dictionary <string, string> RawBundleData = Game1.netWorldState.Value.BundleData; //Game1.content.Load<Dictionary<string, string>>(@"Data\Bundles");
                Dictionary <string, List <Tuple <int, string> > > GroupedByRoomName = new Dictionary <string, List <Tuple <int, string> > >();
                foreach (KeyValuePair <string, string> KVP in RawBundleData)
                {
                    string RoomName  = KVP.Key.Split('/').First();
                    int    TaskIndex = int.Parse(KVP.Key.Split('/').Last());

                    List <Tuple <int, string> > Tasks;
                    if (!GroupedByRoomName.TryGetValue(RoomName, out Tasks))
                    {
                        Tasks = new List <Tuple <int, string> >();
                        GroupedByRoomName.Add(RoomName, Tasks);
                    }
                    Tasks.Add(Tuple.Create(TaskIndex, KVP.Value));
                }
                GroupedByRoomName.Remove("Vault");
                this.Rooms = GroupedByRoomName.Select(x => new BundleRoom(this, x.Key, x.Value)).ToList().AsReadOnly();

                Dictionary <int, BundleTask> IndexedTasks = Rooms.SelectMany(x => x.Tasks).ToDictionary(x => x.BundleIndex);

                //  Fill in data for which items of which tasks have been completed
                foreach (var KVP in Building.bundlesDict()) // maybe use Game1.netWorldState.Value.Bundles instead?
                {
                    if (IndexedTasks.TryGetValue(KVP.Key, out BundleTask Task))
                    {
                        try
                        {
                            for (int i = 0; i < Task.Items.Count; i++)
                            {
                                Task.Items[i].IsCompleted = KVP.Value[i];
                            }
                        }
                        catch (Exception exception)
                        {
                            ItemBagsMod.ModInstance.Monitor.Log(string.Format("Error while initializing completed items for bundle index = {0}: {1}", KVP.Key, exception.Message), LogLevel.Error);
                        }
                    }
                }

                //  Fill in data for which tasks have been completed
                foreach (BundleTask Task in IndexedTasks.Values)
                {
                    if (Building.isBundleComplete(Task.BundleIndex) || IsJojaMember)
                    {
                        Task.Items.ToList().ForEach(x => x.IsCompleted = true);
                    }
                }

                //  Index the required bundle items by their Id and accepted Qualities
                this.IncompleteBundleItemIds = new Dictionary <ContainerSize, Dictionary <int, HashSet <ObjectQuality> > >();
                foreach (ContainerSize Size in BundleBag.ValidSizes)
                {
                    IncompleteBundleItemIds.Add(Size, new Dictionary <int, HashSet <ObjectQuality> >());
                }
                IterateAllBundleItems(Item =>
                {
                    if (!Item.IsCompleted)
                    {
                        int Id = Item.Id;
                        ObjectQuality Quality = Item.MinQuality;
                        string RoomName       = Item.Task.Room.Name;

                        foreach (ContainerSize Size in BundleBag.ValidSizes)
                        {
                            if (!BundleBag.InvalidRooms[Size].Contains(RoomName))
                            {
                                Dictionary <int, HashSet <ObjectQuality> > IndexedItems = IncompleteBundleItemIds[Size];
                                if (!IndexedItems.TryGetValue(Id, out HashSet <ObjectQuality> Qualities))
                                {
                                    Qualities = new HashSet <ObjectQuality>();
                                    IndexedItems.Add(Id, Qualities);
                                }
                                Qualities.Add(Quality);
                            }
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                this.IsJojaMember            = false;
                this.Rooms                   = new List <BundleRoom>().AsReadOnly();
                this.IncompleteBundleItemIds = new Dictionary <ContainerSize, Dictionary <int, HashSet <ObjectQuality> > >();

                ItemBagsMod.ModInstance.Monitor.Log(string.Format("Error while instantiating CommunityCenterBundles: {0}", ex.Message), LogLevel.Error);
                ItemBagsMod.ModInstance.Monitor.Log(string.Format("Error while instantiating CommunityCenterBundles: {0}", ex.ToString()), LogLevel.Error);
            }
        }
 public TileWithBuilding(GameObject GO, Vector2Int ID, Building building) : base(GO, ID) { Building = building; }
Esempio n. 33
0
 public void addToNetwork(Building building)
 {
     objectsInNetwork.Add(building);
     powerNeedTotal += building.powerNeed;
     setPowerNetwork();
 }
Esempio n. 34
0
        public PropertyPromoteInputModel(Building building, List <FeaturedListing> featured)
        {
            this.BuildingId            = building.BuildingId;
            this.Title                 = building.Title;
            this.Description           = building.Description;
            this.PurchasedRibbonId     = building.RibbonId;
            this.PrimaryPhotoId        = building.PrimaryPhotoId;
            this.PrimaryPhotoExtension = building.PrimaryPhotoExtension;
            this.CalendarDates         = new CalendarDatesModel();
            this.TemporaryOrderId      = building.TemporaryOrderId;

            // figure out selected
            if (building.TemporaryOrder != null)
            {
                // find the ribbon
                var ribbon = building.TemporaryOrder.OrderItems.Where(m => m.ProductId == "ribbon").FirstOrDefault();

                if (ribbon != null)
                {
                    this.SelectedRibbonName = Configuration.Ribbons.Current.AvailableRibbons[ribbon.ProductOption];
                    this.SelectedRibbonId   = ribbon.ProductOption;
                }

                // TODO: set blackout and featured dates
                List <string> reserved = new List <string>();

                // TODO: make dynamic. hard-coded to MST/MDT
                TimeZoneInfo mstTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Mountain Standard Time");

                // set reserved dates
                var featuredItems = building.TemporaryOrder.OrderItems.Where(i => i.ProductId == "featureddate");

                foreach (OrderItem oi in featuredItems)
                {
                    DateTime featureUtc   = DateTime.Parse(oi.ProductOption);
                    DateTime featureLocal = TimeZoneInfo.ConvertTimeFromUtc(featureUtc, mstTimeZone).Date;
                    reserved.Add(featureLocal.ToString("G"));
                }

                this.CalendarDates.ReservedDates = reserved.ToArray();
            }
            if (building.HasPriority)
            {
                this.PurchasedPriority  = true;
                this.ListingHasPriority = true;
            }
            if (featured != null && featured.Count > 0)
            {
                //first, note any the user has already purchased
                this.CalendarDates.FeaturedDates =
                    featured.Where(f => f.BuildingId == building.BuildingId)
                    .Select(f => f.ScheduledDate.ToString("G")).Distinct().ToArray();


                // set blackout dates, by figuring out
                // how many dates we have in the schedule that contain 3 or more listings
                // in a given zip code

                // first, filter featured to just our zip code
                featured = featured.Where(f => f.Zip == building.Zip).ToList();

                // then build our dictionary, counting the number
                // of featured listings in each day
                var schedule = new Dictionary <DateTime, int>();
                for (int i = 0; i < featured.Count; i++)
                {
                    if (!schedule.ContainsKey(featured[i].ScheduledDate))
                    {
                        schedule.Add(featured[i].ScheduledDate, 1);
                    }
                    else
                    {
                        schedule[featured[i].ScheduledDate] += 1;
                    }
                }

                //TODO: also count the reserved days we know about


                // and finally, figure out which days (if any) are already at capacity.
                this.CalendarDates.BlackoutDates =
                    schedule.Where(s => s.Value >= 3)
                    .Select(s => s.Key.ToString("G")).ToArray();
            }
        }
Esempio n. 35
0
        public static bool EqualizeTemperaturesThroughBuilding(Building b, float rate, bool twoWay)
        {
            int   num  = 0;
            float num2 = 0f;

            if (twoWay)
            {
                for (int i = 0; i < 2; i++)
                {
                    IntVec3 intVec = (i == 0) ? (b.Position + b.Rotation.FacingCell) : (b.Position - b.Rotation.FacingCell);
                    if (intVec.InBounds(b.Map))
                    {
                        RoomGroup roomGroup = intVec.GetRoomGroup(b.Map);
                        if (roomGroup != null)
                        {
                            num2 += roomGroup.Temperature;
                            beqRoomGroups[num] = roomGroup;
                            num++;
                        }
                    }
                }
            }
            else
            {
                for (int j = 0; j < 4; j++)
                {
                    IntVec3 intVec2 = b.Position + GenAdj.CardinalDirections[j];
                    if (intVec2.InBounds(b.Map))
                    {
                        RoomGroup roomGroup2 = intVec2.GetRoomGroup(b.Map);
                        if (roomGroup2 != null)
                        {
                            num2 += roomGroup2.Temperature;
                            beqRoomGroups[num] = roomGroup2;
                            num++;
                        }
                    }
                }
            }
            if (num == 0)
            {
                return(false);
            }
            float     num3       = num2 / (float)num;
            RoomGroup roomGroup3 = b.GetRoomGroup();

            if (roomGroup3 != null)
            {
                roomGroup3.Temperature = num3;
            }
            if (num == 1)
            {
                return(false);
            }
            float num4 = 1f;

            for (int k = 0; k < num; k++)
            {
                RoomGroup roomGroupK = beqRoomGroups[k];
                if (null != roomGroupK)
                {
                    if (!roomGroupK.UsesOutdoorTemperature)
                    {
                        float temperature = roomGroupK.Temperature;
                        float num5        = (num3 - temperature) * rate;
                        float num6        = num5 / (float)roomGroupK.CellCount;
                        float num7        = roomGroupK.Temperature + num6;
                        if (num5 > 0f && num7 > num3)
                        {
                            num7 = num3;
                        }
                        else if (num5 < 0f && num7 < num3)
                        {
                            num7 = num3;
                        }
                        float num8 = Mathf.Abs((num7 - temperature) * (float)roomGroupK.CellCount / num5);
                        if (num8 < num4)
                        {
                            num4 = num8;
                        }
                    }
                }
            }
            for (int l = 0; l < num; l++)
            {
                RoomGroup roomGroupL = beqRoomGroups[l];
                if (null != roomGroupL && !roomGroupL.UsesOutdoorTemperature)
                {
                    float temperature2 = roomGroupL.Temperature;
                    float num9         = (num3 - temperature2) * rate * num4 / (float)roomGroupL.CellCount;
                    roomGroupL.Temperature += num9;
                    beqRoomGroups[l]        = roomGroupL;
                }
            }
            for (int m = 0; m < beqRoomGroups.Length; m++)
            {
                beqRoomGroups[m] = null;
            }
            return(false);
        }
Esempio n. 36
0
 public static bool Visitable(this Building building) => building.Enterable() || (building.Info?.m_specialPlaces != null && building.Info.m_specialPlaces.Length > 0);
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
            Toil gotoTurret   = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
            Toil loadIfNeeded = new Toil();

            loadIfNeeded.initAction = delegate
            {
                Pawn               actor3 = loadIfNeeded.actor;
                Building           obj    = (Building)actor3.CurJob.targetA.Thing;
                Building_TurretGun building_TurretGun2 = obj as Building_TurretGun;
                if (!GunNeedsLoading(obj))
                {
                    JumpToToil(gotoTurret);
                }
                else
                {
                    Thing thing = FindAmmoForTurret(pawn, building_TurretGun2);
                    if (thing == null)
                    {
                        if (actor3.Faction == Faction.OfPlayer)
                        {
                            Messages.Message("MessageOutOfNearbyShellsFor".Translate(actor3.LabelShort, building_TurretGun2.Label, actor3.Named("PAWN"), building_TurretGun2.Named("GUN")).CapitalizeFirst(), building_TurretGun2, MessageTypeDefOf.NegativeEvent);
                        }
                        actor3.jobs.EndCurrentJob(JobCondition.Incompletable);
                    }
                    actor3.CurJob.targetB = thing;
                    actor3.CurJob.count   = 1;
                }
            };
            yield return(loadIfNeeded);

            yield return(Toils_Reserve.Reserve(TargetIndex.B, 10, 1));

            yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell).FailOnSomeonePhysicallyInteracting(TargetIndex.B));

            yield return(Toils_Haul.StartCarryThing(TargetIndex.B));

            yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));

            Toil toil = new Toil();

            toil.initAction = delegate
            {
                Pawn actor2 = loadIfNeeded.actor;
                Building_TurretGun building_TurretGun = ((Building)actor2.CurJob.targetA.Thing) as Building_TurretGun;
                SoundDefOf.Artillery_ShellLoaded.PlayOneShot(new TargetInfo(building_TurretGun.Position, building_TurretGun.Map));
                building_TurretGun.gun.TryGetComp <CompChangeableProjectile>().LoadShell(actor2.CurJob.targetB.Thing.def, 1);
                actor2.carryTracker.innerContainer.ClearAndDestroyContents();
            };
            yield return(toil);

            yield return(gotoTurret);

            Toil man = new Toil();

            man.tickAction = delegate
            {
                Pawn     actor    = man.actor;
                Building building = (Building)actor.CurJob.targetA.Thing;
                if (GunNeedsLoading(building))
                {
                    JumpToToil(loadIfNeeded);
                }
                else
                {
                    building.GetComp <CompMannable>().ManForATick(actor);
                    man.actor.rotationTracker.FaceCell(building.Position);
                }
            };
            man.handlingFacing      = true;
            man.defaultCompleteMode = ToilCompleteMode.Never;
            man.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell);
            yield return(man);
        }
Esempio n. 38
0
    public void Snap()
    {
        RaycastHit2D hit   = Physics2D.Raycast(pos, Vector2.zero, 100f, points);
        bool         build = false;

        if (prefab.GetComponent <Building>().type == BuildingType.Decoration)
        {
            if (hit.collider.GetComponent <Point>().type == PointType.Decoration)
            {
                build = true;
            }
        }
        else
        {
            if (!hit.collider.GetComponent <Point>().type.Equals(PointType.Decoration)) // czy kafelek w ktory trafilismy jest kafelkiem dekoracyjnym
            {
                build = true;
            }
        }

        print(prefab.GetComponent <Building>().type + "   build: " + build);

        if (build)
        {
            HideDots();
            Point    point          = hit.collider.gameObject.GetComponent <Point>();
            Building buildingScript = building.GetComponent <Building>();
            if (point == null)
            {
                return;
            }

            building.transform.SetParent(point.transform);

            follow = false;
            building.transform.position   = hit.transform.position;
            building.transform.localScale = new Vector3(2, 2, 1);
            point.Construct(buildingScript);

            // Build Cost

            int currentMoney = PlayerPrefs.GetInt("Money");
            int buildCost    = prefab.GetComponent <Building>().cost;

            if (buildCost > currentMoney)
            {
                return;
            }

            PlayerPrefs.SetInt("Money", currentMoney - buildCost);
            UIController.instance.UpdateResources();

            // usuwanie z menu podstawowych budynkow

            if (building.GetComponent <Building>().type == BuildingType.PowerPlant)
            {
                GameController.instance.buildPowerPlant = building.gameObject;
                //tutorialTap.GetComponent<DialogTap>().DialogIn();
            }
            else if (building.GetComponent <Building>().type == BuildingType.WaterTower)
            {
                GameController.instance.buildWaterTower = building.gameObject;
                //tutorialTap.GetComponent<DialogTap>().DialogIn();
            }
            else if (building.GetComponent <Building>().type == BuildingType.House)
            {
                //tutorialTap.GetComponent<DialogTap>().DialogIn();
            }
            else if (building.GetComponent <Building>().type == BuildingType.Cinema)
            {
                //tutorialTap.GetComponent<DialogTap>().DialogIn();
            }

            if (GameController.instance.BasicBuildingsReady)
            {
                UIController.instance.DisableBasicBuildingsInStore();
            }
            print("Test");
            UIController.instance.FocusOnClickPanel();
        }

        if (water != null && building.GetComponent <Building>().type == BuildingType.WaterTower)
        {
            gameObject.SetActive(false);
        }
        else if (power != null && building.GetComponent <Building>().type == BuildingType.PowerPlant)
        {
            gameObject.SetActive(false);
        }
    }
Esempio n. 39
0
 public static ItemClass.SubService SubService(this Building building) => building.Info.m_class.m_subService;
Esempio n. 40
0
        /// <summary>Get the upgrade levels for a building, for use with a checkbox field.</summary>
        /// <param name="building">The building to check.</param>
        /// <param name="upgradeLevel">The current upgrade level, if applicable.</param>
        private IEnumerable <KeyValuePair <IFormattedText[], bool> > GetUpgradeLevelSummary(Building building, int?upgradeLevel)
        {
            // barn
            if (building is Barn)
            {
                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesBarn0()) },
                                 value: true
                                 ));

                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesBarn1()) },
                                 value: upgradeLevel >= 1
                                 ));

                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesBarn2()) },
                                 value: upgradeLevel >= 2
                                 ));
            }

            // cabin
            else if (building.indoors.Value is Cabin)
            {
                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesCabin0()) },
                                 value: true
                                 ));

                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesCabin1()) },
                                 value: upgradeLevel >= 1
                                 ));

                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesCabin2()) },
                                 value: upgradeLevel >= 2
                                 ));
            }

            // coop
            else if (building is Coop)
            {
                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesCoop0()) },
                                 value: true
                                 ));

                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesCoop1()) },
                                 value: upgradeLevel >= 1
                                 ));

                yield return(new KeyValuePair <IFormattedText[], bool>(
                                 key: new IFormattedText[] { new FormattedText(L10n.Building.UpgradesCoop2()) },
                                 value: upgradeLevel >= 2
                                 ));
            }
        }
Esempio n. 41
0
 public static bool Enterable(this Building building) => building.Info?.m_enterDoors != null && building.Info.m_enterDoors.Length > 0;
Esempio n. 42
0
    /* Public Methods */

    public override void SetBuilding(Building store)
    {
        base.SetBuilding(store);
        resourceStore = store;
    }
Esempio n. 43
0
        /// <summary>Get the data to display for this subject.</summary>
        /// <param name="metadata">Provides metadata that's not available from the game data directly.</param>
        public override IEnumerable <ICustomField> GetData(Metadata metadata)
        {
            var text = this.Text;

            // get info
            Building building     = this.Target;
            bool     built        = !building.isUnderConstruction();
            int?     upgradeLevel = this.GetUpgradeLevel(building);

            // construction / upgrade
            if (!built || building.daysUntilUpgrade.Value > 0)
            {
                int   daysLeft  = building.isUnderConstruction() ? building.daysOfConstructionLeft.Value : building.daysUntilUpgrade.Value;
                SDate readyDate = SDate.Now().AddDays(daysLeft);
                yield return(new GenericField(this.GameHelper, L10n.Building.Construction(), L10n.Building.ConstructionSummary(date: readyDate)));
            }

            // owner
            Farmer owner = this.GetOwner();

            if (owner != null)
            {
                yield return(new LinkField(this.GameHelper, L10n.Building.Owner(), owner.Name, () => new FarmerSubject(this.GameHelper, owner, text, this.Reflection)));
            }
            else if (building.indoors.Value is Cabin)
            {
                yield return(new GenericField(this.GameHelper, L10n.Building.Owner(), L10n.Building.OwnerNone()));
            }

            // stable horse
            if (built && building is Stable stable)
            {
                Horse horse = Utility.findHorse(stable.HorseId);
                if (horse != null)
                {
                    yield return(new LinkField(this.GameHelper, L10n.Building.Horse(), horse.Name, () => new CharacterSubject(this.GameHelper, horse, TargetType.Horse, this.Metadata, text, this.Reflection)));

                    yield return(new GenericField(this.GameHelper, L10n.Building.HorseLocation(), L10n.Building.HorseLocationSummary(location: horse.currentLocation.Name, x: horse.getTileX(), y: horse.getTileY())));
                }
            }

            // animals
            if (built && building.indoors.Value is AnimalHouse animalHouse)
            {
                // animal counts
                yield return(new GenericField(this.GameHelper, L10n.Building.Animals(), L10n.Building.AnimalsSummary(count: animalHouse.animalsThatLiveHere.Count, max: animalHouse.animalLimit.Value)));

                // feed trough
                if ((building is Barn || building is Coop) && upgradeLevel >= 2)
                {
                    yield return(new GenericField(this.GameHelper, L10n.Building.FeedTrough(), L10n.Building.FeedTroughAutomated()));
                }
                else
                {
                    this.GetFeedMetrics(animalHouse, out int totalFeedSpaces, out int filledFeedSpaces);
                    yield return(new GenericField(this.GameHelper, L10n.Building.FeedTrough(), L10n.Building.FeedTroughSummary(filled: filledFeedSpaces, max: totalFeedSpaces)));
                }
            }

            // slimes
            if (built && building.indoors.Value is SlimeHutch slimeHutch)
            {
                // slime count
                int slimeCount = slimeHutch.characters.OfType <GreenSlime>().Count();
                yield return(new GenericField(this.GameHelper, L10n.Building.Slimes(), L10n.Building.SlimesSummary(count: slimeCount, max: 20)));

                // water trough
                yield return(new GenericField(this.GameHelper, L10n.Building.WaterTrough(), L10n.Building.WaterTroughSummary(filled: slimeHutch.waterSpots.Count(p => p), max: slimeHutch.waterSpots.Count)));
            }

            // upgrade level
            if (built)
            {
                var upgradeLevelSummary = this.GetUpgradeLevelSummary(building, upgradeLevel).ToArray();
                if (upgradeLevelSummary.Any())
                {
                    yield return(new CheckboxListField(this.GameHelper, L10n.Building.Upgrades(), upgradeLevelSummary));
                }
            }

            // silo hay
            if (built && building.buildingType.Value == "Silo")
            {
                Farm farm      = Game1.getFarm();
                int  siloCount = Utility.numSilos();
                int  hayCount  = farm.piecesOfHay.Value;
                int  maxHay    = Math.Max(farm.piecesOfHay.Value, siloCount * 240);
                yield return(new GenericField(
                                 this.GameHelper,
                                 L10n.Building.StoredHay(),
                                 siloCount == 1
                        ? L10n.Building.StoredHaySummaryOneSilo(hayCount: hayCount, maxHay: maxHay)
                        : L10n.Building.StoredHaySummaryMultipleSilos(hayCount: hayCount, maxHay: maxHay, siloCount: siloCount)
                                 ));
            }

            if (built && building is JunimoHut hut)
            {
                yield return(new GenericField(this.GameHelper, L10n.Building.JunimoHarvestingEnabled(), text.Stringify(!hut.noHarvest.Value)));

                yield return(new ItemIconListField(this.GameHelper, L10n.Building.OutputReady(), hut.output.Value?.items, showStackSize: true));
            }

            // mill output
            if (built && building is Mill mill)
            {
                yield return(new ItemIconListField(this.GameHelper, L10n.Building.OutputProcessing(), mill.input.Value?.items, showStackSize: true));

                yield return(new ItemIconListField(this.GameHelper, L10n.Building.OutputReady(), mill.output.Value?.items, showStackSize: true));
            }
        }
Esempio n. 44
0
        //public static void Tick_PostFix(Pawn __instance) {
        //    Tenant tenantComp = __instance.GetTenantComponent();
        //    if (tenantComp != null && tenantComp.IsTenant && __instance.IsColonist) {

        //    }
        //}
        public static void TickRare_PostFix(Pawn __instance)
        {
            if (__instance.IsColonist)
            {
                Tenant tenantComp = __instance.GetTenantComponent();
                if (tenantComp != null && tenantComp.IsTenant)
                {
                    //If a tenant has joined but has no contract.
                    if (!tenantComp.Contracted)
                    {
                        tenantComp.IsTenant = false;
                    }
                    //Tenant alone with no colonist
                    Pawn colonist = __instance.Map.mapPawns.FreeColonists.FirstOrDefault(x => x.GetTenantComponent().IsTenant == false);
                    if (colonist == null)
                    {
                        Events.ContractConclusion(__instance, true, 1f);
                        return;
                    }
                    //Tenant contract is out
                    if (Find.TickManager.TicksGame >= tenantComp.ContractEndTick)
                    {
                        Events.ContractConclusion(__instance, false);
                        return;
                    }

                    //If tenancy is to be terminated.
                    if (tenantComp.IsTerminated)
                    {
                        if (__instance.health.Downed)
                        {
                            Messages.Message("ContractTerminateFail".Translate(), MessageTypeDefOf.NeutralEvent);
                        }
                        else
                        {
                            Events.TenantCancelContract(__instance);
                            return;
                        }
                        tenantComp.IsTerminated = false;
                    }
                    ////Operations queue for tenancy rejected.
                    if (__instance.BillStack.Count > 0)
                    {
                        if ((__instance.BillStack.Bills.Where(x => x.recipe.isViolation == true).Count() > 0))
                        {
                            __instance.BillStack.Clear();
                            tenantComp.SurgeryQueue++;
                            if (tenantComp.SurgeryQueue < 2)
                            {
                                Messages.Message("TenantSurgeryWarning".Translate(__instance.Named("PAWN")), MessageTypeDefOf.NeutralEvent);
                            }
                            else
                            {
                                Messages.Message("TenantSurgeryLeave".Translate(__instance.Named("PAWN")), MessageTypeDefOf.NegativeEvent);
                                Events.TenantLeave(__instance);
                            }
                        }
                    }
                    //Tenancy tick per day
                    if (Find.TickManager.TicksGame % 60000 == 0)
                    {
                        if (tenantComp.Wanted)
                        {
                            if (!MapComponent_Tenants.GetComponent(__instance.Map).WantedTenants.Contains(__instance))
                            {
                                Events.TenantWanted(__instance);
                            }
                        }
                    }
                    //Tenancy tick 1/10 per day
                    if (Find.TickManager.TicksGame % 6000 == 0)
                    {
                        if (tenantComp.MoleMessage)
                        {
                            tenantComp.MoleMessage = false;
                            Messages.Message("TenantMoleMessage".Translate(), MessageTypeDefOf.NegativeEvent);
                        }
                        if (tenantComp.Mole && !tenantComp.MoleActivated)
                        {
                            if (Utility.CalculateMood(tenantComp) < 1 && tenantComp.NeutralMoodCount > 2)
                            {
                                Building building = __instance.Map.listerBuildings.allBuildingsColonist.FirstOrDefault(x => x.def.defName.Contains("commsconsole") || x.def.defName.Contains("CommsConsole"));
                                if (building != null)
                                {
                                    Job job = new Job(JobDefOf.JobUseCommsConsoleMole, building);
                                    __instance.jobs.TryTakeOrderedJob(job);
                                }
                            }
                        }
                        if (__instance.needs.mood.CurInstantLevel > 0.8f)
                        {
                            Events.TenantWantToJoin(__instance);
                        }

                        //Calculate mood
                        if (__instance.needs.mood.CurInstantLevel > 0.66f)
                        {
                            tenantComp.HappyMoodCount++;
                            tenantComp.RecentBadMoodsCount = 0;
                        }
                        else if (__instance.needs.mood.CurInstantLevel < __instance.mindState.mentalBreaker.BreakThresholdMinor)
                        {
                            tenantComp.SadMoodCount++;
                            tenantComp.RecentBadMoodsCount++;
                            if (tenantComp.RecentBadMoodsCount > 5)
                            {
                                Events.ContractConclusion(__instance, true);
                            }
                        }
                        else
                        {
                            tenantComp.NeutralMoodCount++;
                            tenantComp.RecentBadMoodsCount = 0;
                        }
                    }
                }
            }
        }
Esempio n. 45
0
 public void setGarrisonBuilding(Building b)
 {
     mGarrisonBuilding = b;
 }