public override void CreateSimNode()
{
enabled = true;
state.SceneManager.DestroyEntity("SubNode");
state.SceneManager.DestroyLight("subLight");
Entity sub = state.SceneManager.CreateEntity("SubNode", @"MockSub.mesh");
var sceneNode = new SceneNode(state.SceneManager);
sceneNode.AttachObject(sub);
sceneNode.Yaw(Math.HALF_PI);
SimNode = new SimNode(state.SceneManager.RootSceneNode, sceneNode);
Light subLight = state.SceneManager.CreateLight("subLight");
subLight.Type = Light.LightTypes.LT_SPOTLIGHT;
subLight.Direction = new Vector3(0, 0, -1);
subLight.SpotlightOuterAngle = new Radian(0.4F);
subLight.SpotlightInnerAngle = new Radian(0.2F);
subLight.SpotlightFalloff = 100.0F;
subLight.SetAttenuation(100, 0F, 0.0F, 0.01F);
SimNode.SceneNode.AttachObject(subLight);
SimNode.SceneNode.Position = new Vector3(0, 0, 20);
}
public override void CreateSimNode()
{
enabled = true;
new SimHydrax().Init(state);
SimNode = new SimNode(state.SceneManager.RootSceneNode);
}
public void ResetCamera(State state)
{
Camera.Position = Vector3.ZERO;
Camera.Orientation = Quaternion.IDENTITY;
CameraNode = new SimNode(state.SceneManager.RootSceneNode.CreateChildSceneNode());
CameraChildNode = new SimNode(CameraNode.SceneNode, Camera);
}
private void UpdateNode(SimNode node)
{
// Remove old version
var removed = _nodes.Remove(node) ? true : throw new ArgumentException($"{node} could not be found on the current graph");
// Add new version and change the state to Modified
node.ChangeState = ChangeState.Modified;
_nodes.Add(node);
}
private void RemoveNode(SimNode node)
{
var n = _nodes.FirstOrDefault(a => a.Equals(node)) ?? throw new ArgumentException($"{node} could not be found on the current graph");
// Change the state to removed
n.ChangeState = ChangeState.Removed;
// Remove relations where "n" is either as origin or target
RemoveCorruptedRelations(n);
}
private int Distance(SimNode node1, SimNode node2)
{
const int maxHop = 4;
var lastNodes = new List <SimNode> {
node1
};
// 既に探索済みのノードにはアクセスしないようにするため
var accessedNodes = new List <SimNode> {
node1
};
for (var i = 1; i < maxHop + 1; i++)
{
var lastNodesTmp = new List <SimNode>();
foreach (var node in lastNodes)
{
foreach (var linkNode in node.linkedNodes)
{
if (!accessedNodes.Contains(linkNode))
{
lastNodesTmp.Add(linkNode);
accessedNodes.Add(linkNode);
if (linkNode == node2)
{
return(i);
}
}
}
}
lastNodes = lastNodesTmp;
}
return(-1);
// if(node1 == node2)
// return 0;
// var dist = 0;
// for(int i=1; i<6; i++){
// if(node1.GetLinkedNodes(i, false).Contains(node2)){
// dist = i;
// break;
// }else if(i == 5){
// dist = -1;
// }
// }
// return dist;
}
private void AddNode(SimNode node)
{
// Check if node is already available on the graph
if (_nodes.Contains(node))
{
return;
}
// Subscribe to this node
_client?.ChangeTracker.SubscribeToChangeStateEvent(node);
// Change state of the node to Added and add to graph
node.ChangeState = ChangeState.Added;
_nodes.Add(node);
}
private int GetPossibilities(SimNode node, int numMovesAhead)
{
if (node.MoveNumber == numMovesAhead)
{
return(1);
}
else
{
int num = 0;
foreach (SimNode childNode in node.NextMoves)
{
num += GetPossibilities(childNode, numMovesAhead);
}
return(num);
}
}
private List <Board> GetBoardsAtNumMoves(SimNode node, int numMovesAhead)
{
List <Board> boards = new List <Board>();
if (node.NumOfMoves == numMovesAhead)
{
boards.Add(node.Board);
}
else
{
foreach (SimNode nextMoveNode in node.NextMoves)
{
boards.AddRange(GetBoardsAtNumMoves(nextMoveNode, numMovesAhead));
}
}
return(boards);
}
// m is link count at once
private SimNode[] MakeScaleFreeNetwork(int nodeCount, int m)
{
var nodes = new List <SimNode>();
// make first m node
for (int i = 0; i < m; i++)
{
nodes.Add(new SimNode());
}
// connect first m node
foreach (var node1 in nodes)
{
foreach (var node2 in nodes)
{
if (node1 != node2)
{
node1.linkedNodes.Add(node2);
}
}
}
// add nodes
for (int i = 0; i < nodeCount - m; i++)
{
// probability distribution of connecting
var linkSum = nodes.Sum(n => n.linkedNodes.Count);
var dist = nodes.Select(n => (float)n.linkedNodes.Count / (float)linkSum).ToArray();
// make a new node
var newNode = new SimNode();
// connect m nodes
var selectIndices = SelectByProbDist(dist, m);
foreach (var selectIndex in selectIndices)
{
newNode.linkedNodes.Add(nodes[selectIndex]);
nodes[selectIndex].linkedNodes.Add(newNode);
}
nodes.Add(newNode);
}
return(nodes.ToArray());
}
private void RecreateSceneNode()
{
if (SimNode != null)
{
state.SceneManager.RootSceneNode.RemoveChild(base.SimNode.SceneNode);
SimNode.SceneNode.RemoveAndDestroyAllChildren();
}
mesh = string.IsNullOrEmpty(mesh) ? @"pathsegment.mesh" : new FileInfo(mesh).Name;
var sceneEntity = state.SceneManager.CreateEntity(Name + Random.Next(), mesh);
var sceneNode = state.SceneManager.RootSceneNode.CreateChildSceneNode();
sceneNode.AttachObject(sceneEntity);
sceneNode.Position = Position;
sceneNode.Orientation = Orientation;
sceneNode.Scale(Scale, Scale, Scale);
SimNode = new SimNode(sceneNode);
}
public void Init(State State)
{
this.State = State;
State.PhysicsWorld = this;
World = new MogreNewt.World();
World.SetPlatformArchitecture(MogreNewt.World.PlatformArchitecture.PA_BEST_HARDWARE);
World.SetWorldSize(new Vector3(-500, -500, -500), new Vector3(500, 500, 500));
World.SetSolverModel(MogreNewt.World.SolverModelMode.SM_2_PASS);
World.DebuggerInstance.Init(State.SceneManager);
// using the new "SceneParser" TreeCollision primitive. this will automatically parse an entire tree of
// SceneNodes (parsing all children), and add collision for all meshes in the tree.
var statCol = new MogreNewt.CollisionPrimitives.TreeCollisionSceneParser(World);
statCol.ParseScene(State.SceneManager.RootSceneNode, true, 0); // was floornode
var sceneBody = new Body(World, statCol);
statCol.Dispose();
sceneBody.AttachNode(State.SceneManager.RootSceneNode); // was floornode
sceneBody.SetPositionOrientation(new Vector3(0.0f, 0.0f, 0.0f), Quaternion.IDENTITY);
var ent = State.SceneManager.CreateEntity("cylinder_body", "mocksub.mesh");
var simNode = new SimNode(State.SceneManager.RootSceneNode, ent);
// rigid body.
var phyNode = new PhysicsNode(simNode, State);
phyNode.Body.SetPositionOrientation(new Vector3(0, 10, 0), Quaternion.IDENTITY);
phyNode.Body.SetMassMatrix(125, Vector3.ZERO);
var physicsNode = new PhysicsNode(State.SubNode, State);
physicsNode.Body.SetMassMatrix(125, Vector3.ZERO);
// TODO: FIX THIS State.SubNode = physicsNode;
// initial position
State.Root.FrameStarted += NewtonUpdate;
}
private SimNode[] MakeTreeNodes()
{
// 全ホップ数
const int HopCount = 3;
// 一つのノードにつながっているノードの数
const int LinkNodeCount = 5;
var nodeId = 0;
var firstNode = new SimNode();
var lastNodes = new List <SimNode> {
firstNode
};
var allNodes = new List <SimNode> {
firstNode
};
for (int i = 0; i < HopCount; i++)
{
var lastNodesTmp = new List <SimNode>();
foreach (var lastNode in lastNodes)
{
for (int n = 0; n < LinkNodeCount; n++)
{
var newNode = new SimNode();
lastNode.linkedNodes.Add(newNode);
newNode.linkedNodes.Add(lastNode);
nodeId++;
newNode.nodeId = nodeId;
lastNodesTmp.Add(newNode);
allNodes.Add(newNode);
}
}
lastNodes = lastNodesTmp;
}
return(allNodes.ToArray());
}
private IEnumerable <Board> EnumerateBoardsFromNode(SimNode node, Board b, int numMovesAhead)
{
if (!String.IsNullOrEmpty(node.Move))
{
node.Move = node.Move.Replace("{", "");
node.Move = node.Move.Replace("}", "");
string[] nums = node.Move.Split(':');
string[] fromCellParts = nums[0].Split(',');
string[] toCellParts = nums[1].Split(',');
foreach (string part in fromCellParts)
{
part.Trim();
}
foreach (string part in toCellParts)
{
part.Trim();
}
Cell fromCell = new Cell(int.Parse(fromCellParts[0]), int.Parse(fromCellParts[1]));
Cell toCell = new Cell(int.Parse(toCellParts[0]), int.Parse(toCellParts[1]));
b.MovePiece(fromCell, toCell);
}
if (node.MoveNumber == numMovesAhead)
{
yield return(b);
}
else
{
foreach (SimNode childNode in node.NextMoves)
{
Board newBoard = b.Clone() as Board;
foreach (Board childBoard in EnumerateBoardsFromNode(childNode, newBoard, numMovesAhead))
{
yield return(childBoard);
}
}
}
}
public PhysicsNode(SimNode simNode, State State) : base(simNode.SceneNode)
{
SceneNode = simNode.SceneNode;
SceneNode child = SceneNode;
while (child.NumChildren() > 0)
{
child = child.GetChild(0) as SceneNode;
}
var hull = new MogreNewt.CollisionPrimitives.ConvexHull(State.PhysicsWorld.World, child, child.Orientation, 0.002f, SceneNode.Name.GetHashCode());
Body = new Body(State.PhysicsWorld.World, hull);
Body.AttachNode(SceneNode);
Body.IsGravityEnabled = true;
Body.SetPositionOrientation(SceneNode._getDerivedPosition(), SceneNode.Orientation); // REALPosition Orient
Body.ForceCallback += State.PhysicsWorld.ForceCallback;
// Body.AngularDamping = new Vector3(1,1,1);
// Body.LinearDamping = 1;
Body.UserData = new PhysicsControlData();
hull.Dispose();
}
private void RemoveCorruptedRelations(SimNode node)
{
var corruptedRelations = _relations.Where(a => a.Origin.Equals(node) || a.Target.Equals(node));
Remove(corruptedRelations);
}
public RecreationSimTree(Board board)
{
gameBoard = board;
Base = new SimNode("", 0);
}
} // Make set protected!
public BaseEntity(SimNode node)
{
this.SimNode = node;
}
private SimNode InitNodes()
{
// when tree
// var allNodes = MakeTreeNodes();
// var firstNode = allNodes[0];
_goalNodes = new List <SimNode>();
SimNode[] allNodes = new SimNode[0];
switch (dataSet)
{
case SimRecord.DataSet.WattsStrogatz:
allNodes = MakeConnectedWattsStrogatzGraph(allNodeCount, meanDegree, 0.4f);
break;
case SimRecord.DataSet.Tree:
allNodes = MakeTreeNodes();
break;
case SimRecord.DataSet.BarabasiAlbert:
allNodes = MakeScaleFreeNetwork(allNodeCount, meanDegree / 2);
break;
}
// when watts strogatz graph
SimNode firstNode = allNodes[0];
// SimNode goalNode = allNodes[0];
// var firstNode = allNodes[Random.Range(0, allNodes.Length)];
// var goalNode = allNodes[Random.Range(0, allNodes.Length)];
// set firstNode
// while (firstNode == goalNode)
// {
// var goalList = new SimNode[0];
// GoalNodeが手に入らない場合があるので、ちゃんと定まるまでループ
// while (goalList.Length == 0)
// {
switch (dataSet)
{
case SimRecord.DataSet.WattsStrogatz:
firstNode = allNodes[rand.Next(0, allNodes.Length)];
break;
case SimRecord.DataSet.Tree:
firstNode = allNodes[0];
break;
case SimRecord.DataSet.BarabasiAlbert:
firstNode = allNodes[rand.Next(0, allNodes.Length)];
break;
}
// goalNode = allNodes[Random.Range(0, allNodes.Length)];
// goalList = firstNode.GetLinkedNodes(distanceFtoG, false);
// goalList = allNodes;
// if(goalList.Length == 0)
// Debug.Log("retry because goal not found.");
// }
while (_goalNodes.Count < goalCount)
{
var goalNode = allNodes[rand.Next(0, allNodes.Length)];
// if(0 < Distance(firstNode, goalNode) && !goalNode.IsGoal){
goalNode.IsGoal = true;
_goalNodes.Add(goalNode);
// }
}
// }
// for dist goal
// goalNode.IsGoal = true;
// _goalNodes.Add(goalNode);
_currentNode = firstNode;
_currentNode.Known = true;
_opCount = 0;
_firstNode = firstNode;
_graphDensity = GraphDensity(allNodes);
// 視点ノードと終点ノードとの距離を記録
distanceFtoG = (float)_goalNodes.Sum(g => Distance(firstNode, g)) / (float)_goalNodes.Count;
// distanceFtoG = 0;
return(firstNode);
}
// Make Watts Strogatts Graph
// nodeCount : the number of nodes
// ringK : each node is connected to k/2 nearest neighbors in ring topology
// rewiringP : the probability of rewiring each edge
private SimNode[] MakeWattsStrogatzGraph(int nodeCount, int ringK, float rewiringP)
{
if (ringK >= nodeCount)
{
Debug.Log("parameter is invalid");
}
var allNodes = new SimNode[nodeCount];
for (var i = 0; i < allNodes.Length; i++)
{
allNodes[i] = new SimNode();
}
// 近くのノードと結合させて円環を作る
for (int i = 1; i < ringK / 2 + 1; i++)
{
for (int j = 0; j < allNodes.Length; j++)
{
// リンク先のノードはindexをiだけずらしたもの
var linkNodeIndex = j + i < allNodes.Length ? j + i : j + i - allNodes.Length;
// j <-> j + i にリンクを貼る
allNodes[j].linkedNodes.Add(allNodes[linkNodeIndex]);
allNodes[linkNodeIndex].linkedNodes.Add(allNodes[j]);
}
}
// ランダムに再結線する
for (int i = 1; i < ringK / 2 + 1; i++)
{
for (int j = 0; j < allNodes.Length; j++)
{
// j <-> j + iのリンクに関して, 再結線する
if (rand.NextDouble() < rewiringP)
{
// 現在注目しているノード
var targetNode = allNodes[j];
// 削除するノード
var oldLinkNodeIndex = j + i < allNodes.Length ? j + i : j + i - allNodes.Length;
var oldLinkNode = allNodes[oldLinkNodeIndex];
// 新しく接続するノード
var newLinkNode = allNodes[rand.Next(0, allNodes.Length)];
// 自己ループと重複ループを避ける
while (targetNode == newLinkNode || targetNode.linkedNodes.Contains(newLinkNode))
{
newLinkNode = allNodes[rand.Next(0, allNodes.Length)];
// すでに自分以外の全ノードにエッジがあればスキップ
if (targetNode.linkedNodes.Count >= nodeCount - 1)
{
break;
}
}
targetNode.linkedNodes.Remove(oldLinkNode);
oldLinkNode.linkedNodes.Remove(targetNode);
targetNode.linkedNodes.Add(newLinkNode);
newLinkNode.linkedNodes.Add(targetNode);
}
}
}
return(allNodes);
}
// return: シミュレーションが成功したか
public bool Simulate()
{
// distanceFtoG = -1;
// while(distanceFtoG == -1){
// InitNodes();
// }
// connectedが保証されてないので絶対に使ってはいけません.
// MakeRandomGraph();
InitNodes();
var tryCount = 0;
const int maxTryCount = 1000;
while (!IsAllGoalKnown())
{
tryCount++;
if (maxTryCount < tryCount)
{
return(false);
}
// 選択可能な全ノード
var selectableNodes = _currentNode.GetAllLinkedNodes(MaxSelectHop);
// ユーザーの視界を再現した, 見える範囲のノード
var visibleNodes = new List <SimNode>();
for (int i = 0; i < MaxVisibleCount; i++)
{
var selectHop = SelectHopByExpDist();
// try{
// // みたいノードが0個になったら, 手前のノードで代替する
// while(0 < selectHop && selectableNodes[selectHop].Count == 0){
// selectHop--;
// continue;
// }
// } catch(IndexOutOfRangeException){
// Debug.Log("out of range");
// Debug.Log("SelectHop:" + selectHop);
// Debug.Log("length:" + selectableNodes.Length);
// }
if (selectableNodes[selectHop].Count == 0)
{
continue;
}
if (selectHop == 0)
{
break;
}
var r = rand.Next(0, selectableNodes[selectHop].Count);
visibleNodes.Add(selectableNodes[selectHop][r]);
selectableNodes[selectHop].RemoveAt(r);
var selectableNodesCount = selectableNodes.Sum(ns => ns.Count);
if (selectableNodesCount == 1)
{
break;
}
}
// 目的ノードが視界に入っていたら高確率で選択
var moved = false;
foreach (var goalNode in _goalNodes)
{
if (visibleNodes.Contains(goalNode))
{
var r = rand.NextDouble();
if (r < pSelectVisibleGoal && !goalNode.Known)
{
_currentNode = goalNode;
_currentNode.Known = true;
_opCount++;
moved = true;
}
}
}
if (moved)
{
continue;
}
// 一定確率で始点ノードに戻る
if ((float)rand.NextDouble() < pReturnFirst && _currentNode != _firstNode)
{
_currentNode = _firstNode;
_opCount++;
continue;
}
if (IsAllGoalKnown())
{
continue;
}
var r1 = rand.NextDouble();
// 未知ノードに移動
if (r1 < pSelectUnknown)
{
// var selectHop = SelectHopByProbArray(pSelectHopUnknown);
var selectHop = SelectHopByExpDist();
// var unknownNodes = _currentNode.GetLinkedNodes(selectHop, false).ToList();
var unknownNodes = visibleNodes.Where(n => n.Known == false).ToArray();
if (unknownNodes.Length == 0)
{
continue;
}
var r2 = rand.Next(0, unknownNodes.Length);
_currentNode = unknownNodes[r2];
_currentNode.Known = true;
_opCount++;
}
// 既知ノードに移動
else
{
// var selectHop = SelectHopByProbArray(pSelectHopKnown);
var selectHop = SelectHopByExpDist();
// Debug.Log("Select Hop " + selectHop);
// var knownNodes = _currentNode.GetLinkedNodes(selectHop, true);
var knownNodes = visibleNodes.Where(n => n.Known == true).ToArray();
if (knownNodes.Length == 0)
{
continue;
}
var r2 = rand.Next(0, knownNodes.Length);
_currentNode = knownNodes[r2];
_currentNode.Known = true;
_opCount++;
}
}
// Debug.Log("操作数" + _opCount);
var record = new SimRecord
{
dataSet = dataSet,
nodeCount = allNodeCount,
goalCount = goalCount,
graphDensity = _graphDensity,
lambda = Lambda,
distance = distanceFtoG,
opCount = _opCount,
pSelectUnknown = pSelectUnknown,
pReturnFirst = pReturnFirst,
pSelectVisibleGoal = pSelectVisibleGoal
};
records.Add(record);
return(true);
}
