C# Tower类代码示例

 private GUIStyle GetInspectorStyle(Tower t, int i, bool nada)
 {
     Section s = t.GetSection(i);
     GUIStyle gStyle;
     GUIStyle yStyle;
     GUIStyle rStyle;
     if(nada) {
         gStyle = nadagStyle;
         yStyle = nadayStyle;
         rStyle = nadarStyle;
     } else {
         bool hasWeapon = s.attributes.weapon.GetWeaponType() != "Nothing";
         gStyle = hasWeapon ? wgStyle : ngStyle;
         yStyle = hasWeapon ? wyStyle : nyStyle;
         rStyle = hasWeapon ? wrStyle : nrStyle;
     }
     int stress = t.GetWeightAboveSection(i);
     int maxSP = s.attributes.sp;
     double ratio = (double)stress / (double)maxSP;
     if(ratio < 0.33) {
         return gStyle;
     } else if(ratio >= 0.33 && ratio < 0.66) {
         return yStyle;
     } else {
         return rStyle;
     }
 }

    /// <summary>
    /// Metoda odpowiedzialna za dodawanie odpowiedniego obiektu wieży, definiowanego przez argument type, w miejscu i jako dziecko obiektu parent. Zwraca koszt wieży.
    /// </summary>
    /// <param name="type">Argument typu TowerType określająca typ wieży, jak ma zostać utworzona.</param>
    /// <param name="parent">Argument typu GameObject, którego dzieckiem stanie się nowa wieża.</param>
    /// <returns>Wzraca koszt wybudowania wieży.</returns>
    public int SpawnTower(TowerType type, GameObject parent)
    {
        Tower tempTower = new Tower();
        GameObject tempGameObject = null;
        switch (type)
        {
                case TowerType.Wall:
                    tempTower = WallTower;
                    tempGameObject = Resources.Load("Prefabs/Towers/Wall") as GameObject;
                    break;
                case TowerType.Shooting:
                    tempTower = ShootingTower;
                    tempGameObject = Resources.Load("Prefabs/Towers/Shooting") as GameObject;
                    break;
                case TowerType.Aoe:
                    tempTower = AoeTower;
                    tempGameObject = Resources.Load("Prefabs/Towers/Aoe") as GameObject;
                    break;
        }
        GameObject tower = Instantiate(tempGameObject, parent.transform.position, Quaternion.identity) as GameObject;
        tower.transform.parent = parent.transform;
        tower.transform.localPosition = new Vector3(tower.transform.localPosition.x, -(2.0f/parent.transform.localScale.y), tower.transform.localPosition.z);

        return tempTower.Cost;
    }

            public void MoveDisks(int n, Tower destination, Tower buffer){
		        if (n > 0) {
                    ////////////String tag = "move_" + n + "_disks_from_" + Index + "_to_" + destination.Index + "_with_buffer_" + buffer.Index; 
                    ////////////Console.WriteLine("<" + tag + ">");
			        MoveDisks(n - 1, buffer, destination);
                    ////////////Console.WriteLine("<move_top_from_" + Index + "_to_" + destination.Index + ">");
                    ////////////Console.WriteLine("<before>");
                    ////////////Console.WriteLine("<source_print>");
                    ////////////Print();
                    ////////////Console.WriteLine("</source_print>");
                    ////////////Console.WriteLine("<destination_print>");
                    ////////////destination.Print();
                    ////////////Console.WriteLine("</destination_print>");
                    ////////////Console.WriteLine("</before>");
			        MoveTopTo(destination);
                    ////////////Console.WriteLine("<after>");
                    ////////////Console.WriteLine("<source_print>");
                    ////////////Print();
                    ////////////Console.WriteLine("</source_print>");
                    ////////////Console.WriteLine("<destination_print>");
                    ////////////destination.Print();
                    ////////////Console.WriteLine("</destination_print>");
                    ////////////Console.WriteLine("</after>");
                    ////////////Console.WriteLine("</move_top_from_" + Index + "_to_" + destination.Index + ">");
			        buffer.MoveDisks(n - 1, destination, this);
                    ////////////Console.WriteLine("</" + tag + ">");
		        }
	        }

 public AbstractBuilding Build(string type, Game.Point coords)
 {
     AbstractBuilding building = null;
     switch (type)
     {
         case ("Farm"):
             {
                 building = new Farm(coords);
                 break;
             }
         case ("Barrack"):
             {
                 building = new Barrack(coords);
                 break;
             }
         case ("BowWorkshop"):
             {
                 building = new BowWorkshop(coords);
                 break;
             }
         case ("Tower"):
             {
                 building = new Tower(coords);
                 break;
             }
         default:
             break;
     }
     return building;
 }

	// Use this for initialization
	void Start ()
	{
		if (tower == null) {
			tower = GameObject.FindGameObjectWithTag ("Tower").GetComponent<Tower> ();

		}
	}

 public void Deselect()
 {
     selectedTower = null;
     CurrentlySelectedTower = null;
     RangeCircle.transform.localScale = new Vector3(0, 0, 0);
     infoManager.DisplayInfo(null, true);
 }

 public void Add_FirstDisk_AddsOneDiskToTower()
 {
     var tower = new Tower();
     tower.AddDisk("A");
     tower.Count.ShouldEqual(1);
     tower.TopDisk().ShouldEqual("A");
 }

    public override List<Section> GetDamagedSections(Tower t, int center)
    {
        int ranNum1 = Random.Range(1, Mathf.RoundToInt(100/missPercentage) + 1);
        List<Section> list = new List<Section>();

        if (ranNum1 == 1)//If missed, miss
        {
            int ranNum2 = Random.Range(1, 3);
            CombatLog.addLine ("ran1 = " + ranNum1 + ". ran2 = " + ranNum2);
            if (ranNum2 == 1)//miss high
            {
                CombatLog.addLine("Miss Higher (blind)");
                if (center + 1 < t.GetHeight())//Missed above tower
                {
                    list.Add(t.GetSection(center+1));
                }
            }
            else//miss low
            {
                CombatLog.addLine("Miss Lower (blind)");
                if (center - 1 >= 0) //Missed below tower
                {
                    list.Add (t.GetSection(center - 1));
                }
            }
        }
        else{
                list.Add(t.GetSection(center));
            }
        return list;
    }

    public void DisplayInfo(Tower t, bool preview)
    {
        if (t == null)
        {
            NameText.text = "";
            CostText.text = "";
            DamageText.text = "";
            FireRateText.text = "";
            DPSText.text = "";
            RangeText.text = "";
            ProjectileFollowsText.text = "";
            SellText.text = "";
            SellButton.gameObject.SetActive(false);
            return;
        }
        NameText.text = t.TowerName;
        CostText.text = "Cost: $" + t.Cost.ToString();
        DamageText.text = "Damage: " + t.ProjectileDamage.ToString();
        FireRateText.text = "Fire Rate: " + t.FireRate.ToString();
        DPSText.text = "Optimal DPS: " + (t.ProjectileDamage * t.FireRate).ToString();
        RangeText.text = "Range: " + t.Range.ToString();

        if (t.ProjectileFollows)
            ProjectileFollowsText.text = "Projectile follows";
        else
            ProjectileFollowsText.text = "Projectile doesn't follow";

        if (!preview)
        {
            SellButton.gameObject.SetActive(true);
            SellText.text = "Sell For: $" + (t.Cost / 2).ToString();
        }
    }

        public void Run()
        {
            // Set up code.
            int n = 5;
            Tower[] towers = new Tower[3];
            for (int i = 0; i < 3; i++)
            {
                towers[i] = new Tower(i);
                towers[i].Label = string.Format("{0}", i); ;
            }
            for (int i = n - 1; i >= 0; i--)
            {
                towers[0].Add(i);
            }

            // Copy and paste output into a .XML file and open it with internet explorer.
            towers[0].Print();
            towers[1].Print();
            towers[2].Print();

            towers[0].MoveDisks(n, towers[2], towers[1]);

            towers[0].Print();
            towers[1].Print();
            towers[2].Print();
        }

 public virtual void SetTurret(Tower turret)
 {
     Velocity = turret.ProjectileSpeed;
     Damage = turret.Damage;
     currentTarget = turret.CurrentEnemy;
     range = Vector3.Distance(transform.position, currentTarget.transform.position);
 }

	protected void buttonAction(int i){
		if(tower == null){
			tower = GameObject.FindObjectOfType<Tower>();
		}
		switch (i){
		case 0: //Golem 1
			if(InventroyManager.instance.getCount(Element.DIRT) >= DIRT_GOLEM_COST){
				InventroyManager.instance.removeFromInventory(Element.DIRT, DIRT_GOLEM_COST);
				// make a CUTIE
				unitSpawner.spawnObject();
			}
			break;
		case 1: //Golem 2
			
			break;
		case 2: //Golem 3
			//return ;
			break;
		case 3: //Tower 1
			if(tower != null && InventroyManager.instance.getCount(Element.DIRT) >= DIRT_TOWER_COST){
				InventroyManager.instance.removeFromInventory(Element.DIRT, DIRT_TOWER_COST);			
				tower.increaseHeight();
			}
			break;
		case 4: //Tower 2
			//
			break;
		case 5: //Tower 3
			//
			break;
		}
	}

	// Update is called once per frame
	void OnMouseUp()
	{

		if (!hasTower) {

			if (GameManager.argent >= turret.Valeur()) {
				//Vector3 vect = new Vector3 (transform.position.x, transform.position.y + 0.5f, transform.position.z);

				CurrentTurret = (Tower)Instantiate (turret, transform.position, Quaternion.identity);
				CurrentTurret.name = "Turret";
				CurrentTurret.transform.parent = gameObject.transform;
				GameManager.argent -= turret.Valeur();
				hasTower = true;

			}
			else{
				this.GetComponent<Renderer>().material.mainTexture = textureError;
			}

		}
		else {
			Destroy(transform.FindChild("Turret").gameObject);
			GameManager.argent+= CurrentTurret.Valeur()/2;
			hasTower = false;
		}

	}

    public override void DoDamage(Tower t, int center, int damage, Tower self, int firingSection)
    {
        if(t.GetSections().Count >= 1) {
            //t.DamageSection(center, damage);
            Section s = t.GetSection (center);
            if (!modifiedSecs.ContainsKey(s)) //if not modified before...
            {
                ModifyWeight(s, t, damage, self);
                modifiedSecs.Add(s, 1);

            }
            else if (modifiedSecs[s] >= numTimesModifiable)
            {
                ModifyWeight(s, t, damage, self);
                modifiedSecs[s]++;
            }
            else
            {
                //TODO: Make this a warning and let them go back to their turn
                CombatLog.addLine("This section has already altered the weight " + modifiedSecs[s] + "times.");
            }
        }
        else if(center < 0) {
            CombatLog.addLine("Attack was too low");
            CombatLog.addLine("Fill the aim bar more.");
        } else if(center >= t.GetSections().Count) {
            CombatLog.addLine("Attack was too high");
            CombatLog.addLine("Lower the aim bar.");
        }
    }

    public bool Build(Tower prefab)
    {
        bool result = false;

        if (this.Tower == null && prefab == null)
        {
            GameObject.Destroy(this.gameObject);
            result = true;
        }
        else
        {
            if (this.Tower != null)
            {
                GameObject.Destroy(this.Tower.gameObject);
                result = true;
            }

            if (prefab != null)
            {
                var tower = GameObject.Instantiate<Tower>(prefab);
                tower.transform.parent = this.transform;
                tower.transform.localPosition = Vector3.zero;
                tower.transform.localRotation = Quaternion.identity;
                this.Tower = tower;

                result = true;
            }
        }
        return result;
    }