public Inventory(int ID,
     Enums.Entity_Type Entity_Type,
     int Container_ID,
     int Capacity)
 {
     NewInventory(ID, Entity_Type, Container_ID, Capacity);
 }

 public MetaDataToEntity(int ID,
     Enums.Entity_Type Entity_Type,
     string MetaData_Key,
     string Value)
 {
     NewMetaDataToEntity(ID, Entity_Type, MetaData_Key, Value);
 }

    public void Change(Enums.Suit cardSuit, Enums.Number cardNumber)
    {
        suit = cardSuit;
           number = cardNumber;

           Refresh();
    }

    public override Action_Base CreateNewAction(Enums.ActionType _type, GameObject _object)
    {
        switch (_type)
        {
            case Enums.ActionType.action_click:
                switch(_object.tag)
                {
                    case "attackButton":
                        return new Action_ChangeState(Enums.GameStates.gamestate_AimAttack);
                        break;

                    case "buildButton":
                        if (_object.GetComponent<CanBuildTurret>() != null)
                        {
                            return new Action_Build(Enums.EntityTypes.turret);
                        }
                        else if (_object.GetComponent<CanBuildCrystal>() != null)
                        {
                            return new Action_Build(Enums.EntityTypes.crystal);
                        }
                        break;
                }
                break;
            case Enums.ActionType.action_backUp:
                return new Action_ChangeState(Enums.GameStates.gamestate_waitingForCommand);
                break;
        }
        return null;
    }

    /// <summary>
    /// ルームCP内BattleState要素変更メソッド
    /// <para>　引数に設定された内容でBattleStateの値を更新する。</para>
    /// <para>　また、本BattleStateの更新はマスタークライアント側が行う。</para>
    /// </summary>
    /// <param name="newValue">更新する新しいBattleStateの値</param>
    public void SetBattleStateInRoomCP(Enums.BattleState newValue)
    {
        // マスタークライアントでない者が設定しようとした場合は抜ける
        if (!PhotonNetwork.isMasterClient) return;

        roomCP["BS"] = newValue;
    }

 public double this[Enums.Velocity index]
 {
     get
     {
         switch (index)
         {
             case Enums.Velocity.MeterPerSecond:
                 return value;
             case Enums.Velocity.KilometerPerHour:
                 return value*Constants.Hour/Constants.Kilometer;
             case Enums.Velocity.Knots:
                 return value*Constants.Hour/Constants.NMile;
             default:
                 return 0;
         }
     }
     set
     {
         switch (index)
         {
             case Enums.Velocity.MeterPerSecond:
                 this.value = value;
                 break;
             case Enums.Velocity.KilometerPerHour:
                 this.value = value*Constants.Kilometer/Constants.Hour;
                 break;
             case Enums.Velocity.Knots:
                 this.value = value*Constants.NMile/Constants.Hour;
                 break;
             default:
                 break;
         }
     }
 }

        public static string MesFechaString(Enums.Meses mes)
        {
            switch (mes)
            {
                case Enums.Meses.Enero:
                    return Properties.Resources.rxEnero;
                case Enums.Meses.Febrero:
                    return Properties.Resources.rxFebrero;
                case Enums.Meses.Marzo:
                    return Properties.Resources.rxMarzo;
                case Enums.Meses.Abril:
                    return Properties.Resources.rxAbril;
                case Enums.Meses.Mayo:
                    return Properties.Resources.rxMayo;
                case Enums.Meses.Junio:
                    return Properties.Resources.rxJunio;
                case Enums.Meses.Julio:
                    return Properties.Resources.rxJulio;
                case Enums.Meses.Agosto:
                    return Properties.Resources.rxAgosto;
                case Enums.Meses.Setiembre:
                    return Properties.Resources.rxSetiembre;
                case Enums.Meses.Octubre:
                    return Properties.Resources.rxOctubre;
                case Enums.Meses.Noviembre:
                    return Properties.Resources.rxNoviembre;
                case Enums.Meses.Diciembre:
                    return Properties.Resources.rxDiciembre;
            }

            return string.Empty;
        }

    //Change the game state (occurs on next frame)
    public void ChangeGameState(Enums.GameStateNames nextState)
    {
        if (!m_gameStateDictionary.ContainsKey(nextState))
            return;

        m_nextGameStateIndex = nextState;
    }

 public static bool InvalidColumnValue(
     object fieldValue, Enums.Operator op,
     string valueToCompare, Type fieldValueType)
 {
     return ConditionEvaluator.MatchItemValueBasedOnOperatorAndValueType(
         op, valueToCompare, fieldValue, fieldValueType);
 }

        public static bool InvalidLengthValue(int length, Enums.Operator op,
            string lengthToCompare)
        {
            int intlengthToCompare;

            if (int.TryParse(lengthToCompare, out intlengthToCompare))
            {
                switch (op)
                {
                    case Enums.Operator.Equal:
                        return length == intlengthToCompare;
                    case Enums.Operator.NotEqual:
                        return length != intlengthToCompare; ;
                    case Enums.Operator.GreaterThan:
                        return length > intlengthToCompare;
                    case Enums.Operator.LessThan:
                        return length < intlengthToCompare;
                    default:
                        return false;
                }
            }
            else
            {
                return true;
            }
        }

 public double this[Enums.Time index]
 {
     get
     {
         switch (index)
         {
             case Enums.Time.Second:
                 return value;
             case Enums.Time.Minutes:
                 return value/Constants.Minutes;
             case Enums.Time.Hour:
                 return value/Constants.Hour;
             default:
                 return 0;
         }
     }
     set
     {
         switch (index)
         {
             case Enums.Time.Second:
                 this.value = value;
                 break;
             case Enums.Time.Minutes:
                 this.value = value*Constants.Minutes;
                 break;
             case Enums.Time.Hour:
                 this.value = value*Constants.Hour;
                 break;
             default:
                 break;
         }
     }
 }

 //заполнение параметров контейнера
 protected ContainersCore(Enums.ContainerType containerType, int id, double area, double dencity)
 {
     this.containerType = containerType;
     this.area = area;
     this.dencity = dencity;
     this.id = id;
 }

        //===================================================
        // PUBLIC METHODS
        //===================================================
        /// <summary>
        /// Creates a turret.
        /// </summary>
        /// <param name="turretType">Type of the turret.</param>
        /// <param name="position">The position.</param>
        public void CreateTurret( Enums.TurretType turretType, Vector3 position )
        {
            GameObject tempGO = null;
            switch( turretType ) {
                case Enums.TurretType.Type_A:
                    tempGO = turretPrefabA;
                    break;
                case Enums.TurretType.Type_B:
                    tempGO = turretPrefabB;
                    break;
                case Enums.TurretType.Type_C:
                    tempGO = turretPrefabC;
                    break;
                case Enums.TurretType.Type_D:
                    tempGO = turretPrefabD;
                    break;
                default:
                    tempGO = turretPrefabA;
                    break;
            }

            GameObject turretGO = Instantiate( tempGO, position, Quaternion.identity ) as GameObject;
            turretGO.transform.SetParent( turretContainer );

            turrets.Add( turretGO );
        }

    public void Move(Enums.ActionType _type)
    {
        int _oldX;
        int _oldY;
        switch(_type)
        {
            case Enums.ActionType.action_right:
                _oldX = storage.xPos;
                _oldY = storage.yPos;

                storage.GameWorld.RemoveObjectFromTile(_oldX, _oldY, this.gameObject);
                storage.xPos = _oldX + 1;
                storage.yPos = storage.GameWorld.GetColumnHeight(storage.xPos);
                storage.GameWorld.AddObjectToTile(storage.xPos, storage.yPos, this.gameObject);

                this.gameObject.transform.Translate(1,storage.yPos - _oldY,0);
                break;
            case Enums.ActionType.action_left:
                _oldX = storage.xPos;
                _oldY = storage.yPos;

                storage.GameWorld.RemoveObjectFromTile(_oldX, _oldY, this.gameObject);
                storage.xPos = _oldX - 1;
                storage.yPos = storage.GameWorld.GetColumnHeight(storage.xPos);
                storage.GameWorld.AddObjectToTile(storage.xPos, storage.yPos, this.gameObject);

                this.gameObject.transform.Translate(-1,storage.yPos - _oldY,0);
                break;
        }
    }

 public ReturnObject(Enums.Return_Status Return_Status,
     string Friendly_Message,
     string Technical_Message,
     object Return_Object)
 {
     NewReturnObject(Return_Status, Friendly_Message, Technical_Message, Return_Object, string.Empty);
 }

 //===================================================
 // PRIVATE METHODS
 //===================================================
 /// <summary>
 /// Dispatches the turret type.
 /// </summary>
 /// <param name="turretType">Type of the turret.</param>
 private void TurretTypeSelected( Enums.TurretType turretType  )
 {
     if( EventBuy != null ) {
         EventBuy( turretType, position );
     }
     OnClose();
 }

        public void ShowMsg(Enums.LogType type, string txt)
        {
            switch (type)
            {
                case Enums.LogType.Login:
                    Dispatcher.Invoke(new Action(() => listBox1.Items.Add(txt)));
                    break;
                case Enums.LogType.Logout:
                    Dispatcher.Invoke(new Action(() => listBox1.Items.Remove(txt)));
                    break;
                default:

                    Brush brush = Brushes.Black;
                    if (type == Enums.LogType.Start)
                    {
                        brush = Brushes.Red;
                    }
                    else if (type == Enums.LogType.Error)
                    {
                        brush = Brushes.Blue;
                    }
                    Dispatcher.Invoke(new Action(() =>
                        {
                            var p = new Paragraph(); // Paragraph 类似于 html 的 P 标签
                            var r = new Run(txt); // Run 是一个 Inline 的标签
                            p.Inlines.Add(r);
                            p.Foreground = brush;//设置字体颜色
                            // 除了设置属性，事件也可以在这里设置

                            Doc.Blocks.Add(p);
                            richTextBox1.Document = Doc;
                        }));
                    break;
            }
        }

        public Log GetNextPrevImage(int? id, Enums.Arrow? arrow, string person)
        {
            using (var unitOfWork = new UnitOfWork())
            {
                var repository = new LogRepository(unitOfWork.Session);

                if (id == null)
                {
                    return repository.Query(r => r.PersonName == person).FirstOrDefault();
                }
                else
                {
                    switch (arrow)
                    {
                        case Enums.Arrow.Left:
                            return repository.Query(r => r.PersonName == person && r.Id < id).LastOrDefault();
                            break;
                        case Enums.Arrow.Right:
                            return repository.Query(r => r.PersonName == person && r.Id > id).FirstOrDefault();
                            break;
                        default:
                            break;
                    }
                }

                return repository.Query(r => r.PersonName == person).First();
            }
        }

 public Enums.WallOrientation FindOppositeWall(Enums.WallOrientation wall)
 {
     if (wall == Enums.WallOrientation.North) return Enums.WallOrientation.South;
     if (wall == Enums.WallOrientation.East) return Enums.WallOrientation.West;
     if (wall == Enums.WallOrientation.South) return Enums.WallOrientation.North;
     return Enums.WallOrientation.East;
 }

 public override Action_Base CreateNewAction(Enums.ActionType _type, GameObject _object)
 {
     switch(_type)
     {
         case Enums.ActionType.action_right:
             if (_object.GetComponent<GroundMovement>() != null || _object.GetComponent<FlightMovement>() != null)
             {
                 return new Action_Move(_type, _object);
             }
             break;
         case Enums.ActionType.action_left:
             if (_object.GetComponent<GroundMovement>() != null || _object.GetComponent<FlightMovement>() != null)
             {
                 return new Action_Move(_type, _object);
             }
             break;
         case Enums.ActionType.action_up:
             if (_object.GetComponent<GroundMovement>() != null || _object.GetComponent<FlightMovement>() != null)
             {
                 return new Action_Move(_type, _object);
             }
             break;
         case Enums.ActionType.action_down:
             if (_object.GetComponent<GroundMovement>() != null || _object.GetComponent<FlightMovement>() != null)
             {
                 return new Action_Move(_type, _object);
             }
             break;
         case Enums.ActionType.action_openActMenu:
             return new Action_ChangeState(Enums.GameStates.gamestate_SelectActionMenu);
             break;
     }
     return null;
 }