private void CreateInitialData()
        {
            _rootEquipment = new Equipment {Name = "Motor"};
            _childEquipment1 = new Equipment {Name = "AC Motor"};
            _childEquipment2 = new Equipment {Name = "DC Motor"};
            _grandCildEquipment1_1 = new Equipment {Name = "AC LV Motor"};
            _grandCildEquipment1_2 = new Equipment {Name = "AC MV Motor"};
            _grandCildEquipment1_3 = new Equipment {Name = "AC HV Motor"};
            _grandCildEquipment2_1 = new Equipment {Name = "DC LV Motor"};
            _grandCildEquipment2_2 = new Equipment {Name = "DC MV Motor"};

            _rootEquipment.AddChildEquipment(_childEquipment1);
            _rootEquipment.AddChildEquipment(_childEquipment2);
            _childEquipment1.AddChildEquipment(_grandCildEquipment1_1);
            _childEquipment1.AddChildEquipment(_grandCildEquipment1_2);
            _childEquipment1.AddChildEquipment(_grandCildEquipment1_3);
            _childEquipment2.AddChildEquipment(_grandCildEquipment2_1);
            _childEquipment2.AddChildEquipment(_grandCildEquipment2_2);

            using (var session = _sessionFactory.OpenSession())
            {
                session.Save(_rootEquipment);
                session.Flush();
            }
        }

 ///<summary>Inserts one Equipment into the database.  Returns the new priKey.</summary>
 internal static long Insert(Equipment equipment)
 {
     if(DataConnection.DBtype==DatabaseType.Oracle) {
         equipment.EquipmentNum=DbHelper.GetNextOracleKey("equipment","EquipmentNum");
         int loopcount=0;
         while(loopcount<100){
             try {
                 return Insert(equipment,true);
             }
             catch(Oracle.DataAccess.Client.OracleException ex){
                 if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
                     equipment.EquipmentNum++;
                     loopcount++;
                 }
                 else{
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else {
         return Insert(equipment,false);
     }
 }

 public static Equipment get() {
   if(_instance == null) {
     Logger.Log("Equipment::get was badly initialized", Logger.Level.WARN);
     _instance = GameObject.Find(gameObjectName).GetComponent<Equipment>();
   }
   return _instance;
 }

 public List<Equipment> AddEquipment(Equipment equipment)
 {
     List<Equipment> toBeRemoved = new List<Equipment>();
     for(int i=0;i<equipped.Count;i++){
         if(equipped[i].GetType() == equipment.GetType()){
             AddToInventory(equipped[i],1);
             equipped[i] = equipment;
             toBeRemoved.Add(equipped[i]);
             return null;
         }
         if(equipment is TwoHanded){
             if(equipped[i] is OneHanded)
                 toBeRemoved.Add(equipped[i]);
         }
         if(equipment is OneHanded){
             if(equipped[i] is TwoHanded)
                 toBeRemoved.Add(equipped[i]);
         }
     }
     foreach(Equipment equip in toBeRemoved){
         AddToInventory(equip,1);
         equipped.Remove(equip);
     }
     equipped.Add(equipment);
     return null;
 }

    //dan
    //protected PlayerRotation PlayerRot;
    // =============================================================================
    // =============================================================================
    // METHODS UNITY ---------------------------------------------------------------
    protected virtual void Awake()
    {
        Config = GameObject.FindWithTag ( "Config" ).GetComponent<Config> ();

        Trans = transform;
        Audio = audio;
        NetView = networkView;

        GameObject player = GameObject.FindWithTag ( "Player" );
        PlayerMov = player.GetComponent<PlayerMovement> ();

        //dan
        //TODO: fix player Rotation
        //PlayerRot = player.GetComponent<PlayerRotation> ();
        Equip = gameObject.GetComponent<Equipment> ();

        if ( DisplayLeft )
        {
            DisplayLeft.renderer.material.color = DisplayColor;
        }
        if ( DisplayRight )
        {
            DisplayRight.renderer.material.color = DisplayColor;
        }
    }

 private void ProcessEqu(Equipment sourceEquipment, int _playerId)
 {
     equipment = new InvItem[sourceEquipment.GetSlotCount ()];
     for (int i = 0; i < sourceEquipment.GetSlotCount (); i++) {
         equipment [i] = CreateInvItem (sourceEquipment.GetSlotItem (i), 1, _playerId);
     }
 }

 /**
  * Attempt to add an item to this grid in any spot that it will fit
  * Return false if no space
  */
 public override bool AddItem(Equipment item)
 {
     InventoryGridItem gridItem = item.inventoryGridItem;
     for (int i = 0; i + gridItem.width <= numTilesX; i++) {
         for (int j = 0; j + gridItem.height <= numTilesY; j++) {
             // If the item fits, add it to the inventory
             if (CanItemFit(item.inventoryGridItem, i, j)) {
                 bool inserted = base.AddItem(item);
                 // If it was successfully added, add it to the grid
                 if (inserted) {
                     gridItem.x = i;
                     gridItem.y = j;
                     for (int k = 0; k < gridItem.width; k++)
                         for (int q = 0; q < gridItem.height; q++)
                             gridFills[gridItem.x + k, gridItem.y + q] = true;
                     // Auto add it to an available hotkey slot if the item is flagged to do so
                     if (item.inventoryGridItem.autoAddToHotkey) {
                         for (int q = 0; q < numHotkeys; q++) {
                             if (hotkeyItems[q] == null) {
                                 hotkeyItems[q] = item;
                                 break;
                             }
                         }
                     }
                 }
                 return inserted;
             }
         }
     }
     return false;
 }

 public override void OnEnable()
 {
     e = target as Equipment;
     fdb = e.fdb;
     base.OnEnable();
     name = "Equipment";
 }

        public MTBISummaryManager(Equipment.EquipmentBase equipment)
        {
            EquipmentInstance = equipment;
            AlarmList = new List<string>();
            Load();

            Run = true;

            Thread thread = new Thread(
                    delegate()
                    {
                        while (Run)
                        {
                            Action log;

                            if (_logQueue.Count > 0)
                            {
                                lock (threadRoot)
                                {
                                    log = _logQueue.Dequeue();
                                }

                                log();
                            }

                            Thread.Sleep(10);
                        }
                    });

            thread.Start();
        }

 public void RemoveEquipment(Equipment equipment)
 {
     if(equipped.Contains(equipment)){
         AddToInventory(equipment,1);
         equipped.Remove(equipment);
     }
 }

    void AssignAttributes(Equipment e)
    {
        // Get base stat from equipment designation
        //foreach (KeyValuePair<string, StatTemplate> pair in e.Designation.BaseStats) {
        //  var statKey = pair.Key;
        //  var statTemplate = pair.Value;

        //  float val = BaseStatValue(statKey);

        //  float eqTypeMultiplier = EquipmentTypeMultiplier(e.Type, statKey);
        //  val *= eqTypeMultiplier;

        //  float rarityMultiplier = RarityMultiplier(e.Rarity, Stat.SignForValue(val));
        //  val *= rarityMultiplier;

        //  // Prefix
        //  var prefixRoll = tpd.RollPercent(e.Rarity.prefixChance);
        //  if (prefixRoll) {
        //    e.Prefix = EquipmentModifier.Prefix();
        //    ApplyModifier(e, e.Prefix);
        //  }

        //  // Suffix
        //  var suffixRoll = tpd.RollPercent(e.Rarity.suffixChance);
        //  if (suffixRoll) {
        //    e.Suffix = EquipmentModifier.Suffix();
        //    ApplyModifier(e, e.Suffix);
        //  }

        //  e.Stats[statTemplate.key] = new Stat(statTemplate.key, val);
        //}
    }

    public void Login()
    {
        if (username.text.Trim ().Equals ("")) {
            ShowHint.Hint (StringCollection.NEEDUSERNAME);
            return;
        }

        if (password.text.Trim ().Equals ("")) {
            ShowHint.Hint (StringCollection.NEEDPASSWORD);
            return;
        }

        bool vali = false;

        //去服务器验证
        vali = true;
        //如果成功
        if (vali) {

            bool haveInfo = true;

            if (haveInfo) {
                //如果有玩家信息,加载并跳转城市场景

                //从服务器端获取玩家数据初始化
                gData.isPlayer = false; //初始的时候总是佣兵模式，玩家在线后与其他玩家组队，才会变成联机模式
                gData.characterList = new List<Character> ();

                Equipment e = new Equipment (1, 2, 0, 0, Equipment.EquipPos.BODY, "2", "学者的思考", 1, 200);
                List<Equipment> eList = new List<Equipment> ();
                eList.Add (e);

                Character c = new Character (2000, 30, 100, 0, 0, "zhouhui", true, 50, 0, ProFactory.getPro ("Geomancer", "1"), 10, 0, eList, -1);

                HealthItem item = new HealthItem (Item.RangeType.SINGLE, 10, "1", "单体治疗药剂", 50);
                List<Baggrid> bgList = new List<Baggrid> ();
                Baggrid bg = new Baggrid (item, 2);
                bgList.Add (bg);

                //		Equipment e2 = new Equipment(2,3,Equipment.EquipPos.BODY,"3","学者的幻想",1,500);
                //		Baggrid bg2 = new Baggrid (e2, 1);
                //		bgList.Add (bg2);

                c.BgList = bgList;
                gData.characterList.Add (c);
                Character c2 = new Character (0, 40, 100, 0, 0, "unity", false, 100, 100, ProFactory.getPro ("Settler", "1"), 1, 0, null, -1);
                gData.characterList.Add (c2);

                Application.LoadLevel ("city");

            } else {
                //如果没有,跳转角色创建场景
                Application.LoadLevel ("create");
            }

        } else {
            ShowHint.Hint (StringCollection.INVALIDACCOUNT);
        }
    }

 public void Initialize(Equipment.DependencyEquipments.TrayLoadingUnit unit)
 {
     UIUtility.SetActionsOfGeneralPartToButton(buttonClamp, unit.LeftTrayClamp, "EXTEND", "RETRACT");
     UIUtility.SetActionsOfGeneralPartToButton(buttonFirstLifter, unit.FirstTrayLifter, "UP", "DOWN");
     UIUtility.SetActionsOfGeneralPartToButton(buttonSecondLifter, unit.SecondTrayLifter, "UP", "DOWN");
     UIUtility.SetActionsOfGeneralPartToButton(buttonTraySeperator, unit.FrontLeftTraySeperator , "UP", "DOWN");
     UIUtility.SetActionsOfOneWayMotorPartToButton(buttonConveyor, unit.Conveyor);
 }

 public override void LoadContent(Equipment owner, ContentManager content, ManagerMap managerMap, ManagerCamera managerCamera, Entities entities)
 {
     base.LoadContent(owner, content, managerMap, managerCamera,entities);
     AddComponent(new Sprite(ManagerContent.LoadTexture("sword"), 16, 16, new Vector2(0, 0)));
     AddComponent(new Animation(16,16,2,100));
     AddComponent(new Camera(managerCamera));
     GuiTexture = ManagerContent.LoadTexture("sword_gui");
 }

 public override void LoadContent(Equipment owner, ContentManager content, ManagerMap managerMap, ManagerCamera managerCamera, Entities entities)
 {
     base.LoadContent(owner,content,managerMap,managerCamera,entities);
     AddComponent(new Sprite(content.Load<Texture2D>("boomerang"),16,16,new Vector2(0,0)));
     AddComponent(new Collision(managerMap,entities));
     AddComponent(new Animation(16,16,3));
     AddComponent(new Camera(managerCamera));
     GuiTexture = content.Load<Texture2D>("boomerang_gui");
 }

        public void AddEquipment(Equipment equipment)
        {
            if (equipment == null)
            {
                throw new ArgumentNullException("The equipment connot be null.");
            }

            this.equipments.Add(equipment);
        }

 public void AddWeapon(Equipment equip, int numb, bool right, int wActNumb, SpFunctions sp)
 {
     int i,j;
     int cLen = equip.bag [numb].GetComponent<ItemClass>().coordinates.Length/3;
     CharacterAnimator anim = equip.gameObject.GetComponent<CharacterAnimator> ();
     ItemClass item = equip.bag [numb].GetComponent<ItemClass> ();
     GameObject weapon;
     weapon = Instantiate (right == true ? item.objects [0] : item.objects [1],
                           new Vector3 (equip.gameObject.transform.position.x + item.coordinates [0]*equip.gameObject.transform.lossyScale.x,
                  equip.gameObject.transform.position.y + item.coordinates [1]*equip.gameObject.transform.lossyScale.y,
                  equip.gameObject.transform.position.z + item.coordinates [2]),
                           equip.gameObject.transform.rotation)as GameObject;
     weapon.transform.localScale=new Vector3(weapon.transform.localScale.x*sp.realSign(equip.gameObject.transform.localScale.x),
                                             weapon.transform.localScale.y,
                                             weapon.transform.localScale.z);
     weapon.transform.SetParent (equip.gameObject.transform);
     sp.SetMoveset(equip.gameObject,weapon.GetComponent<WeaponClass>());
     j = 0;
     while (j<item.parametres1.Length) {
         if (item.parametres1 [j] != 0)
             break;
         anim.allParts [item.parametres2 [j]].parts.Add (weapon.GetComponent<PartConroller> ());
         j++;
     }
     for (i=2; i<equip.bag[numb].GetComponent<ItemClass>().objects.Length; i++) {
         listOfObjects.Add (GameObject.Instantiate (item.objects [i],
                                                    new Vector3 (equip.gameObject.transform.position.x + item.coordinates [i * cLen]*equip.gameObject.transform.lossyScale.x,
                      equip.gameObject.transform.position.y + item.coordinates [i * cLen + 1]*equip.gameObject.transform.lossyScale.y,
                      equip.gameObject.transform.position.z + item.coordinates [i * cLen + 2]),
                                                    equip.gameObject.transform.rotation)as GameObject);
         listOfObjects [i-2].transform.localScale=new Vector3(listOfObjects [i-2].transform.localScale.x*sp.realSign(equip.gameObject.transform.localScale.x),
                                                              listOfObjects [i-2].transform.localScale.y,
                                                              listOfObjects [i-2].transform.localScale.z);
         listOfObjects [i-2].transform.SetParent (equip.gameObject.transform);
         listOfObjects[i-2].GetComponent<PartConroller>().right=(right==true? 1: -1);
         while (j<item.parametres1.Length) {
             if (item.parametres1 [j] != i)
                 break;
             anim.allParts [item.parametres2 [j]].parts.Add (listOfObjects [i-2].GetComponent<PartConroller> ());
             j++;
         }
     }
     equip.gameObject.GetComponent<Actions> ().activities [wActNumb].weapon = weapon.GetComponent<WeaponClass> ();
     equip.gameObject.GetComponent<Actions> ().activities [wActNumb].actMode = numb;
     if (weapon.GetComponent<WeaponClass> ().handEmployment == 2)
     {
         equip.gameObject.GetComponent<Actions> ().activities [wActNumb-1].weapon = weapon.GetComponent<WeaponClass> ();
         equip.gameObject.GetComponent<Actions> ().activities [wActNumb-1].actMode = numb;
         equip.leftWeapon=weapon.GetComponent<WeaponClass>();
     }
     if (right)
         equip.rightWeapon=weapon.GetComponent<WeaponClass>();
     else
         equip.leftWeapon=weapon.GetComponent<WeaponClass>();
     listOfObjects.Clear ();
 }

 // Use this for initialization
 void Start()
 {
     ViewParameter viewParameter = ViewParameter.Instance;
     int ueid = viewParameter.getIntValue ("ueid");
     int urid = viewParameter.getIntValue ("urid");
     Hashtable userRolesMap = User.Instance.userRolesMap;
     userRole = (UserRole)userRolesMap [urid];
     e = (Equipment) (User.Instance).equipMap [ueid];
     dis = SlgDispatcher.Instance;
 }

    void Start()
    {
        _equipment = GetComponent<Equipment>();
        _camera = Camera.main.GetComponent<CameraController>();

        rightHand = _equipment.First(slot => ((slot.region == EquipmentRegion.Hands) &&
                                              slot.tags.Contains(EquipmentTag.Held, EquipmentTag.Right)));
        leftHand  = _equipment.First(slot => ((slot.region == EquipmentRegion.Hands) &&
                                              slot.tags.Contains(EquipmentTag.Held, EquipmentTag.Left)));
    }

 public ActionResult Edit(Equipment equipment)
 {
     if (ModelState.IsValid)
     {
         context.Entry(equipment).State = EntityState.Modified;
         context.SaveChanges();
         return RedirectToAction("Index");
     }
     return View(equipment);
 }