C# BuildingType.ToString方法代码示例

	public bool BuildBuilding (BuildingType type, IVec2 Pos, int teamID, bool force)
	{
		bool isBuilding = false;

		if (CanBuild (type, Pos) || force) {
			Building newBuilding = new Building ();
			isBuilding = newBuilding.Build (type, Pos, teamID);
			if (isBuilding || force) {
				IVec2 offset = new IVec2();
				IVec2 size = Building.Sizes[type];
				for (offset.x = -size.x / 2; offset.x < size.x / 2; offset.x++) {
					for (offset.y = -size.y / 2; offset.y < size.y / 2; offset.y++) {
						IVec2 newPos = Pos + offset;
						entities [newPos.x, newPos.y] = newBuilding;
					}
				}

				GameObject obj = Instantiate (BuildingTile, Vector3.zero, Quaternion.Euler (Vector3.zero)) as GameObject;
				obj.renderer.material = Instantiate(GameObject.FindObjectOfType<MaterialSource>().getMaterialByName("Team" + (teamID + 1).ToString())) as Material;
				obj.renderer.material.mainTexture = GameObject.FindObjectOfType<MaterialSource>().getTextureByName(type.ToString());
				obj.transform.SetParent(chunks[Pos.x / 32, Pos.y / 32].transform);
				obj.transform.position = getTileCenterPos (Pos);
				Vector3 oldScale = obj.transform.localScale;
				obj.transform.localScale = new Vector3(size.x * oldScale.x, 1 * oldScale.y, size.y * oldScale.z);
				obj.name = "Building" + Buildings.Count + "(" + type.ToString() + ")";
				newBuilding.gameObject = obj;
				Buildings.Add(newBuilding);
				Players[teamID].Buildings.Add(newBuilding);
			}
		}

		return isBuilding;
	}

        /// <summary>
        /// Construct the building class instance from the given properties.
        /// </summary>
        /// <param name="type" type="BuildingType">type</param>
        /// <param name="plot">The plot of land this building stands on, note it might be bigger than the
        /// actual buildings footprint, for example if it is part of a larger complex, limit the size of
        /// buildings to have a footprint of no more than 100 square meters.</param>
        /// <param name="flags"></param>
        /// <param name="owner">The owner of the building either a user, or company (group of companies) own buildings.</param>
        /// <param name="seed"></param>
        /// <param name="height">The height in floors of the building, not each floor is approximately 3 meters in size
        /// and thus buildings are limited to a maximum height of 100 floors.</param>
        public CityBuilding( BuildingType type, BuildingPlot plot, BuildingFlags flags, 
            UUID owner, IScene scene, string name ):base(owner,new Vector3(plot.xpos,21,plot.ypos),
            Quaternion.Identity, PrimitiveBaseShape.CreateBox(), name, scene)
        {
            //  Start the process of constructing a building given the parameters specified. For
            // truly random buildings change the following value (6) too another number, this is
            // used to allow for the buildings to be fairly fixed during research and development.
            buildingSeed = 6; // TODO FIX ACCESS TO THE CityModule.randomValue(n) code.
            buildingType = type;
            buildingPlot = plot;
            buildingFlags = flags;
            //  Has a valid owner been specified, if not use the default library owner (i think) of the zero uuid.
            if (!owner.Equals(UUID.Zero))
                buildingOwner = owner;
            else
                buildingOwner = UUID.Zero;

            //  Generate a unique value for this building and it's own group if it's part of a complex,
            // otherwise use the zero uuid for group (perhaps it should inherit from the city?)
            buildingUUID = UUID.Random();
            buildingGUID = UUID.Random();

            buildingCenter = new Vector3((plot.xpos + plot.width / 2), 21, (plot.ypos + plot.depth) / 2);
            if (name.Length > 0)
                buildingName = name;
            else
                buildingName = "Building" + type.ToString();
            //  Now that internal variables that are used by other methods have been set construct
            // the building based on the type, plot, flags and seed given in the parameters.
            switch (type)
            {
                case BuildingType.BUILDING_GENERAL:
                    OpenSim.Framework.MainConsole.Instance.Output("Building Type GENERAL", log4net.Core.Level.Info);
                    createBlocky();
                    break;
                case BuildingType.BUILDING_LOCALE:
                    /*
                    switch ( CityModule.randomValue(8) )
                    {
                        case 0:
                            OpenSim.Framework.MainConsole.Instance.Output("Locale general.", log4net.Core.Level.Info);
                            createSimple();
                            break;
                        case 1:
                            OpenSim.Framework.MainConsole.Instance.Output("locale 1", log4net.Core.Level.Info);
                            createBlocky();
                            break;
                    }
                    */
                    break;
                case BuildingType.BUILDING_CIVIL:
                    createTower();
                    break;
                case BuildingType.BUILDING_MILITARY:
                    break;
                case BuildingType.BUILDING_HEALTHCARE:
                    break;
                case BuildingType.BUILDING_SPORTS:
                    break;
                case BuildingType.BUILDING_ENTERTAINMENT:
                    break;
                case BuildingType.BUILDING_EDUCATION:
                    break;
                case BuildingType.BUILDING_RELIGIOUS:
                    break;
                case BuildingType.BUILDING_MUSEUM:
                    break;
                case BuildingType.BUILDING_POWERSTATION:
                    break;
                case BuildingType.BUILDING_MINEOILGAS:
                    break;
                case BuildingType.BUILDING_ZOOLOGICAL:
                    break;
                case BuildingType.BUILDING_CEMETARY:
                    break;
                case BuildingType.BUILDING_PRISON:
                    break;
                case BuildingType.BUILDING_AGRICULTURAL:
                    break;
                case BuildingType.BUILDING_RECREATION:
                    break;
                default:
                    createSimple();
                    break;
            }
        }

        /// <summary>
        /// Gets power loss coefficient for given frequency and building type.
        /// </summary>
        public static int GetPowerLossCoefficient(BuildingType pType, double pFrequency)
        {
            IEnumerable<XElement> coefficients = XmlParser.GetElements("PowerLossCoefficient", pType.ToString());

            var coeffdesc = coefficients.ToDictionary(
                            k => double.Parse(k.Attribute("UpTo").Value) * GetFrequencyMetricsWithValues()[k.Attribute("Metric").Value],
                            v => int.Parse(v.Attribute("N").Value)).OrderBy(k => k.Key);

            var element = coeffdesc.FirstOrDefault(k => k.Key >= pFrequency);

            if (element.Key == 0 && element.Value == 0) // workaround - means that frequency is higher than any in xml
            {
                return coeffdesc.Last().Value;
            }
            else
            {
                return element.Value;
            }
        }