public AGI_Fields(Fields gi_fields)
        {
            fields = new int[F_MAX_X * F_MAX_Y];

            /* 初期化 */
            int cnt = 0;
            for (int i = 0 ; i < fields.Length; i++)
            {
                if (i < F_MAX_X)
                {
                    fields[i] = WALL;
                }
                else if (i > (F_MAX_X * (F_MAX_Y - 1)))
                {
                    fields[i] = WALL;
                }
                else if (((i % F_MAX_X) == 0) || ((i % F_MAX_X) == (F_MAX_X - 1)))
                {
                    fields[i] = WALL;
                }
                else
                {
                    if (gi_fields.GetFieldsInfo(cnt) == 0)
                    {
                        fields[i] = EMPUTY;
                    }
                    else
                    {
                        fields[i] = OBJECT;
                    }
                    cnt++;
                }
            }
        }

        public static GameStates GetGameState(Fields.Field field, Player.Player currentPlayer)
        {
            if (currentPlayer == null)
            {
                return GameStates.Laufend;
            }

            foreach (char symbol in GetAllPlayerSymbols(field))
            {
                if (WinChecker.Pruefe(symbol, field))
                {
                    if (currentPlayer.Symbol == symbol)
                    {
                        return GameStates.Gewonnen;
                    }
                    else
                    {
                        return GameStates.Verloren;
                    }
                }
            }

            if (!FieldHelper.HasEmptyFields(field))
            {
                return GameStates.Unentschieden;
            }
            return GameStates.Laufend;
        }

        public IParameters Read(TflTransform transform) {
            var parameters = new Parameters.Parameters(new DefaultFactory(_logger));

            foreach (var p in transform.Parameters) {
                if (string.IsNullOrEmpty(p.Field) && (string.IsNullOrEmpty(p.Name) || string.IsNullOrEmpty(p.Value))) {
                    throw new TransformalizeException(_logger, "The entity {0} has a {1} transform parameter without a field attribute, or name and value attributes.  Entity parameters require one or the other.", _entity.Alias, transform.Method);
                }

                var fields = new Fields(_entity.Fields, _entity.CalculatedFields);
                if (!string.IsNullOrEmpty(p.Field)) {
                    if (fields.FindByParamater(p).Any()) {
                        var field = fields.FindByParamater(p).Last();
                        var name = string.IsNullOrEmpty(p.Name) ? field.Alias : p.Name;
                        parameters.Add(field.Alias, name, null, field.Type);
                    } else {
                        if (!p.Field.StartsWith("Tfl")) {
                            _logger.EntityWarn(_entity.Name, "The entity {0} has a {1} transform parameter that references field {2}.  This field hasn't been defined yet in {0}.", _entity.Alias, transform.Method, p.Field);
                        }
                        var name = string.IsNullOrEmpty(p.Name) ? p.Field : p.Name;
                        parameters.Add(p.Field, name, p.HasValue() ? p.Value : null, "System.String");
                    }
                } else {
                    var parameter = new Parameter(p.Name, p.Value) {
                        SimpleType = Common.ToSimpleType(p.Type),
                        ValueReferencesField = p.HasValue() && fields.Find(p.Value).Any()
                    };
                    parameters.Add(p.Name, parameter);
                }
            }

            return parameters;
        }

        public TruncateOperation(string entityName, Fields fields, Fields calculatedFields = null)
            : base(string.Empty, string.Empty) {

            EntityName = entityName;

            foreach (Field field in fields.WithString()) {
                _aliases.Add(field.Alias);
                var value = field.Length.Equals("max", IC) ? Int32.MaxValue.ToString(CultureInfo.InvariantCulture) : field.Length;
                if (CanChangeType(value, typeof(int))) {
                    _lengthMap[field.Alias] = Convert.ToInt32(value);
                } else {
                    throw new TransformalizeException(Logger, "Can not change field {0}'s length of '{0}' to an integer.  Please use an integer or the keyword: max.", field.Alias, value);
                }
            }

            if (calculatedFields != null) {
                foreach (var field in calculatedFields.WithString()) {
                    if (!_aliases.Contains(field.Alias)) {
                        _aliases.Add(field.Alias);
                        var value = field.Length.Equals("max", IC) ? Int32.MaxValue.ToString(CultureInfo.InvariantCulture) : field.Length;
                        if (CanChangeType(value, typeof(int))) {
                            _lengthMap[field.Alias] = Convert.ToInt32(value);
                        } else {
                            throw new TransformalizeException(Logger, "Can not change field {0}'s length of '{1}' to an integer.  Please use an integer or the keyword: max.", field.Alias, value);
                        }
                    }
                }
            }

            base.OnFinishedProcessing += StringLengthOperation_OnFinishedProcessing;
        }

        public IParameters Read(TflTransform transform) {
            var parameters = new Parameters.Parameters(_defaultFactory);
            var fields = new Fields(_process.OutputFields(), _process.CalculatedFields.WithoutOutput());

            foreach (var p in transform.Parameters) {

                if (!string.IsNullOrEmpty(p.Field)) {
                    if (fields.FindByParamater(p).Any()) {
                        var field = fields.FindByParamater(p).Last();
                        var name = string.IsNullOrEmpty(p.Name) ? field.Alias : p.Name;
                        parameters.Add(field.Alias, name, null, field.Type);
                    } else {
                        _process.Logger.Warn("A {0} transform references {1}, but I can't find the definition for {1}.\r\nYou may need to define the entity attribute in the parameter element.\r\nOr, set the output attribute to true in the field element. Process transforms rely on fields being output.\r\nOne other possibility is that the participates in a relationship with another field with the same name and Transformalize doesn't know which one you want.  If that's the case, you have to alias one of them.", transform.Method, p.Field);
                        var name = p.Name.Equals(string.Empty) ? p.Field : p.Name;
                        parameters.Add(p.Field, name, p.HasValue() ? p.Value : null, p.Type);
                    }
                } else {
                    var parameter = new Parameter(p.Name, p.Value) {
                        SimpleType = Common.ToSimpleType(p.Type),
                        ValueReferencesField = p.HasValue() && fields.Find(p.Value).Any()
                    };
                    parameters.Add(p.Name, parameter);
                }
            }

            return parameters;
        }

        public void SetFieldValue(Fields aField, string aValue)
        {
            InputType inputType = GetInputType(aField);
            string locator = GetLocator(aField, LocatorType.Edit);

            SetFieldValue(inputType, locator, aValue);
        }

 private static string SerializeFields(Fields? fieldsToFacet)
 {
     if (fieldsToFacet  == Fields.Ip) { return "ip"; }
      if (fieldsToFacet  == Fields.InputName) { return "inputname"; }
      if (fieldsToFacet == Fields.Text) { return "text"; }
      return null;
 }

 public LogLoadOperation(Entity entity) {
     _entity = entity;
     var fields = new Fields(entity.Fields, entity.CalculatedFields).WithOutput();
     _columns.AddRange(fields.Aliases());
     _guids.AddRange(fields.WithGuid().Aliases());
     _byteArrays.AddRange(fields.WithBytes().Aliases());
 }

        public string GetFieldValue(Fields aField)
        {
            InputType inputType = GetInputType(aField);
            string locator = GetLocator(aField, LocatorType.Edit);

            return GetFieldValue(inputType, locator);
        }

 public Fields Fields() {
     var fields = new Fields();
     foreach (var join in Join) {
         fields.Add(join.Fields());
     }
     return fields;
 }

        protected override void PrepareSchema() {
            NotifyBatchSize = (int)LogRows;
            BatchSize = _batchSize;

            var fromFields = new Fields(_entity.Fields, _entity.CalculatedFields).WithOutput().AddBatchId(_entity.Index, false);
            if (_entity.IsMaster() && _entity.Delete)
                fromFields.AddDeleted(_entity.Index, false);

            foreach (var field in fromFields) {
                Schema[field.Alias] = field.SystemType;
            }

            var toFields = new SqlServerEntityAutoFieldReader().Read(Connection, _entity.ProcessName, _entity.Prefix, _entity.OutputName(), string.Empty, _entity.IsMaster());
            foreach (var from in fromFields) {
                if (toFields.HaveField(from.Alias)) {
                    var to = toFields.Find(from.Alias).First();
                    if (!to.SimpleType.Equals(from.SimpleType)) {
                        if (!to.SimpleType.Equals("byte[]") && from.SimpleType.Equals("rowversion")) {
                            throw new TransformalizeException(Logger, EntityName, "{0} has a matching {1} fields, but different types: {2} != {3}.", TargetTable, from.Alias, from.SimpleType, to.SimpleType);
                        }
                    }
                } else {
                    throw new TransformalizeException(Logger, EntityName, "{0} does not have a matching {1} field.", TargetTable, from.Alias);
                }
            }
        }

        public Fields Read(AbstractConnection connection, string process, string prefix, string name, string schema, bool isMaster = false) {
            var fields = new Fields();

            using (var cn = connection.GetConnection()) {
                cn.Open();
                var sql = PrepareSql();
                connection.Logger.EntityDebug(name, sql);

                var results = cn.Query(sql, new { name, schema });

                foreach (var result in results) {
                    var columnName = result.COLUMN_NAME;
                    var type = GetSystemType(result.DATA_TYPE);
                    var length = result.CHARACTER_MAXIMUM_LENGTH == "0" || result.CHARACTER_MAXIMUM_LENGTH == "-1" ? "64" : result.CHARACTER_MAXIMUM_LENGTH;
                    var fieldType = (bool)result.IS_PRIMARY_KEY ? (isMaster ? FieldType.MasterKey : FieldType.PrimaryKey) : FieldType.NonKey;
                    var field = new Field(type, length, fieldType, true, string.Empty) {
                        Name = columnName,
                        Entity = name,
                        Process = process,
                        Index = Convert.ToInt16(result.ORDINAL_POSITION - 1),
                        Schema = schema,
                        Input = true,
                        Precision = result.NUMERIC_PRECISION,
                        Scale = result.NUMERIC_SCALE,
                        Alias = prefix + columnName
                    };
                    fields.Add(field);
                }
            }

            return fields;
        }

 public static void ExecuteEdit(IWin32Window owner, Fields fields)
 {
     using (var form = new ViewFieldsForm())
     {
         form.Init(fields, true);
         form.ShowDialog(owner);
     }
 }

 public EntityKeysToOperations(ref Entity entity, AbstractConnection connection, bool firstRun, string operationColumn = "operation") {
     _entity = entity;
     _connection = connection;
     _firstRun = firstRun;
     _operationColumn = operationColumn;
     _key = _entity.PrimaryKey.WithInput();
     _fields = _entity.Fields.WithInput();
 }

 private SlowCompositeReaderWrapper(CompositeReader reader)
     : base()
 {
     @in = reader;
     fields = MultiFields.GetFields(@in);
     liveDocs = MultiFields.GetLiveDocs(@in);
     @in.RegisterParentReader(this);
 }

    public Configuration(string configFilename)
    {
      this.m_configFilename = configFilename;
      Debug.Log("Config file set to: {0}.", this.m_configFilename);

      /* Default field initialization. */
      this.m_currentSerializer = new DataContractJsonSerializer(typeof(Fields));
      this.m_configFields = new Fields();
    }

        public void SelectFieldDeclaredOnBaseReturnsCorrectField()
        {
            var sut = new Fields<SubClassWithFields>();
            var expected = typeof(SubClassWithFields).GetField("ReadOnlyText");

            var actual = sut.Select(x => x.ReadOnlyText);

            Assert.Equal(expected, actual);
        }

        public static string Select(Fields fields, string leftTable, string rightTable, AbstractConnection connection, string leftSchema, string rightSchema) {
            var maxDop = connection.MaxDop ? "OPTION (MAXDOP 2);" : ";";
            var sqlPattern = "\r\nSELECT\r\n    {0}\r\nFROM {1} l\r\nINNER JOIN {2} r ON ({3})\r\n" + maxDop;

            var columns = new FieldSqlWriter(fields).Input().Select(connection).Prepend("l.").ToAlias(connection.L, connection.R, true).Write(",\r\n    ");
            var join = new FieldSqlWriter(fields).FieldType(FieldType.MasterKey, FieldType.PrimaryKey).Name(connection.L, connection.R).Input().Set("l", "r").Write(" AND ");

            return string.Format(sqlPattern, columns, SafeTable(leftTable, connection, leftSchema), SafeTable(rightTable, connection, rightSchema), @join);
        }

        public DapperBulkUpdateOperation(AbstractConnection connection, Entity entity) {
            _connection = connection;
            _tflBatchId = entity.TflBatchId;
            _fields = entity.OutputFields();
            var writer = new FieldSqlWriter(_fields);
            var sets = writer.Alias(_connection.L, _connection.R).SetParam().Write(", ", false);

            _sql = string.Format(@"UPDATE [{0}] SET {1}, TflBatchId = @TflBatchId WHERE TflKey = @TflKey;", entity.OutputName(), sets);
        }

        public void QueryFieldUsingLinqSyntaxReturnsCorrectField()
        {
            var sut = new Fields<ClassWithFields>();

            FieldInfo actual = from x in sut select x.ReadOnlyText;

            var expected = typeof(ClassWithFields).GetField("ReadOnlyText");
            Assert.Equal(expected, actual);
        }