public RleSetAmount(RawNode node, IContext context)
: base(node, context)
{
_random = PathUtil.GetModelPath(GetContext(), node.GetString("random"), null).GetSelf <Random>();
var rows = node.GetNode("elements").array;
foreach (var obj in rows)
{
var pair = (List <object>)obj;
var arr = new [] { Convert.ToInt32(pair[0]), Convert.ToInt32(pair[1]) };
_list.Add(arr);
}
foreach (var pair in _list)
{
_length += pair[1];
}
}
//按照深度优先的方式搜索所有节点
private void DFS_Node(LinkType linkType, RawNode node, int[] visitedNodes, List <RawNode> nodeList)
{
visitedNodes[node.UrlId] = 1;
nodeList.Add(node);
for (int i = 0; i < NodeArray.Length; i++)
{
//访问该顶点互联的其他顶点（不能是vpx端点，且端点没被访问过）
if ((NodeArray[i].Type != EndType.VPX) && (visitedNodes[NodeArray[i].UrlId] == 0))
{
RawLink gLink = GetLinkValue(linkType, node.UrlId, i);
if (gLink != null)
{
DFS_Node(linkType, NodeArray[i], visitedNodes, nodeList);
}
}
}
}
public Game(RawNode knivesSettings, RawNode settings)
{
m_rnd = new Random();
m_settings = settings;
m_knivesSettings = knivesSettings;
m_knife = new Knife();
m_knife.throwSuccess += OnKnifeThrowSuccess;
m_score = 0;
m_perfectFlipCounter = 0;
m_knifeMode = KnifeMode.Medium;
m_stepAwardCalculator = new StepAwardCalculator(
requiredScore: m_settings.GetIntArray("flips_bonus_flips"),
awards: m_settings.GetIntArray("flips_bonus_gold")
);
}
public void EnsureEntityShouldNotBeRollbackedAfterCommitedAndViceVersa()
{
InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() =>
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Commit();
Transaction.Rollback();
}
});
Assert.That(exception.Message, Contains.Substring("The transaction was already committed or rolled back."));
InvalidOperationException exception2 = Assert.Throws <InvalidOperationException>(() =>
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Rollback();
Transaction.Commit();
}
});
Assert.That(exception2.Message, Contains.Substring("The transaction was already committed or rolled back."));
}
public static KnifeMode[] GetSupportedModes(RawNode knifeNode)
{
var modesNode = knifeNode.GetNode("modes");
var supportedModes = new KnifeMode[AllKnifeModes.Length];
int count = 0;
foreach (var mode in AllKnifeModes)
{
var key = GetKnifeModeKey(mode);
if (modesNode.CheckKey(key))
{
supportedModes[count++] = mode;
}
}
Array.Resize(ref supportedModes, count);
return(supportedModes);
}
public SomeModel(RawNode initNode, SomeModelCategories categories, SomeModelDescription description, IContext context) : base(initNode, categories, description, context)
{
int value = description.amount.Number();
var result = description.reward.Calculate();
var s = result.Serialize();
var sResult = FactoryManager.Build <RewardResult>(new RawNode(s), context);
description.reward.Award(sResult);
description.reward.Award();
description.reward.Award();
description.reward.Award();
description.reward.Award();
if (description.requirement.Check())
{
description.price.Pay();
}
}
public static ModelsPath GetModelPath(IContext context, RawNode node)
{
string path;
Random random = null;
if (node.IsDictionary() && node.CheckKey("path"))
{
path = node.GetString("path");
if (node.CheckKey("random"))
{
random = GetModelPath(context, node.GetString("random"), null).GetSelf <Random>();
}
}
else
{
path = node.ToString();
}
return(GetResult(context, path, random));
}
public void EnsureEntityIsFlushedAfterTransaction()
{
using (Transaction.Begin(true))
{
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Flush();
}
using (Transaction.Begin())
{
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
Assert.IsNull(record);
}
}
public void EnsureEntityIsCreatedRegardlessAnExceptionIsThrown()
{
Assert.Throws <Exception>(() =>
{
using (Transaction.Begin())
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
throw new Exception();
}
});
using (Transaction.Begin())
{
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
}
}
public override void Load(OGM item)
{
Transaction trans = Transaction.RunningTransaction;
string returnStatement = " RETURN node";
string match = string.Format("MATCH (node:{0}) WHERE node.{1} = {{key}}", item.GetEntity().Label.Name, item.GetEntity().Key.Name);
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("key", item.GetKey());
Dictionary <string, object?>?customState = null;
var args = item.GetEntity().RaiseOnNodeLoading(trans, item, match + returnStatement, parameters, ref customState);
var result = trans.Run(args.Cypher, args.Parameters);
RawRecord record = result.FirstOrDefault();
if (record == null)
{
item.PersistenceState = PersistenceState.DoesntExist;
return;
}
RawNode loaded = record["node"].As <RawNode>();
args.Id = loaded.Id;
args.Labels = loaded.Labels;
// HACK: To make it faster we do not copy/replicate the Dictionary here, but it means someone
// could be changing the INode content from within an event. Possibly dangerous, but
// turns out the Neo4j driver can deal with it ... for now ...
args = item.GetEntity().RaiseOnNodeLoaded(trans, args, loaded.Id, loaded.Labels, (Dictionary <string, object?>)loaded.Properties);
if (item.PersistenceState == PersistenceState.HasUid || item.PersistenceState == PersistenceState.Loaded)
{
item.SetData(args.Properties !);
item.PersistenceState = PersistenceState.Loaded;
}
}
public void EnsureEntityShouldNotBeAddedAfterRollback()
{
using (Transaction.Begin(true))
{
// Let us try to create an entity
Transaction.RunningTransaction.Run("CREATE (n:SampleEntity { name: 'Address', title: 'Developer' })");
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
RawNode loaded = record["n"].As <RawNode>();
Assert.AreEqual(loaded.Properties["name"], "Address");
Assert.AreEqual(loaded.Properties["title"], "Developer");
Transaction.Rollback();
}
using (Transaction.Begin())
{
RawResult result = Transaction.RunningTransaction.Run("Match (n:SampleEntity) Return n");
RawRecord record = result.FirstOrDefault();
Assert.IsNull(record);
}
}
static void Main(string[] args)
{
/*
* int[] r = new int[20];
* for (int j = 0; j < 10; j++)
* {
* var rnd = new FastRandom2(j);
* for (int i = 0; i < 100000000; i++)
* {
* int result = rnd.Range(1, 20);
* r[result]++;
* }
* }
*
* for (int i = 0; i < r.Length; i++)
* {
* Console.WriteLine(i + " -> " + r[i]);
* }*/
FactoryManager.SetDefaultFactory(new DefaultFactory());
FactoryManager.AddFactory(typeof(IRandomImplementation), new Factory())
.AddVariant("fast", typeof(FastRandom));
FactoryManager.AddFactory(typeof(Price), new Factory())
.AddVariant("simple-resource", typeof(SimpleResourcePrice))
.AddVariant("simple", typeof(SimpleResourcePrice))
.AddVariant("composite", typeof(CompositeReward));
FactoryManager.AddFactory(typeof(PathChoice), new Factory())
.AddVariant("rle", typeof(RleSetPathChoice))
.AddVariant("simple", typeof(SimplePathChoice));
FactoryManager.AddFactory(typeof(Reward), new Factory())
.AddVariant("simple-resource", typeof(SimpleResourceReward))
.AddVariant("composite", typeof(CompositeReward))
.AddVariant("random", typeof(RandomReward));
FactoryManager.AddFactory(typeof(RewardResult), new Factory())
.AddVariant("simple-resource", typeof(SimpleResourceRewardResult))
.AddVariant("composite", typeof(CompositeRewardResult));
FactoryManager.AddFactory(typeof(Requirement), new Factory())
.AddVariant("simple-resource", typeof(SimpleResourceRequirement))
.AddVariant("and", typeof(AndRequirement))
.AddVariant("not", typeof(NotRequirement))
.AddVariant("or", typeof(OrRequirement))
.AddVariant("composite", typeof(CompositeRequirement))
.AddVariant("false", typeof(FalseRequirement))
.AddVariant("city", typeof(CityRequirement))
.AddVariant("building", typeof(BuildingRequirement));
FactoryManager.AddFactory(typeof(Amount), new Factory())
.AddVariant("simple", typeof(SimpleAmount))
.AddVariant("set", typeof(SetAmount))
.AddVariant("rle", typeof(RleSetAmount))
.AddVariant("range", typeof(RangeAmount))
.AddVariant("critical", typeof(CriticalAmount));
var mockNode = new RawNode(JSON.Instance.Parse(File.ReadAllText("mock.json")));
var simpleResourceNode = JSON.Instance.Parse(File.ReadAllText("simple-resources.json"));
var randomNode = JSON.Instance.Parse(File.ReadAllText("random.json"));
var objectsNode = JSON.Instance.Parse(File.ReadAllText("objects.json"));
var dealsNode = JSON.Instance.Parse(File.ReadAllText("deals.json"));
var citiesNode = JSON.Instance.Parse(File.ReadAllText("cities.json"));
var dict = SerializeUtil.Dict().SetArgs("simple-resources", simpleResourceNode, "objects", objectsNode, "random",
randomNode, "deals", dealsNode, "cities", citiesNode);
var player = new Player(mockNode, new RawNode(dict));
var territories = new Territories("territories", new TerritoryCategory(), player);
territories.Attach(territories.category.tank.fire, OnTerritories);
territories["0"].Attach(territories.category.tank.fire, OnTerritory);
territories["0"].tanks.Attach(territories.category.tank.fire, OnTanks);
territories["0"].tanks["0"].Attach(territories.category.tank.fire, OnTank);
territories["0"].tanks["0"].Fire();
var cities = player.GetChild <CityCollection>("cities");
var model = cities["0"];
cities.Attach(cities.categories.buildings.complete, Handler);
model.buildings["0"].Complete();
Console.ReadKey();
}
public override void Insert(OGM item)
{
Transaction trans = Transaction.RunningTransaction;
Entity entity = item.GetEntity();
string labels = string.Join(":", entity.GetBaseTypesAndSelf().Where(x => x.IsVirtual == false).Select(x => x.Label.Name));
if (entity.RowVersion != null)
{
item.SetRowVersion(trans.TransactionDate);
}
IDictionary <string, object?> node = item.GetData();
string create = string.Format("CREATE (inserted:{0} {{node}}) Return inserted", labels);
if (entity.FunctionalId != null)
{
object?key = item.GetKey();
if (key is null)
{
string nextKey = string.Format("CALL blueprint41.functionalid.next('{0}') YIELD value as key", entity.FunctionalId.Label);
if (entity.FunctionalId.Format == IdFormat.Numeric)
{
nextKey = string.Format("CALL blueprint41.functionalid.nextNumeric('{0}') YIELD value as key", entity.FunctionalId.Label);
}
create = nextKey + "\r\n" + string.Format("CREATE (inserted:{0} {{node}}) SET inserted.{1} = key Return inserted", labels, entity.Key.Name);
node.Remove(entity.Key.Name);
}
else
{
entity.FunctionalId.SeenUid(key.ToString() !);
}
}
Dictionary <string, object?> parameters = new Dictionary <string, object?>();
parameters.Add("node", node);
Dictionary <string, object?>?customState = null;
var args = entity.RaiseOnNodeCreate(trans, item, create, parameters, ref customState);
var result = trans.Run(args.Cypher, args.Parameters);
RawRecord record = result.FirstOrDefault();
if (record == null)
{
throw new InvalidOperationException($"Due to an unexpected state of the neo4j transaction, it seems impossible to insert the {entity.Name} at this time.");
}
RawNode inserted = record["inserted"].As <RawNode>();
args.Id = inserted.Id;
args.Labels = inserted.Labels;
// HACK: To make it faster we do not copy/replicate the Dictionary here, but it means someone
// could be changing the INode content from within an event. Possibly dangerous, but
// turns out the Neo4j driver can deal with it ... for now ...
args.Properties = (Dictionary <string, object?>)inserted.Properties;
args = entity.RaiseOnNodeCreated(trans, args, inserted.Id, inserted.Labels, (Dictionary <string, object?>)inserted.Properties);
item.SetData(args.Properties !);
item.PersistenceState = PersistenceState.Persisted;
Transaction.RunningTransaction.Register(entity.Name, item, true);
}
private static bool HasDeflection(RawNode config, string name)
{
return(config.CheckKey(name) || config.CheckKey(name + "_left") || config.CheckKey(name + "_right"));
}
public CityCollection(RawNode initNode, CityCategories categories, IContext context, IDescription dataSource) : base(initNode, categories, context, dataSource)
{
}
public BuildingDescription(RawNode node, IContext context = null) : base(node, context)
{
}
public LimitedResourcePrice(RawNode node, IContext context) : base(node, context)
{
resource = GetPath().GetSelf <LimitedResource>();
}
public DealDescription(RawNode node, IContext context) : base(node, context)
{
}
protected override SomeModel Factory(RawNode initNode, SomeModelDescription description)
{
return(new SomeModel(initNode, categories, description, GetContext()));
}
private Maybe <ILineNode> ParseStatement(MergeableGenerator <Token> tokens, ImmutableStack <Closure> scopes)
{
while (ExpandIdentifier(tokens, scopes))
{
}
head = tokens.Current;
tokens.MoveNext();
//TODO: Replace with real raw information, and error if not valid.
IList <IParamNode> parameters;
//TODO: Make intelligent to reject malformed parameters.
//TODO: Parse parameters after checking code validity.
if (tokens.Current.Type != TokenType.NEWLINE && tokens.Current.Type != TokenType.SEMICOLON)
{
parameters = ParseParamList(tokens, scopes);
}
else
{
parameters = new List <IParamNode>();
tokens.MoveNext();
}
string upperCodeIdentifier = head.Content.ToUpperInvariant();
if (SpecialCodes.Contains(upperCodeIdentifier))
{
switch (upperCodeIdentifier)
{
case "ORG":
if (parameters.Count != 1)
{
Error(head.Location, "Incorrect number of parameters in ORG: " + parameters.Count);
}
else
{
parameters[0].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); }).IfJust(
(int temp) =>
{
if (temp > 0x2000000)
{
Error(parameters[0].MyLocation, "Tried to set offset to 0x" + temp.ToString("X"));
}
else
{
CurrentOffset = temp;
}
}),
() => { Error(parameters[0].MyLocation, "Expected atomic param to ORG."); }
);
}
break;
case "PUSH":
if (parameters.Count != 0)
{
Error(head.Location, "Incorrect number of parameters in PUSH: " + parameters.Count);
}
else
{
pastOffsets.Push(new Tuple <int, bool>(CurrentOffset, offsetInitialized));
}
break;
case "POP":
if (parameters.Count != 0)
{
Error(head.Location, "Incorrect number of parameters in POP: " + parameters.Count);
}
else if (pastOffsets.Count == 0)
{
Error(head.Location, "POP without matching PUSH.");
}
else
{
Tuple <int, bool> tuple = pastOffsets.Pop();
CurrentOffset = tuple.Item1;
offsetInitialized = tuple.Item2;
}
break;
case "MESSAGE":
Message(head.Location, PrettyPrintParams(parameters));
break;
case "WARNING":
Warning(head.Location, PrettyPrintParams(parameters));
break;
case "ERROR":
Error(head.Location, PrettyPrintParams(parameters));
break;
case "ASSERT":
if (parameters.Count != 1)
{
Error(head.Location, "Incorrect number of parameters in ASSERT: " + parameters.Count);
}
else
{
parameters[0].AsAtom().IfJust(
(IAtomNode atom) =>
{
atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); }).IfJust(
(int temp) =>
{
if (temp < 0)
{
Error(parameters[0].MyLocation, "Assertion error: " + temp);
}
});
},
() => { Error(parameters[0].MyLocation, "Expected atomic param to ASSERT."); }
);
}
break;
case "PROTECT":
if (parameters.Count == 1)
{
parameters[0].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); }).IfJust(
(int temp) =>
{
protectedRegions.Add(new Tuple <int, int, Location>(temp, 4, head.Location));
}),
() => { Error(parameters[0].MyLocation, "Expected atomic param to PROTECT"); });
}
else if (parameters.Count == 2)
{
int start = 0, end = 0;
bool errorOccurred = false;
parameters[0].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); errorOccurred = true; }).IfJust(
(int temp) =>
{
start = temp;
}),
() => { Error(parameters[0].MyLocation, "Expected atomic param to PROTECT"); errorOccurred = true; });
parameters[1].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); errorOccurred = true; }).IfJust(
(int temp) =>
{
end = temp;
}),
() => { Error(parameters[0].MyLocation, "Expected atomic param to PROTECT"); errorOccurred = true; });
if (!errorOccurred)
{
int length = end - start;
if (length > 0)
{
protectedRegions.Add(new Tuple <int, int, Location>(start, length, head.Location));
}
else
{
Warning(head.Location, "Protected region not valid (end offset not after start offset). No region protected.");
}
}
}
else
{
Error(head.Location, "Incorrect number of parameters in PROTECT: " + parameters.Count);
}
break;
case "ALIGN":
if (parameters.Count != 1)
{
Error(head.Location, "Incorrect number of parameters in ALIGN: " + parameters.Count);
}
else
{
parameters[0].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); }).IfJust(
(int temp) =>
{
CurrentOffset = CurrentOffset % temp != 0 ? CurrentOffset + temp - CurrentOffset % temp : CurrentOffset;
}),
() => { Error(parameters[0].MyLocation, "Expected atomic param to ALIGN"); }
);
}
break;
case "FILL":
if (parameters.Count > 2 || parameters.Count == 0)
{
Error(head.Location, "Incorrect number of parameters in FILL: " + parameters.Count);
}
else
{
// FILL <amount> [value]
int amount = 0;
int value = 0;
if (parameters.Count == 2)
{
// param 2 (if given) is fill value
parameters[1].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); }).IfJust(
(int val) => { value = val; }),
() => { Error(parameters[0].MyLocation, "Expected atomic param to FILL"); });
}
// param 1 is amount of bytes to fill
parameters[0].AsAtom().IfJust(
(IAtomNode atom) => atom.TryEvaluate((Exception e) => { Error(parameters[0].MyLocation, e.Message); }).IfJust(
(int val) => { amount = val; }),
() => { Error(parameters[0].MyLocation, "Expected atomic param to FILL"); });
var data = new byte[amount];
for (int i = 0; i < amount; ++i)
{
data[i] = (byte)value;
}
var node = new DataNode(CurrentOffset, data);
CheckDataWrite(amount);
CurrentOffset += amount;
return(new Just <ILineNode>(node));
}
break;
}
return(new Nothing <ILineNode>());
}
else if (Raws.ContainsKey(upperCodeIdentifier))
{
//TODO: Check for matches. Currently should type error.
foreach (Raw r in Raws[upperCodeIdentifier])
{
if (r.Fits(parameters))
{
if ((CurrentOffset % r.Alignment) != 0)
{
Error(head.Location, string.Format("Bad code alignment (offset: {0:X8})", CurrentOffset));
}
StatementNode temp = new RawNode(r, head, CurrentOffset, parameters);
CheckDataWrite(temp.Size);
CurrentOffset += temp.Size; //TODO: more efficient spacewise to just have contiguous writing and not an offset with every line?
return(new Just <ILineNode>(temp));
}
}
//TODO: Better error message (a la EA's ATOM ATOM [ATOM,ATOM])
Error(head.Location, "Incorrect parameters in raw " + head.Content + '.');
IgnoreRestOfStatement(tokens);
return(new Nothing <ILineNode>());
}
else //TODO: Move outside of this else.
{
Error(head.Location, "Unrecognized code: " + head.Content);
return(new Nothing <ILineNode>());
}
}
public LazyDictionary(RawNode node, IContext context = null) : base(node, context)
{
}
public void Transform(RawNode item)
{
throw new NotImplementedException();
}
public SomeModelCollection(RawNode initNode, SomeModelCategories categories, IContext context, IDescription dataSource) : base(initNode, categories, context, dataSource)
{
}
protected override CityDescription Factory(RawNode partialNode)
{
return(new CityDescription(partialNode, GetContext()));
}
public FalseRequirement(RawNode node, IContext context)
: base(node, context)
{
}
public CityDescriptionDataSource(RawNode node, IContext context = null) : base(node, context)
{
}
protected WrappedRequirement(RawNode node, IContext context) : base(node, context)
{
innerRequirement = FactoryManager.Build <Requirement>(node.GetNode("requirement"), context);
}
public SomeModelDescription(RawNode node, IContext context = null) : base(node, context)
{
}
public LazyArray(RawNode descriptionNode, IContext context = null) : base(descriptionNode, context)
{
}
protected override City Factory(RawNode initNode, CityDescription description)
{
return(new City(initNode, categories, description, GetContext()));
}
