public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
var expression = value as BindingExpression;
if (expression == null)
{
// TODO: Can't handle this
return ValidationResult.ValidResult;
}
var sourceItem = typeof(BindingExpression).GetProperty("SourceItem", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(expression, null);
if (sourceItem == null || sourceItem.GetType().Name == "NullDataItem" || sourceItem.GetType() == previousSourceItemType)
{
return ValidationResult.ValidResult;
}
previousSourceItemType = sourceItem.GetType();
var propertyName = (string)typeof(BindingExpression).GetProperty("SourcePropertyName", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(expression, null);
if (propertyName == null)
{
return ValidationResult.ValidResult;
}
var properties = TypeDescriptor.GetProperties(sourceItem);
var property = properties.Find(propertyName, true);
if (property == null)
{
// TODO: Can't handle this
return ValidationResult.ValidResult;
}
var context = new FieldContext(field, editorBinding, sourceItem, propertyName, property);
fieldBuilder.Configure(context);
return ValidationResult.ValidResult;
}
public override IFieldContext NewFieldContext(string id)
{
FieldContext field = new FieldContext();
field.ID = id;
field.MessageSource = this.MessageSource;
return field;
}
public void DeleteOneMetadataFromInside(FieldContext fc)
{
MetadataContext mc = new MetadataContext(fc.FieldId, fc.FieldInfo.FieldName, fc.Values[0].TextContext.Text, fc.Document.DocumentId);
listOfMetadata = ReadAllFields().ToList();
var metadataContext = listOfMetadata.First(l => l.Id.Equals(mc.Id));
listOfMetadata.Remove(metadataContext);
WriteJsonFile(listOfMetadata);
}
/// <summary>
/// Creates the appropriate editor from the context. If the return value is null, another
/// <see cref="IEditorStrategy"/> will be asked. The returned value should be fully configured
/// and bound.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// A control that will be used for editing the field, or null if this strategy cannot be
/// used for this field.
/// </returns>
public object CreateEditor(FieldContext context)
{
var textBox = new TextBox { Width = 200 };
context.WhenHasAttribute<StringLengthAttribute>(sl => textBox.MaxLength = sl.MaximumLength);
BindingOperations.SetBinding(textBox, TextBox.TextProperty, context.Binding);
return textBox;
}
private static PartialResults CheckDiagonals(FourInARowState state)
{
PartialResults summary = new PartialResults();
//// from left bottom to right top
for (Int32 startY = 0, mStartY = FourInARowState.RowCount - WinningCount + 1; startY < mStartY; startY++)
{
FieldContext context = new FieldContext();
for (Int32 x = 0, y = startY, my = FourInARowState.RowCount, mx = FourInARowState.ColumnCount; y < my && x < mx /* && y < state.LastEmptyRow */; x++, y++)
{
ProcessField(state, x, y, context);
}
summary.Add(context.PartialResults);
}
for (Int32 startX = 1, mStartX = FourInARowState.ColumnCount - WinningCount + 1; startX < mStartX; startX++)
{
FieldContext context = new FieldContext();
for (Int32 x = startX, y = 0, my = FourInARowState.RowCount, mx = FourInARowState.ColumnCount; y < my && x < mx /* && y < state.LastEmptyRow */; x++, y++)
{
ProcessField(state, x, y, context);
}
summary.Add(context.PartialResults);
}
//// from right bottom to left top
for (Int32 startY = 0, mStartY = FourInARowState.RowCount - WinningCount + 1; startY < mStartY; startY++)
{
FieldContext context = new FieldContext();
for (Int32 x = FourInARowState.ColumnCount - 1, y = startY, my = FourInARowState.RowCount; y < my && x >= 0 /* && y < state.LastEmptyRow */; x--, y++)
{
ProcessField(state, x, y, context);
}
summary.Add(context.PartialResults);
}
for (Int32 sStartX = FourInARowState.ColumnCount - 2, mStartX = WinningCount - 1; sStartX >= mStartX; sStartX--)
{
FieldContext context = new FieldContext();
for (Int32 x = sStartX, y = 0, my = FourInARowState.RowCount; y < my && x >= 0 /* && y < state.LastEmptyRow */; x--, y++)
{
ProcessField(state, x, y, context);
}
summary.Add(context.PartialResults);
}
return(summary);
}
/// <summary>
/// 起こりうる最大連鎖回数を分析します
/// </summary>
/// <returns>起こりうる最大連鎖回数</returns>
/// <param name="context">フィールド状態</param>
/// <param name="player">プレイヤ</param>
public int Analyze(FieldContext context, Player.Index player)
{
int maxChain = 0;
// 移動可能パターンを取得
var movePatterns = CompleteReadingHelper.GetAllMovePatterns();
// 分析対象の移動可能スライムを生成
var usingSlimes = context.UsingSlimes;
var slimePatterns = new List <Slime[]>();
slimePatterns.Add(new[] { usingSlimes[0], usingSlimes[1] });
slimePatterns.Add(new[] { usingSlimes[2], usingSlimes[3] });
// 自動移動機能を生成
var updater = DiProvider.GetContainer().GetInstance <AutoMoveAndDropUpdater>();
updater.Inject(context.UsingSlimes);
// 各移動可能スライムの全パターンを試していく
foreach (var slimePattern in slimePatterns)
{
var _context = context.DeepCopy();
// 移動可能スライムを書き換える
for (var movable = 0; movable < MovableSlime.Length; movable++)
{
var org = _context.MovableSlimes[player.ToInt()][(int)movable];
var valid = (org.Index == FieldContextConfig.MaxHiddenUnitIndex &&
org.Position == FieldContextConfig.MovableSlimeInitialShiftAfterDroped + (FieldContextConfig.OneLineBitCount * (int)movable));
if (!valid)
{
return(0);
}
// 元の移動可能スライムを消す
_context.SlimeFields[player.ToInt()][org.Slime][org.Index] &= ~(1u << org.Position);
// 色を書き換える
org.Slime = slimePattern[(int)movable];
}
// 自動移動を実行
foreach (var movePattern in movePatterns)
{
var _movedContext = _context.DeepCopy();
var param = new AutoMoveAndDropUpdater.Param()
{
Pattern = movePattern,
};
updater.Update(_movedContext, player, param);
maxChain = Math.Max(maxChain, param.Chain);
}
}
// 試行内の最大連鎖数を返却
return(maxChain);
}
/// <summary>
/// Checks whether a field with the specified Id has already been defined.
/// </summary>
/// <param name="container">The field container to search.</param>
/// <param name="fieldId">The field Id to check for.</param>
/// <param name="node">The field being defined.</param>
/// <returns>
/// true if the field Id has already been defined, false otherwise.
/// </returns>
public static bool IsFieldIdAlreadyDefined(
this IFieldContainer container,
int fieldId,
FieldContext node)
{
return(container.Fields
.Where(item => item.FieldId == fieldId)
.FirstOrDefault().Node != node);
}
/// <summary>
/// Checks whether the field has already been defined.
/// </summary>
/// <param name="container">The field container to search.</param>
/// <param name="name">The name of the field.</param>
/// <param name="node">The field being defined.</param>
/// <returns>
/// true if the field name has already been defined, false otherwise.
/// </returns>
public static bool IsFieldNameAlreadyDefined(
this IFieldContainer container,
string name,
FieldContext node)
{
return(container.Fields
.Where(item => item.Name == name)
.FirstOrDefault().Node != node);
}
public static T AddGraphQlError <T>(this T exception, string errorCode, FieldContext fieldContext)
where T : Exception
{
var error = new GraphQlError(errorCode);
error.Fixup(fieldContext);
exception.Data[errorKey] = new[] { error };
return(exception);
}
public bool SaveNode(Node node, dynamic rawdata, List <Field> fields = null)
{
if (fields != null)
{
throw new Exception("SaveNodeData is not consumed in the right way!");
foreach (var field in fields)
{
try
{
var value = rawdata[field.Id.ToString()];
//raw data has to be processed before saving to database
var fieldtype = _fieldrepository.GetFieldType(field);
var type = System.Type.GetType(fieldtype.ClassPath);
FieldContext _context = new FieldContext(field.Id, fieldtype.Id, field.FieldName);
_context.RawData = value;
_context.OldValue = null;
var fieldobj = Activator.CreateInstance(type, _context);
var mi = type.GetMethod("GetValue");
var data = mi.Invoke(fieldobj, null).ToString();
_currentrepository.SaveNodeData(node, field, data);
}
catch (Exception e) { }
}
}
else
{
var list = ((INodeRepository)_currentrepository).GetNodeFieldMapData(node);
foreach (var nodefield in list)
{
try
{
var value = rawdata[nodefield.Id.ToString()];
//raw data has to be processed before saving to database
var fieldtype = _fieldrepository.GetFieldType(nodefield.Field);
var type = System.Type.GetType(fieldtype.ClassPath);
FieldContext _context = new FieldContext(nodefield.Field.Id, fieldtype.Id, nodefield.Field.FieldName);
_context.RawData = value;
_context.OldValue = nodefield.NodeData;
var fieldobj = Activator.CreateInstance(type, _context);
//invoke GetValue to get the processed value.
var mi = type.GetMethod("GetValue");
var data = mi.Invoke(fieldobj, null).ToString();
//call SaveValue to save addition information.
mi = type.GetMethod("SaveValue");
mi.Invoke(fieldobj, null);
nodefield.NodeData = data;
_currentrepository.SaveNodeData(nodefield);
}
catch (Exception e) { }
}
}
return(true);
}
/// <inheritdoc/>
public Field FindSymbolForNode(FieldContext node)
{
if (this.FindSymbolForNode((IParseTree)node) is Field field)
{
return(field);
}
return(null);
}
public void TestBuildFieldContext_Struct()
{
string testSrcML = "<struct>struct <name>foo</name> <block>{<public type=\"default\"><decl_stmt><decl><type><name>int</name></type> <name>a</name></decl>;</decl_stmt></public>}</block>;</struct>";
XElement xml = XElement.Parse(string.Format(srcMLFormat, testSrcML), LoadOptions.PreserveWhitespace);
FieldContext fc1 = new FieldContext("int", true, "foo");
FieldContext fc2 = ContextBuilder.BuildFieldContext(xml.Descendants(SRC.Declaration).First());
Assert.IsTrue(FieldContextsAreEqual(fc1, fc2));
}
public void TestBuildFieldContext_Global()
{
string testSrcML = "<decl_stmt><decl><type><name>int</name></type> <name>a</name> =<init> <expr><lit:literal type=\"number\">42</lit:literal></expr></init></decl>;</decl_stmt>";
XElement xml = XElement.Parse(string.Format(srcMLFormat, testSrcML), LoadOptions.PreserveWhitespace);
FieldContext fc1 = new FieldContext("int", true, "");
FieldContext fc2 = ContextBuilder.BuildFieldContext(xml.Descendants(SRC.Declaration).First());
Assert.IsTrue(FieldContextsAreEqual(fc1, fc2));
}
/// <summary>
/// 評価値を取得する
/// </summary>
/// <returns></returns>
protected override double GetEvaluate(FieldContext context)
{
StopWatchLogger.StartEventWatch("SearchBestPointer-GetEvaluate");
var score = this.Evaluator.Evaluate(context);
StopWatchLogger.StopEventWatch("SearchBestPointer-GetEvaluate");
FileHelper.WriteLine($"score:{score} direction:{context.OperationDirection}");
return(score * this.GetParity(context));
}
public void DeleteOneContextFromInside(FieldContext fc)
{
string hashName = CalculateMD5Hash(fc.FieldInfo.FieldName + fc.Document.DocumentId);
string hashPath = GetFilePathUsingFullNameOfFile(hashName);
if (hashPath != null)
{
File.Delete(hashPath);
MetadataStorage.DeleteOneMetadataFromInside(fc);
}
}
/// <summary>
/// Creates the appropriate editor from the context. If the return value is null, another
/// <see cref="IEditorStrategy"/> will be asked. The returned value should be fully configured
/// and bound.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// A control that will be used for editing the field, or null if this strategy cannot be
/// used for this field.
/// </returns>
public object CreateEditor(FieldContext context)
{
var textBox = new TextBox {
Width = 200
};
context.WhenHasAttribute <StringLengthAttribute>(sl => textBox.MaxLength = sl.MaximumLength);
BindingOperations.SetBinding(textBox, TextBox.TextProperty, context.Binding);
return(textBox);
}
public void AddMetadata(FieldContext fc)
{
MetadataContext mc = new MetadataContext(fc.FieldId, fc.FieldInfo.FieldName, fc.Values[0].TextContext.Text, fc.Document.DocumentId);
List<string> listOfMetadataHashId = GetListOfMetadataHashId();
string hash = CalculateMD5Hash(mc.Id);
if (!listOfMetadataHashId.Contains(hash + ".json"))
{
listOfMetadata.Add(mc);
WriteJsonFile(listOfMetadata);
}
}
public void TestConstructSwum()
{
string testSrcML = "<class>class <name>foo</name> <block>{<private type=\"default\"><decl_stmt><decl><type><name>int</name></type> <name>a</name></decl>;</decl_stmt></private>}</block>;</class>";
XElement xml = XElement.Parse(string.Format(srcMLFormat, testSrcML), LoadOptions.PreserveWhitespace);
FieldContext fc = ContextBuilder.BuildFieldContext(xml.Descendants(SRC.Declaration).First());
FieldDeclarationNode fdn = new FieldDeclarationNode("a", fc);
FieldRule rule = new FieldRule(posData, tagger, splitter);
rule.ConstructSwum(fdn);
Console.WriteLine(fdn.ToString());
}
/// <summary>
/// 指定したバージョンのベクトルを取得します。
/// </summary>
/// <param name="version">ベクトルバージョン</param>
/// <param name="context">フィールド状態</param>
/// <returns>ベクトル</returns>
public SparseVector <double> GetVector(AiPlayer.Version version, FieldContext context)
{
if (!this.VectorGens.ContainsKey(version))
{
throw new ArgumentException("ベクトル種別が不正です");
}
var vector = this.GetVector(this.VectorGens[version], context);
return(vector);
}
/// <summary>
/// TODO:勝ったプレイヤを取得します。
/// </summary>
/// <param name="context">フィールド状態</param>
/// <returns>勝ったプレイヤ</returns>
private static Player.Index GetWinPlayer(FieldContext context)
{
if (LastWinCount[(int)Player.Index.First] != context.WinCount[(int)Player.Index.First])
{
return(Player.Index.First);
}
else
{
return(Player.Index.Second);
}
}
/// <summary>
/// Asks each <see cref="IEditorStrategy">editor strategy</see> in the list whether it can create a
/// control for editing the given field, returning the first non-null result. If none of the editors
/// can provide an editor, the fallback editor is asked.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public object GetEditor(FieldContext context)
{
foreach (var selector in this)
{
var editor = selector.CreateEditor(context);
if (editor != null)
{
return(editor);
}
}
return(fallback.CreateEditor(context));
}
protected Field SetupField(FieldContext fieldNode, Struct @struct, int?fieldId = null, string name = null)
{
var field = new FieldBuilder()
.SetNode(fieldNode)
.SetFieldId(fieldId)
.SetName(name)
.Build();
this.binderProvider.GetBinder(fieldNode).Returns(this.fieldBinder);
this.fieldBinder.Bind <Field>(fieldNode, @struct).Returns(field);
return(field);
}
/// <summary>
/// パターンを生成します。
/// </summary>
/// <param name="context">フィールド状態</param>
/// <returns>現在のフィールド状態のパターンリスト</returns>
public SparseVector <double> GetNext(FieldContext context)
{
Debug.Assert(this.HasInjected, "依存性の注入が完了していません");
int maxIndex = 0;
var dic = new Dictionary <int, double>();
for (var i = 0; i < Player.Length; i++)
{
var player = (Player.Index)i;
if (!this.MyConfig.BothPlayer && player != context.OperationPlayer)
{
// 片方のみ対象の場合は、操作対象プレイヤのみを対象にする
continue;
}
var colorSlimeFields = context.SlimeFields[player.ToInt()].
Where(f => context.UsingSlimes.Contains(f.Key)).
Select(f => f.Value.Skip(FieldContextConfig.MinDisplayUnitIndex).ToArray()).ToArray();
var obsSlimeFields = context.SlimeFields[player.ToInt()].
Where(f => f.Key == Slime.Obstruction).
Select(f => f.Value.Skip(FieldContextConfig.MinDisplayUnitIndex).ToArray()).ToArray();
foreach (var pattern in this.MyConfig.Patterns)
{
foreach (var fields in colorSlimeFields)
{
this.AddPatternCount(fields, pattern, maxIndex, dic);
}
maxIndex += (int)pattern.MaxIndex + 1;
if (!this.MyConfig.ContainsObstructionSlime)
{
// おじゃまスライムを含めない場合はスキップ
continue;
}
foreach (var fields in obsSlimeFields)
{
this.AddPatternCount(fields, pattern, maxIndex, dic);
}
maxIndex += (int)pattern.MaxIndex + 1;
}
}
var vector = new SparseVector <double>(maxIndex, dic, this.MyConfig.SparseValue);
return(vector);
}
private object ArrayToOutputRec(FieldContext context, TypeRef typeRef, object value)
{
if (value == null)
{
return(null);
}
var list = value as IList;
var result = new object[list.Count];
var elemTypeRef = typeRef.Inner;
for (int i = 0; i < result.Length; i++)
{
result[i] = ToOutputRec(context, elemTypeRef, list[i]);
}
return(result);
}
/// <summary>
/// フレーム毎に実行される更新処理を行います。
/// </summary>
private static void Update()
{
if (IsEnd(Context))
{
Console.WriteLine(string.Format("{0}Pの勝ちです。", (int)GetWinPlayer(Context) + 1));
return;
}
// 移動方向無コマンドの実行
Context.OperationDirection = Direction.None;
var c = ConsoleClientDiProvider.GetContainer().GetInstance <NativeCommand>();
c.Command = Command.Move;
c.Context = Context.DeepCopy();
c.Context.OperationPlayer = NoneMovePlayer;
NoneMovePlayer = Player.GetOppositeIndex(NoneMovePlayer);
FileHelper.WriteLine("----- 移動方向無コマンドの実行 -----");
FileHelper.WriteLine(Sender.Send(Context));
Context = Receiver.Receive(c);
// 入力を受け付けたコマンドの実行
IsBlockedKeyInfo = true;
var keys = KeyInfos.Select(k => k).ToList();
KeyInfos.Clear();
IsBlockedKeyInfo = false;
foreach (var key in keys)
{
if (!KeyMap.ContainsKey(key.Key))
{
continue;
}
Context.OperationPlayer = KeyMap.GetPlayer(key.Key);
Context.OperationDirection = KeyMap.GetDirection(key.Key);
c = ConsoleClientDiProvider.GetContainer().GetInstance <NativeCommand>();
c.Command = Command.Move;
c.Context = Context.DeepCopy();
FileHelper.WriteLine("----- 入力を受け付けたコマンドの実行 -----");
FileHelper.WriteLine(Sender.Send(Context));
Context = Receiver.Receive(c);
}
// 画面描画
FieldContextWriter.Write(Context);
}
public FieldContext field()
{
FieldContext _localctx = new FieldContext(_ctx, State);
EnterRule(_localctx, 4, RULE_field);
try {
State = 27;
_errHandler.Sync(this);
switch (_input.La(1))
{
case TEXT:
EnterOuterAlt(_localctx, 1);
{
State = 24; Match(TEXT);
}
break;
case STRING:
EnterOuterAlt(_localctx, 2);
{
State = 25; Match(STRING);
}
break;
case T__0:
case T__1:
case T__2:
EnterOuterAlt(_localctx, 3);
{
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
/// <summary>
/// Creates the appropriate editor from the context. If the return value is null, another
/// <see cref="IEditorStrategy"/> will be asked. The returned value should be fully configured
/// and bound.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// A control that will be used for editing the field, or null if this strategy cannot be
/// used for this field.
/// </returns>
public object CreateEditor(FieldContext context)
{
if (context.PropertyDescriptor.PropertyType != typeof (bool))
{
return null;
}
// Hide the header:
context.Field.Header = "";
var displayName = context.PropertyDescriptor.Attributes.OfType<DisplayNameAttribute>().FirstOrDefault();
var checkBox = new CheckBox();
checkBox.Content = displayName == null ? context.PropertyName : displayName.DisplayName;
BindingOperations.SetBinding(checkBox, ToggleButton.IsCheckedProperty, context.Binding);
return checkBox;
}
public FieldContext field()
{
FieldContext _localctx = new FieldContext(Context, State);
EnterRule(_localctx, 4, RULE_field);
try {
State = 28;
switch (TokenStream.La(1))
{
case TEXT:
EnterOuterAlt(_localctx, 1);
{
State = 25; Match(TEXT);
}
break;
case String:
EnterOuterAlt(_localctx, 2);
{
State = 26; Match(String);
}
break;
case T__0:
case T__1:
case COMMA:
EnterOuterAlt(_localctx, 3);
{
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
private static PartialResults CheckColumns(FourInARowState state)
{
PartialResults summary = new PartialResults();
for (Int32 x = 0, mx = FourInARowState.ColumnCount; x < mx; x++)
{
FieldContext context = new FieldContext();
for (Int32 y = 0, my = FourInARowState.RowCount; y < my /* && y < state.LastEmptyRow */; y++)
{
ProcessField(state, x, y, context);
}
summary.Add(context.PartialResults);
}
return(summary);
}
/// <summary>
/// 指定した種別の評価値を取得します。
/// </summary>
/// <param name="version">バージョン</param>
/// <param name="context">フィールド状態</param>
/// <returns>評価値</returns>
public double GetEval(AiPlayer.Version version, FieldContext context)
{
double ev = 0.0d;
switch (version)
{
case AiPlayer.Version.V1_0:
case AiPlayer.Version.V2_0:
ev = this.LinearRegressionEvaluators[version].Evaluate(context);
ev += this.AliveEvaluators[version].Sum(e => e.Evaluate(context));
ev += this.RandomEvaluator.Evaluate(this.RandomParams[version]);
break;
default:
throw new ArgumentException("バージョンが不正です");
}
return(ev);
}
/// <summary>
/// Creates the appropriate editor from the context. If the return value is null, another
/// <see cref="IEditorStrategy"/> will be asked. The returned value should be fully configured
/// and bound.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// A control that will be used for editing the field, or null if this strategy cannot be
/// used for this field.
/// </returns>
public object CreateEditor(FieldContext context)
{
if (context.PropertyDescriptor.PropertyType != typeof(bool))
{
return(null);
}
// Hide the header:
context.Field.Header = "";
var displayName = context.PropertyDescriptor.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
var checkBox = new CheckBox();
checkBox.Content = displayName == null ? context.PropertyName : displayName.DisplayName;
BindingOperations.SetBinding(checkBox, ToggleButton.IsCheckedProperty, context.Binding);
return(checkBox);
}
private bool FieldContextsAreEqual(FieldContext fc1, FieldContext fc2)
{
if (fc1 == null && fc2 == null)
{
return(true);
}
if ((fc1 == null) ^ (fc2 == null))
{
return(false);
}
if (fc1.DeclaringClass != fc2.DeclaringClass ||
fc1.IdType != fc2.IdType ||
fc1.IdTypeIsPrimitive != fc2.IdTypeIsPrimitive)
{
return(false);
}
return(true);
}
protected Field SetupField(
FieldContext fieldNode,
Exception exception,
int?fieldId = null,
string name = null,
FieldRequiredness requiredness = FieldRequiredness.Default)
{
var field = new FieldBuilder()
.SetNode(fieldNode)
.SetFieldId(fieldId)
.SetRequiredness(requiredness)
.SetName(name)
.Build();
this.binderProvider.GetBinder(fieldNode).Returns(this.fieldBinder);
this.fieldBinder.Bind <Field>(fieldNode, exception).Returns(field);
return(field);
}
// Recursive method, for high-rank arrays
private object ToOutputRec(FieldContext context, TypeRef typeRef, object value)
{
if (value == null)
{
return(null);
}
if (typeRef.Kind == TypeKind.NonNull)
{
typeRef = typeRef.Inner;
}
if (Handler.IsFlagSet && typeRef.Rank == 1)
{
return(Handler.ConvertFlagsEnumValueToOutputStringList(value));
}
if (typeRef.IsList)
{
return(ArrayToOutputRec(context, typeRef, value));
}
return(Handler.ConvertEnumValueToOutputString(value));
}
/// <summary>
/// 自動移動を実行します。
/// </summary>
/// <param name="context">フィールド状態</param>
/// <param name="player">プレイヤ</param>
/// <param name="param">パラメータ</param>
public void Update(FieldContext context, Player.Index player, Param param)
{
Debug.Assert(this.HasInjected, "依存性の注入が完了していません");
if (!(context.FieldEvent[(int)context.OperationPlayer] == FieldEvent.None || context.FieldEvent[(int)context.OperationPlayer] == FieldEvent.End))
{
return;
}
#if DEBUG
for (var i = 0; i < context.UsingSlimes.Length; i++)
{
Debug.Assert(context.UsingSlimes[i] == this.UsingSlimes[i], "使用スライムが不正です");
}
#endif
// 回転と横移動
foreach (var p in param.Pattern)
{
context.OperationDirection = p;
context = this.Game.Update(context);
}
// 最後まで落下させる
while (!context.Ground[(int)player] && context.FieldEvent[(int)player] != FieldEvent.End)
{
context.OperationDirection = Direction.Down;
context = this.Game.Update(context);
}
// 接地したら即設置完了にする
context.BuiltRemainingTime[(int)player] = -1;
context.OperationDirection = Direction.None;
context = this.Game.Update(context);
// イベント終了 or ゲーム終了まで更新する
while (context.FieldEvent[(int)player] != FieldEvent.None && context.FieldEvent[(int)player] != FieldEvent.End)
{
context = this.Game.Update(context);
param.Chain = Math.Max(param.Chain, context.Chain[player.ToInt()]);
}
Debug.Assert(context.FieldEvent[(int)player] == FieldEvent.None || context.FieldEvent[(int)player] == FieldEvent.End, "イベント発生中はありえません");
}
public Label Parse(IEnumerable <Token> tokens)
{
var label = new Label();
FieldContext = new FieldContext(new Font("A", Orientation.Normal, 5, 9));
foreach (var token in tokens)
{
Execute(token, label);
}
if (_unSupported.Count <= 0)
{
return(label);
}
var sb = new StringBuilder();
foreach (var token in _unSupported.GroupBy(p => p.Command).Select(g => g.First()).ToList())
{
sb.Append(token.Command + Environment.NewLine);
}
throw new ArgumentException(sb.ToString());
}
public FieldContext field()
{
FieldContext _localctx = new FieldContext(Context, State);
EnterRule(_localctx, 8, RULE_field);
try {
EnterOuterAlt(_localctx, 1);
{
State = 74; Match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
/// <summary>
/// Creates the appropriate editor from the context. If the return value is null, another
/// <see cref="IEditorStrategy"/> will be asked. The returned value should be fully configured
/// and bound.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>
/// A control that will be used for editing the field, or null if this strategy cannot be
/// used for this field.
/// </returns>
public object CreateEditor(FieldContext context)
{
if (!context.PropertyDescriptor.PropertyType.IsEnum)
return null;
var enumType = context.PropertyDescriptor.PropertyType;
var items = new List<EnumOption>();
foreach (var value in Enum.GetValues(enumType))
{
var displayName = enumType.GetField(value.ToString()).GetCustomAttributes(typeof(EnumDisplayNameAttribute), true).OfType<EnumDisplayNameAttribute>().FirstOrDefault();
var item = new EnumOption();
item.DisplayName = displayName == null ? value.ToString() : displayName.DisplayName;
item.Value = value;
items.Add(item);
}
var comboBox = new ComboBox();
comboBox.SelectedValuePath = "Value";
comboBox.DisplayMemberPath = "DisplayName";
comboBox.ItemsSource = items;
BindingOperations.SetBinding(comboBox, Selector.SelectedValueProperty, context.Binding);
return comboBox;
}
public DynamicNodeValue(FieldContext _context)
{
context = _context;
}
public void AddOneContextFromInside(FieldContext fc)
{
TryCreateFolderIfNotExist(storagePath);
WriteJsonFile(fc);
MetadataStorage.AddOneMetadataFromInside(fc);
}
private void WriteJsonFile(FieldContext fc)
{
string hashName = CalculateMD5Hash(fc.FieldInfo.FieldName + fc.Document.DocumentId);
string filePath = storagePath + hashName + ".json";
VerifyFileExistenceAndRemoveIfExists(filePath);
using (TextWriter textWriter = File.CreateText(filePath))
{
var context = JsonConvert.SerializeObject(fc, Formatting.Indented);
textWriter.Write(context);
}
}
public virtual string TransformValue(FieldContext field, StaticNodeValue sv)
{
return QuoteStr(sv.Value);
}
protected virtual string RenderField(StringBuilder sb, FieldContext field)
{
if(field.Value == null)
throw new ApplicationException("Field has no value: " + field.Name);
List<TerminalNodeValue> vals = new List<TerminalNodeValue>(field.Value.Terminals);
if(vals.Count == 0)
throw new ApplicationException("Field has no value: " + field.Name);
if(vals.Count == 1 && vals[0] is StaticNodeValue)
return TransformValue(field, (StaticNodeValue)vals[0]);
StringBuilder valStr = new StringBuilder();
int c = 0;
foreach(TerminalNodeValue tsv in vals) {
if(tsv is NullNodeValue)
return "NULL";
else if(field.ObjectClassField.Atts["DataType"] != "string") {
if(c > 0)
throw new ApplicationException("Cannot have compound values for datatype: " + field.ObjectClassField.Atts["DataType"]);
if(tsv is StaticNodeValue) {
if(field.ObjectClassField.Atts["DataType"] == "int")
valStr.Append(Convert.ToString(Convert.ToInt32(((StaticNodeValue)tsv).Value)));
else
valStr.Append(QuoteStr(((StaticNodeValue)tsv).Value));
}
else if(tsv is DynamicNodeValue)
valStr.Append("@" + ((DynamicNodeValue)tsv).Context.Name);
}
else {
if(c++ > 0)
valStr.Append(" + ");
if(tsv is StaticNodeValue)
valStr.Append(QuoteStr(((StaticNodeValue)tsv).Value));
else if(tsv is DynamicNodeValue)
valStr.AppendFormat("cast(@{0} as varchar)", ((DynamicNodeValue)tsv).Context.Name);
}
}
return valStr.ToString();
}
public void AddContext(FieldContext fc)
{
TryCreateFolderIfNotExist(storagePath);
WriteJsonFile(fc);
MetadataStorage.AddMetadata(fc);
}
/// <summary>
/// Creates a new FieldDeclarationNode.
/// </summary>
/// <param name="name">The name of the declared field.</param>
/// <param name="context">The surrounding context of the field.</param>
public FieldDeclarationNode(string name, FieldContext context)
: base(name) {
this.Context = context;
}