// Use this for initialization
void Start()
{
nodeController = GetComponent <NodeController>();
trapController = GetComponent <TrapController>();
uiController = GameObject.Find("In-game UI").GetComponent <UI_Controller>();
loader = GameObject.Find("SceneManager").GetComponent <SceneLoader>();
}
public async Task GetRawTransactionAsync_TransactionCannotBeFound_ReturnsNullAsync()
{
var txId = new uint256(12142124);
this.pooledTransaction.Setup(p => p.GetTransaction(txId))
.ReturnsAsync((Transaction)null)
.Verifiable();
var blockStore = new Mock <IBlockStore>();
blockStore.Setup(b => b.GetTrxAsync(txId))
.ReturnsAsync((Transaction)null)
.Verifiable();
this.fullNode.Setup(f => f.NodeFeature <IBlockStore>(false))
.Returns(blockStore.Object);
this.controller = new NodeController(this.fullNode.Object, this.LoggerFactory.Object,
this.dateTimeProvider.Object, this.chainState.Object, this.nodeSettings,
this.connectionManager.Object, this.chain, this.network, this.pooledTransaction.Object,
this.pooledGetUnspentTransaction.Object, this.getUnspentTransaction.Object, this.networkDifficulty.Object);
string txid = txId.ToString();
bool verbose = false;
var json = (JsonResult)await this.controller.GetRawTransactionAsync(txid, verbose).ConfigureAwait(false);
Assert.Null(json.Value);
this.pooledTransaction.Verify();
blockStore.Verify();
}
/// <summary>
/// Takes into acount our current resource pools/rates, the nodes resource rates, the distance to nearest player, and the distance to the most threatening player.
/// </summary>
/// <param name="desiredNode"></param>
/// <returns></returns>
public float EvaluateExpansion(out NodeController desiredNode)
{
int iIndex = 0;
float bestval = float.MinValue;
foreach (var res in GameManager.instance.resourceList)
{
expansionInputs[iIndex] = player.GetResourcePool(res);
expansionInputs[++iIndex] = player.GetResourceRate(res);
}
desiredNode = null;
foreach (var kvp in player.borderNodes)
{
int i = iIndex + 1;
for (int j = 0; j < GameManager.instance.resourceList.Count; ++j, ++i)
{
var res = GameManager.instance.resourceList[j];
expansionInputs[i] = kvp.Value.resourceCont.GetResourceRate(res);
}
expansionInputs[i] = kvp.Value.nearestOwnedDist;
expansionInputs[++i] = GameManager.instance.DistanceToNearestPlayerNode(kvp.Value, threatPlayer);
expansionInputs[++i] = kvp.Value.buildingCont.GetBuildingTypeCount(BUILDING_TYPE.ECONOMIC);
float val = nnExpansion.Evaluate(expansionInputs)[0];
if (val > bestval)
{
bestval = val;
desiredNode = kvp.Value;
}
}
return(bestval);
}
public void GenerateMap()
{
for (int y = 0; y < _grid.GetLength(1); y++)
{
for (int x = 0; x < _grid.GetLength(0); x++)
{
Node node = _grid[x, y];
if (node != null)
{
if (node.GetNodeType() != NodeType.BLANK)
{
GameObject nodeGO = Instantiate(nodePrefabs[node.GetNodeType()], new Vector3(x - 5.5f, y - 9.5f, 0), nodePrefabs[node.GetNodeType()].transform.rotation);
NodeController nc = nodeGO.GetComponent <NodeController>();
nc.SetNode(node);
if (node.GetNodeType() == NodeType.START_NODE)
{
NetManager.StartingNodes.Add(nc);
node.SetNodeType(NodeType.NODE);
}
if (node is BaseNode baseNode)
{
baseNode.SetComponentData(0);
}
NetworkServer.Spawn(nodeGO);
nc.color = node.GetNodeType() != NodeType.DATA_BUS ? Color.white : Color.red;
}
}
}
}
}
/**
* Retrieves a random neighbour of a specific node.
* @param node the given node.
* @return a random neighbour.
*/
private NodeController getRandomNeighbour(NodeController node)
{
List <NodeController> neighbours = node.Neighbours;
int randomNumber = Random.Range(0, neighbours.Count);
return(neighbours[randomNumber]);
}
public float[] EvaluateDevelopment(NodeController node)
{
for (int i = 0; i < developmentInputs.Length; ++i)
{
developmentInputs[i] = 0.0f;
if (i % 2 == 0)
{
developmentInputs[i] = player.resourceRatesList[i / 2].value;
}
else
{
developmentInputs[i] = player.resourcePoolsList[i / 2].value;
}
}
return(nnDevelopment.Evaluate(developmentInputs));
//var outputs = nnDevelopment.Evaluate(developmentInputs);
//int highest = 0;
//for (int i = 0; i < outputs.Length; ++i)
// if (outputs[i] > outputs[highest])
// highest = i;
//var building = GameManager.instance.buildingList[highest];
//return GameManager.instance.AttemptToBuyBuilding(player, node, building);
}
private void IsFill_CheckedChanged(object sender, EventArgs e)
{
if (this.IsFill.Checked)
{
this.ColorChoosen.Visible = true;
var a = NodeController.Get_Node_Selected();
if (a != null)
{
a.setcolor(a.Color_old);
this.ColorChoosen.BackColor = a.Color_old;
// click_isfill(this, new Click_node { color_of_node = this.ColorChoosen.BackColor });
}
}
else
{
this.ColorChoosen.Visible = false;
var a = NodeController.Get_Node_Selected();
if (a != null)
{
a.setcolor(Color.Gainsboro);
// click_isfill(this, new Click_node { color_of_node = this.ColorChoosen.BackColor });
}
}
}
private void TextSize_ValueChanged(object sender, EventArgs e)
{
var a = NodeController.Get_Node_Selected();
a.set_font(fontDialog1.Font, fontDialog1.Font.Style, float.Parse(TextSize.Value.ToString()));
fontDialog1.Font = new Font(fontDialog1.Font.Name, float.Parse(TextSize.Value.ToString()), fontDialog1.Font.Style);
}
public SquareSetup(NodeController _northwestCorner, NodeController _northeastCorner,
NodeController _southeastCorner, NodeController _southwestCorner)
{
northwestCorner = _northwestCorner;
northeastCorner = _northeastCorner;
southeastCorner = _southeastCorner;
southwestCorner = _southwestCorner;
north = northwestCorner.nodeRight;
east = southeastCorner.nodeAbove;
south = southwestCorner.nodeRight;
west = southwestCorner.nodeAbove;
//
if (northwestCorner.nodeActive)
{
config += 8;
}
if (northeastCorner.nodeActive)
{
config += 4;
}
if (southeastCorner.nodeActive)
{
config += 2;
}
if (southwestCorner.nodeActive)
{
config += 1;
}
}
public void CreateFromPositionedNode(int num, PositionedNode pn)
{
NodeController node = Instantiate(nodePrefab, transform);
node.Initialise(num, pn.position, pn.type);
nodes.Add(node);
}
private void SetControllerCrossReferences(ConnectionController connectionController)
{
if (connectionController == null)
{
Debug.Log("connectionController");
}
if (connectionController?.StaticModel == null)
{
Debug.Log("StaticModel");
}
if (connectionController?.StaticModel?.Node1 == null)
{
Debug.Log("Node1");
}
if (nodeDictionary == null)
{
Debug.Log("nodeDictionary");
}
if (nodeDictionary[connectionController.StaticModel.Node1] == null)
{
Debug.Log("nodeDictionary[connectionController.StaticModel.Node1]");
}
NodeController nodeController1 = nodeDictionary[connectionController.StaticModel.Node1].GetComponent <NodeController>();
NodeController nodeController2 = nodeDictionary[connectionController.StaticModel.Node2].GetComponent <NodeController>();
nodeController1.Connections.Add(connectionController);
nodeController2.Connections.Add(connectionController);
connectionController.SetNodeControllers(nodeController1, nodeController2);
}
public SquareGrid(int[,] level, float squareSize)
{
int nodeCountX = level.GetLength(0);
int nodeCountZ = level.GetLength(1);
float levelWidth = nodeCountX * squareSize;
float levelHeight = nodeCountZ * squareSize;
NodeController[,] nodeController = new NodeController[nodeCountX, nodeCountZ];
for (int x = 0; x < nodeCountX; x++)
{
for (int z = 0; z < nodeCountZ; z++)
{
Vector3 position = new Vector3(-levelWidth / 2 + x * squareSize + squareSize / 2, 0, -levelHeight / 2 + z * squareSize + squareSize / 2);
nodeController[x, z] = new NodeController(position, level[x, z] == 1, squareSize);
}
}
squares = new SquareSetup[nodeCountX - 1, nodeCountZ - 1];
for (int x = 0; x < nodeCountX - 1; x++)
{
for (int z = 0; z < nodeCountZ - 1; z++)
{
squares[x, z] = new SquareSetup(nodeController[x, z + 1],
nodeController[x + 1, z + 1],
nodeController[x + 1, z],
nodeController[x, z]);
}
}
}
/// <summary>
/// Событие, срабатывающее, при нажатии на нод из TreeView.
/// Если была нажата левая кнопка мыши, то в ListView выводятся все товары разделов и подразделов.
/// Если была нажата правая кнопка мыши, то открывается контекстное меню для взаимодействия с программой.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void treeView_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
treeView.SelectedNode = treeView.GetNodeAt(e.Location);
Dictionary <TreeNode, List <TreeNode> > treeNodes =
NodeController.GetDeepestNodes(treeView.SelectedNode, new Dictionary <TreeNode, List <TreeNode> >());
GenerateListViewItems(treeNodes);
}
if (e.Button == MouseButtons.Right)
{
treeView.SelectedNode = treeView.GetNodeAt(e.Location);
if (treeView.SelectedNode.Tag is StorageModel)
{
ChangeActionToolStripsState(
false, true, false, true, true, true, true);
}
if (treeView.SelectedNode.Tag is SectionModel)
{
ChangeActionToolStripsState(
false, true, true, true, true, true, false);
}
if (treeView.SelectedNode.Tag is ProductModel)
{
ChangeActionToolStripsState(
false, false, false, true, true, false, false);
}
contextMenuStrip.Show(e.Location);
}
}
private IEnumerator FollowPath(NodeController destinationNode, int amount, NetworkIdentity sender)
{
Node currentWaypoint = _path[0];
while (true)
{
if (Math.Abs(transform.position.x - (currentWaypoint.GetPosition().x - 5.5f)) < 0.1 &&
Math.Abs(transform.position.y - (currentWaypoint.GetPosition().y - 9.5f)) < 0.1)
{
_targetIndex++;
if (_targetIndex >= _path.Count)
{
FinishedPath(destinationNode, amount, sender);
yield break;
}
Debug.Log($"{_targetIndex}:{_path.Count}");
currentWaypoint = _path[_targetIndex];
}
Vector2Int newTarget = currentWaypoint.GetPosition();
transform.position = Vector3.MoveTowards(transform.position,
new Vector3(newTarget.x - 5.5f, newTarget.y - 9.5f, 0), _speed * Time.deltaTime);
yield return(null);
}
}
public async Task GetRawTransactionAsync_TransactionNotInPooledTransaction_ReturnsTransactionFromBlockStoreAsync()
{
var txId = new uint256(12142124);
this.pooledTransaction.Setup(p => p.GetTransaction(txId))
.ReturnsAsync((Transaction)null);
Transaction transaction = this.CreateTransaction();
this.blockStore.Setup(b => b.GetTransactionById(txId))
.Returns(transaction);
this.controller = new NodeController(this.chainIndexer, this.chainState.Object,
this.connectionManager.Object, this.dateTimeProvider.Object, this.fullNode.Object,
this.LoggerFactory.Object, this.nodeSettings, this.network, this.asyncProvider.Object, this.selfEndpointTracker.Object, this.consensusManager.Object, this.blockStore.Object, this.getUnspentTransaction.Object,
this.networkDifficulty.Object, this.pooledGetUnspentTransaction.Object, this.pooledTransaction.Object);
string txid = txId.ToString();
bool verbose = false;
var json = (JsonResult)await this.controller.GetRawTransactionAsync(txid, verbose).ConfigureAwait(false);
var resultModel = (TransactionBriefModel)json.Value;
Assert.NotNull(json);
var model = Assert.IsType <TransactionBriefModel>(resultModel);
Assert.Equal(transaction.ToHex(), model.Hex);
}
public Form1()
{
InitializeComponent();
nodeController = new NodeController();
aiController = new AiController();
PopulateUI();
}
public void CancelJobShouldReturnOkWhenSuccessful()
{
_workerWrapper = new WorkerWrapper(new LongRunningInvokeHandlerFake(),
_nodeConfigurationFake,
_nodeStartupNotification,
_pingToManagerFake,
_sendJobDoneTimer,
_sendJobCanceledTimer,
_sendJobFaultedTimer,
_trySendJobDetailToManagerTimer,
_jobDetailSender);
_nodeController = new NodeController(_workerWrapper)
{
Request = new HttpRequestMessage()
};
_nodeController.PrepareToStartJob(_jobQueueItemEntity);
_nodeController.StartJob(_jobQueueItemEntity.JobId);
while (!_workerWrapper.IsWorking)
{
Thread.Sleep(200);
}
var actionResult = _nodeController.TryCancelJob(_jobQueueItemEntity.JobId);
Assert.IsTrue(actionResult.ExecuteAsync(new CancellationToken()).Result.StatusCode == HttpStatusCode.OK);
}
public async Task GetTxOutAsync_IncludeInMempool_UnspentTransactionFound_ReturnsModelAsync()
{
var txId = new uint256(1243124);
Transaction transaction = this.CreateTransaction();
var unspentOutputs = new UnspentOutput(new OutPoint(transaction, 0), new Coins(1, transaction.Outputs[0], transaction.IsCoinBase));
this.pooledGetUnspentTransaction.Setup(s => s.GetUnspentTransactionAsync(new OutPoint(txId, 0)))
.ReturnsAsync(unspentOutputs)
.Verifiable();
this.controller = new NodeController(this.chainIndexer, this.chainState.Object,
this.connectionManager.Object, this.dateTimeProvider.Object, this.fullNode.Object,
this.LoggerFactory.Object, this.nodeSettings, this.network, this.asyncProvider.Object, this.selfEndpointTracker.Object, this.consensusManager.Object, this.blockStore.Object, this.getUnspentTransaction.Object,
this.networkDifficulty.Object, this.pooledGetUnspentTransaction.Object, this.pooledTransaction.Object);
string txid = txId.ToString();
uint vout = 0;
bool includeMemPool = true;
var json = (JsonResult)await this.controller.GetTxOutAsync(txid, vout, includeMemPool).ConfigureAwait(false);
var resultModel = (GetTxOutModel)json.Value;
this.pooledGetUnspentTransaction.Verify();
Assert.Equal(this.chainIndexer.Tip.HashBlock, resultModel.BestBlock);
Assert.True(resultModel.Coinbase);
Assert.Equal(3, resultModel.Confirmations);
Assert.Equal(new ScriptPubKey(transaction.Outputs[0].ScriptPubKey, this.network).Hex, resultModel.ScriptPubKey.Hex);
Assert.Equal(transaction.Outputs[0].Value, resultModel.Value);
}
public MaxSystemEvents(NlmTreeListView listView, NodeController nodeControl)
{
// Set properties.
ListView = listView;
NodeControl = nodeControl;
// Create Events
FilePreSave = new SystemNotificationObjectHandler(SystemNotificationCode.FilePreSave);
FilePreSave.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onFilePreSave);
SystemPreReset = new SystemNotificationObjectHandler(SystemNotificationCode.SystemPreReset);
SystemPreReset.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPreReset);
SystemPostReset = new SystemNotificationObjectHandler(SystemNotificationCode.SystemPostReset);
SystemPostReset.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPostReset);
SystemPreNew = new SystemNotificationObjectHandler(SystemNotificationCode.SystemPreNew);
SystemPreNew.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPreReset);
SystemPostNew = new SystemNotificationObjectHandler(SystemNotificationCode.SystemPostNew);
SystemPostNew.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPostReset);
SystemPreLoad = new SystemNotificationObjectHandler(SystemNotificationCode.FilePreOpen);
SystemPreLoad.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPreReset);
SystemPostLoad = new SystemNotificationObjectHandler(SystemNotificationCode.FilePostOpen);
SystemPostLoad.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPostReset);
SystemPostMerge = new SystemNotificationObjectHandler(SystemNotificationCode.FilePostMerge);
SystemPostMerge.NotificationRaised += new EventHandler <SystemNotificationObjectEventArgs>(onSystemPostMerge);
// import, dunno if we need that one
// xref
}
public async Task ShouldReturnAllNodesWithSpecifiedNameWhenGetNodesCalled()
{
//Given
const string hostname = "node1";
var desc = new NodeDescription();
desc.Hostname = hostname;
_swarmClient.GetNodes().Returns(x => {
return(Task.FromResult <IEnumerable <NodeListResponse> >(new [] { _any.Create <NodeListResponse>(),
_any.Build <NodeListResponse>().With(t => t.Description, desc).Create() }));
});
var nodeService = new NodeService(_swarmClient, _loggerFactory);
var nodeController = new NodeController(nodeService);
//When
var response = await nodeController.GetNode(hostname, SwarmRole.Unknown);
var jsonResult = response as JsonResult;
var value = jsonResult?.Value as IEnumerable <NodeListResponse>;
//Then
Assert.NotNull(jsonResult);
Assert.NotNull(value);
Assert.Equal(200, jsonResult.StatusCode);
Assert.Equal(1, value.Count());
}
private void Start()
{
_grid = new NodeController[_gridWidth, _gridHeight];
_verticallyMatchedNodes = new List <NodeController>();
_horizontallyMatchedNodes = new List <NodeController>();
_movingNodesList = new List <NodeController>();
for (int y = 0; y < _gridHeight; y++)
{
for (int x = 0; x < _gridWidth; x++)
{
Color nodeColor = _colorsList[Random.Range(0, _colorsList.Count)];
GameObject go = GetComponent <ObjectPooler>().GetPooledObject("Node");
NodeController node = go.GetComponent <NodeController>();
node.name = "Node_" + x + "_" + y;
node.transform.SetParent(transform);
node.transform.localPosition = new Vector3(x * 1f + 0.5f, -y * 1f - 0.5f, 0f);
node.PosX = x;
node.PosY = y;
node.NodeColor = nodeColor;
_grid[x, y] = node;
}
}
transform.position = new Vector3(-_gridWidth * 0.5f, _gridHeight * 0.5f, 0f);
EventBus.RaiseGameStarted(this);
FindDestroyAndSettleMatchedNodes();
EventBus.OnMoveNode += OnMoveNode;
EventBus.OnNodeMovementEnded += OnNodeMovementEnded;
}
public NodeControllerTest()
{
this.network = KnownNetworks.TestNet;
this.chain = WalletTestsHelpers.GenerateChainWithHeight(3, this.network);
this.chainState = new Mock <IChainState>();
this.connectionManager = new Mock <IConnectionManager>();
this.connectionManager.Setup(c => c.Network).Returns(this.network);
this.dateTimeProvider = new Mock <IDateTimeProvider>();
this.fullNode = new Mock <IFullNode>();
this.nodeSettings = new NodeSettings(networksSelector: Networks.Networks.Bitcoin);
this.peerBanning = new Mock <IPeerBanning>();
this.blockStore = new Mock <IBlockStore>();
this.getUnspentTransaction = new Mock <IGetUnspentTransaction>();
this.networkDifficulty = new Mock <INetworkDifficulty>();
this.pooledGetUnspentTransaction = new Mock <IPooledGetUnspentTransaction>();
this.pooledTransaction = new Mock <IPooledTransaction>();
this.controller = new NodeController(
this.chain,
this.chainState.Object,
this.connectionManager.Object,
this.dateTimeProvider.Object,
this.fullNode.Object,
this.LoggerFactory.Object,
this.nodeSettings,
this.network,
this.blockStore.Object,
this.getUnspentTransaction.Object,
this.networkDifficulty.Object,
this.pooledGetUnspentTransaction.Object,
this.pooledTransaction.Object);
}
public async Task ShouldReturnAllManagerNodesInfoWhenGetNodesCalled()
{
//Given
var spec = new NodeUpdateParameters();
spec.Role = "manager";
_swarmClient.GetNodes().Returns(x => {
return(Task.FromResult <IEnumerable <NodeListResponse> >(new [] { _any.Create <NodeListResponse>(),
_any.Build <NodeListResponse>().With(t => t.Spec, spec).Create() }));
});
var nodeService = new NodeService(_swarmClient, _loggerFactory);
var nodeController = new NodeController(nodeService);
//When
var response = await nodeController.GetNode(null, SwarmRole.Manager);
var jsonResult = response as JsonResult;
var value = jsonResult?.Value as IEnumerable <NodeListResponse>;
//Then
Assert.NotNull(jsonResult);
Assert.NotNull(value);
Assert.Equal(200, jsonResult.StatusCode);
Assert.Equal(1, value.Count());
}
protected NodeController findMoveNode(string goal, string subgoal)
{
switch (goal)
{
case "attack":
//gets two possible targets then randomly picks one
GameObject[] targets = { Manager.findClosestEnemy(currentNode), Manager.findClosestEnemy(currentNode) };
GameObject enemy = targets[Random.Range(0, 1)];
NodeController enemyLocation = enemy.GetComponent <Character>().getCurrentNode().GetComponent <NodeController>();
NodeController attackLocation = null;
switch (subgoal)
{
case "melee":
//checks nodes around the enemy to find node thats the closest
attackLocation = findClosestMeleeNode(enemyLocation);
return(attackLocation);
/*case "ranged":
* //gets path to target and sets the target as node that has the distance of characters attack range
* List<GameObject> tempPath = MapGrid.getPath(currentNode,enemyLocation.x,enemyLocation.y);
* attackLocation = tempPath[rangedRange].GetComponent<NodeController>();
* return attackLocation;
*/
}
break;
}
return(null);
}
public void StartJobShouldReturnBadRequestWhenStartJobIdDoesNotMatchPrepareJobId()
{
_workerWrapper = new WorkerWrapper(new ShortRunningInvokeHandlerFake(),
_nodeConfigurationFake,
_nodeStartupNotification,
_pingToManagerFake,
_sendJobDoneTimer,
_sendJobCanceledTimer,
_sendJobFaultedTimer,
_trySendJobDetailToManagerTimer,
_jobDetailSender);
_nodeController = new NodeController(_workerWrapper)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
_nodeController.PrepareToStartJob(_jobQueueItemEntity);
var actionResult = _nodeController.StartJob(Guid.NewGuid());
Assert.IsTrue(actionResult.ExecuteAsync(new CancellationToken())
.Result.StatusCode ==
HttpStatusCode.BadRequest);
}
static void Main(string[] args)
{
var outputBus = new InMemoryBus("OutputBus");
var controller = new NodeController(outputBus);
var mainQueue = new QueuedHandler(controller, "Main Queue");
controller.SetMainQueue(mainQueue);
// Hello world service
var hello = new HelloWorldService(mainQueue);
outputBus.Subscribe<SystemMessage.SystemInit>(hello);
outputBus.Subscribe<SystemMessage.StartShutdown>(hello);
outputBus.Subscribe<HelloWorldMessage.Hi>(hello);
// TIMER
var timer = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
outputBus.Subscribe<TimerMessage.Schedule>(timer);
Console.WriteLine("Starting everything. Press enter to initiate shutdown");
mainQueue.Start();
mainQueue.Publish(new SystemMessage.SystemInit());
Console.ReadLine();
mainQueue.Publish(new SystemMessage.StartShutdown());
Console.ReadLine();
}
// Use this for initialization
void Start()
{
nodePrefab = transform.GetComponentInChildren <NodeController>();
foreach (Transform child in transform)
{
Destroy(child.gameObject);
}
nodePrefab.enabled = true;
nodePrefab.GetComponent <BoxCollider2D>().enabled = true;
for (int i = 0; i < size; ++i)
{
nodeGrid[i] = Instantiate(nodePrefab, transform);
nodeGrid[i].transform.localPosition = new Vector3(
i % width - (width - 1) / 2f,
i / width - (width - 1) / 2f, 0);
nodeGrid[i].name = "Node (" + i % width + ", " + i / width + ")";
nodeGrid[i].delta_pressure = 0.1f;
}
nodeGrid[0].delta_pressure = 1f;
int j = 0;
for (int y = 0; y < width; ++y)
{
for (int x = 0; x < width - 1; ++x)
{
connections[j++] = new NodeConnection(nodeGrid[x + y * width], nodeGrid[(x + 1) + y * width], new Vector2(1, 0));
connections[j++] = new NodeConnection(nodeGrid[y + x * width], nodeGrid[y + (1 + x) * width], new Vector2(0, 1));
}
}
transform.Translate(new Vector3(0, 0, width - 4));
}
private List<Vector2> findNeigboursForNode(NodeController node, List<Vector2> neighbours)
{
neighbours.Clear();
Vector2 nodeLocation = node.getNodeCoordinates();
for (int xOffset = -1; xOffset<=1; xOffset++)
{
int neighbourX = (int)nodeLocation.x + xOffset;
if (neighbourX < 0 ||
neighbourX >= boardWidth) continue;
for (int yOffset = -1; yOffset<= 1; yOffset++)
{
int neighbourY = (int)nodeLocation.y + yOffset;
if(neighbourY < 0 ||
neighbourY >= boardHeight ||
(neighbourX == nodeLocation.x && neighbourY == nodeLocation.y)) continue;
Vector2 neighbourLocalCoordinates = new Vector2(neighbourX, neighbourY);
neighbours.Add (neighbourLocalCoordinates);
}
}
return neighbours;
}
public void Spawn(List <Node> path, NodeController destinationNode, int amount, NetworkIdentity sender)
{
_path = path;
StopCoroutine(FollowPath(destinationNode, amount, sender));
StartCoroutine(FollowPath(destinationNode, amount, sender));
}
public async Task GetTaskAsync_Verbose_BlockNotFoundOnChain_ReturnsTransactionVerboseModelWithoutBlockInformationAsync()
{
Transaction transaction = this.CreateTransaction();
var txId = new uint256(12142124);
this.pooledTransaction.Setup(p => p.GetTransaction(txId))
.ReturnsAsync(transaction);
var blockStore = new Mock <IBlockStore>();
blockStore.Setup(b => b.GetTrxBlockIdAsync(txId))
.ReturnsAsync((uint256)null);
this.fullNode.Setup(f => f.NodeFeature <IBlockStore>(false))
.Returns(blockStore.Object);
this.controller = new NodeController(this.fullNode.Object, this.LoggerFactory.Object,
this.dateTimeProvider.Object, this.chainState.Object, this.nodeSettings,
this.connectionManager.Object, this.chain, this.network, this.pooledTransaction.Object,
this.pooledGetUnspentTransaction.Object, this.getUnspentTransaction.Object, this.networkDifficulty.Object);
string txid = txId.ToString();
bool verbose = true;
var json = (JsonResult)await this.controller.GetRawTransactionAsync(txid, verbose).ConfigureAwait(false);
var resultModel = (TransactionVerboseModel)json.Value;
Assert.NotNull(resultModel);
var model = Assert.IsType <TransactionVerboseModel>(resultModel);
Assert.Null(model.BlockHash);
Assert.Null(model.Confirmations);
Assert.Null(model.Time);
Assert.Null(model.BlockTime);
}
public NodeConnection(NodeController n0, NodeController n1, Vector2 normal)
{
this.n0 = n0;
this.n1 = n1;
this.normal = normal;
n0.AddConnection(this);
}
//todo - doesnt work
public GameObject findClosestBuilding(GameObject attackerNode)
{
Character closest = null;
Character[] playerCharacters = EnemyManager.TeamMembers;
int lowestDistance = 0;
//go through all enemies and compare distances
foreach (Character enemy in playerCharacters)
{
//Character enemyChar = enemy.GetComponent<Character>();
//if the checked character is knocked out skip it
if (enemy.knockedOut)
{
continue;
}
NodeController enemyNode = enemy.getCurrentNode().GetComponent <NodeController>();
int distance = MapGrid.getPath(attackerNode, enemyNode.x, enemyNode.y).Count;
//if no closest selected yet just set this one as it and move on
if (closest == null)
{
closest = enemy;
lowestDistance = distance;
continue;
}
if (distance < lowestDistance)
{
closest = enemy;
lowestDistance = distance;
}
}
return(closest.gameObject);
}
// Use this for initialization
void Start()
{
nodeControllerObject = Instantiate(Resources.Load<GameObject>(nodeControllerPath));
_nodeController = nodeControllerObject.GetComponent<NodeController>();
nodeControllerObject.transform.SetParent(transform);
//_arrowControllerObject = transform.FindChild("ArrowController").gameObject;
//_frameControllerObject = transform.FindChild("FrameController").gameObject;
}
public static NodeEntryPoint StartWithOptions(NodeOptions options, Action<int> termination)
{
var slim = new ManualResetEventSlim(false);
var list = String.Join(Environment.NewLine,
options.GetPairs().Select(p => String.Format("{0} : {1}", p.Key, p.Value)));
Log.Info(list);
var bus = new InMemoryBus("OutputBus");
var controller = new NodeController(bus);
var mainQueue = new QueuedHandler(controller, "Main Queue");
controller.SetMainQueue(mainQueue);
Application.Start(i =>
{
slim.Set();
termination(i);
});
var http = new PlatformServerApiService(mainQueue, String.Format("http://{0}:{1}/", options.LocalHttpIp, options.HttpPort));
bus.Subscribe<SystemMessage.Init>(http);
bus.Subscribe<SystemMessage.StartShutdown>(http);
var timer = new TimerService(new ThreadBasedScheduler(new RealTimeProvider()));
bus.Subscribe<TimerMessage.Schedule>(timer);
// switch, based on configuration
AzureStoreConfiguration azureConfig;
if (AzureStoreConfiguration.TryParse(options.StoreLocation, out azureConfig))
{
var storageService = new AzureStorageService(azureConfig, mainQueue);
bus.Subscribe<ClientMessage.AppendEvents>(storageService);
bus.Subscribe<SystemMessage.Init>(storageService);
bus.Subscribe<ClientMessage.ImportEvents>(storageService);
bus.Subscribe<ClientMessage.RequestStoreReset>(storageService);
}
else
{
var storageService = new FileStorageService(options.StoreLocation, mainQueue);
bus.Subscribe<ClientMessage.AppendEvents>(storageService);
bus.Subscribe<SystemMessage.Init>(storageService);
bus.Subscribe<ClientMessage.ImportEvents>(storageService);
bus.Subscribe<ClientMessage.RequestStoreReset>(storageService);
}
mainQueue.Start();
mainQueue.Enqueue(new SystemMessage.Init());
return new NodeEntryPoint(mainQueue,slim);
}
private NodeController[,] buildNetwork(NodeController[,] map)
{
for (int i = 0; i< boardWidth; i++)
{
for (int j = 0; j < boardHeight; j++)
{
GameObject newNode = Instantiate(nodePrefab, new Vector3(i,j,0f), Quaternion.identity) as GameObject;
newNode.transform.parent = this.transform;
Node newNodeView = newNode.GetComponent<Node>();
NodeModel newNodeModel = new NodeModel(new Vector2(i,j));
FSMSystem newNodeFSM = configureFSM();
map[i,j] = new NodeController(newNodeModel, newNodeView, newNodeFSM);
}
}
Utilities.alignGroupCenterToOrigin(transform,nodePrefab,boardWidth,boardHeight);
return map;
}
private void connectNodes(NodeController[,] map)
{
List<Vector2> neighboursLocalCoordinates = new List<Vector2> ();
for (int i = 0; i< boardWidth; i++)
{
for (int j = 0; j < boardHeight; j++)
{
NodeController node = map[i,j];
findNeigboursForNode(node, neighboursLocalCoordinates);
foreach( Vector2 location in neighboursLocalCoordinates)
{
node.addNeighbour(map[(int)location.x, (int)location.y]);
}
}
}
}
public void OnEnable()
{
nCont = (NodeController)target;
Transform t = nCont.transform.FindChild("Node " + (node + 1) + "/Line");
if (t != null)
{
Image line = t.GetComponent<Image>();
line.color = Color.yellow;
EditorUtility.SetDirty(line);
EditorApplication.MarkSceneDirty();
}
if (nCont.prefab == null)
{
nCont.prefab = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/TechTree/Prefabs/Node.prefab");
//Add Center Node
RectTransform currentNode = ((GameObject)PrefabUtility.InstantiatePrefab(AssetDatabase.LoadAssetAtPath<GameObject>("Assets/TechTree/Prefabs/CentralNode.prefab"))).GetComponent<RectTransform>();
currentNode.SetParent(nCont.transform, false);
currentNode.gameObject.GetComponent<NodeDataContainer>().location = 0;
}
EditorApplication.playmodeStateChanged += ClearColors;
}
public Idle(NodeController controller)
{
stateID = StateID.Idle;
nodeController = controller;
}
public static void SetNodeController(NodeController nodeControllerScript)
{
Node.nodeControllerScript = nodeControllerScript;
}
// 隣接判定、ノードごとの処理
public void NodeCheckAction(NodeController.NodeLinkTaskChecker Tc, _eLinkDir Link)
{
NodeDebugLog += "NodeCheckAction. CheckerID : " + Tc.ID + "\n";
// チェック済みでスキップ
if (bChecked) { Tc.Branch--; return; }
// 各種変数定義
bool bBranch = false;
bChecked = true;
Tc.SumNode++;
bChain = false;
// お隣さんを更新
UpdateNegibor();
// 状態表示
Tc += (ToString() + "Action \n Link : " + bitLink.ToStringEx() + "\nNegibor : " + Negibor.ToStringEx());
Tc += Tc.NotFin + " : " + Tc.Branch.ToString();
// チェックスタート
// 接地判定（根本のみ）
if (Link == _eLinkDir.NONE) // 根本か確認
{
if (!bitLink[(int)_eLinkDir.RD] && !bitLink[(int)_eLinkDir.LD]) // 下方向チェック
{
Tc.Branch--;
Tc.SumNode--;
bChecked = false;
return; // 繋がってないなら未チェックとして処理終了
}
// 繋がっている
Tc += ("Ground");
}
// この時点で枝が繋がっている事が確定
bChain = true;
Tc.NodeList.Add(this); // チェッカに自身を登録しておく
// 終端ノードであれば、周囲チェック飛ばす
var TempBit = new BitArray(6);
// 除外方向設定
TempBit.SetAll(false);
if (Link == _eLinkDir.NONE)
{
TempBit.Set((int)_eLinkDir.RD, true);
TempBit.Set((int)_eLinkDir.LD, true);
}
else {
TempBit.Set((int)Link, true);
}
TempBit.And(bitLink).Xor(bitLink); // 自身の道とAND後、自身の道とXOR。
if (TempBit.isZero()) // 比較して一致なら除外方向以外に道がない = XOR後に全0なら終端
{
Tc.Branch--; // 終端ノードであればそこで終了
return;
}
// 周囲のチェック
// この時点で、TempBitは先が壁の道を除いた自分の道を示している。
Tc += "ExcludeFrom MyWay : " + TempBit.ToStringEx();
for (int n = 0; n < (int)_eLinkDir.MAX; n++)
{
var TempBit2 = new BitArray(6);
// 隣接ノードのうち、道が無い場所に自分の道が伸びてたらそこは途切れている。
TempBit2 = TempBit.retAnd(Negibor.retNot());
// ノード繋がってない
if (TempBit2[n])
{
nodeControllerScript.unChainController.AddObj(this, (_eLinkDir)n);
Tc.NotFin = true; // 隣と繋がってないので、枝未完成として登録
}
}
Tc += ("Negibor : " + Negibor.ToStringEx());
TempBit.And(Negibor); // 隣接ノードと繋がっている場所を特定
Tc += "Linked : " + TempBit.ToStringEx();
for (int n = 0; n < (int)_eLinkDir.MAX; n++)
{
if (!TempBit[n]) { continue; } // ビット立ってないならスキップ
// お隣さんと繋がっているので、処理引き渡しの準備
bChain = true;
// デバック表示
Tc += ("Linked [" + LinkDirToString(n) + "]");
// 接続先がおかしいならノーカンで
Vec2Int Target = nodeControllerScript.GetDirNode(nodeID, (_eLinkDir)n);
if (Target.x == -1) { continue; }
// 分岐を検出してカウント
if (!bBranch)
{
bBranch = true; // 一回目ならノーカン
}
else {
Tc.Branch++; // 二回目以降は分岐なので、枝カウンタを+1
}
// 次へ引き渡す
Node TgtNode = nodeControllerScript.GetNodeScript(Target);
if (TgtNode.IsOutPuzzle)
{
Tc.Branch--; // 接続先が壁なら処理飛ばして枝解決
}
else {
// 周囲のActionをトリガーさせる
Observable
.Return(TgtNode)
.Subscribe(_ => {
TgtNode.NodeCheckAction(Tc, (_eLinkDir)((n + 3 >= 6) ? (n + 3 - 6) : (n + 3)));
}).AddTo(this);
}
}
if (Tc.NotFin && Tc.Branch > 0)
{
Tc.Branch--;
}
}
public void networkBuildMEthodTest()
{
MethodInfo buildMethod = testNetworkProbe.getMethod ("buildNetwork");
NodeController[,] newMap = new NodeController[4, 4];
newMap = buildMethod.Invoke(testNetwork, new object[]{newMap}) as NodeController[,];
Assert.AreEqual (4 * 4, newMap.Length);
}
public SquareGrid(int[,] level, float squareSize){
int nodeCountX = level.GetLength(0);
int nodeCountZ = level.GetLength(1);
float levelWidth = nodeCountX * squareSize;
float levelHeight = nodeCountZ * squareSize;
NodeController[,] nodeController = new NodeController[nodeCountX, nodeCountZ];
for(int x = 0; x < nodeCountX; x++){
for (int z = 0; z < nodeCountZ; z++){
Vector3 position = new Vector3(-levelWidth/2 + x * squareSize + squareSize/2, 0, -levelHeight/2 + z * squareSize + squareSize/2);
nodeController[x, z] = new NodeController(position, level[x, z] == 1, squareSize);
}
}
squares = new SquareSetup[nodeCountX - 1, nodeCountZ -1];
for(int x = 0; x < nodeCountX - 1; x++){
for (int z = 0; z < nodeCountZ - 1; z++){
squares[x, z] = new SquareSetup(nodeController[x, z + 1],
nodeController[x + 1, z + 1],
nodeController[x + 1, z],
nodeController[x, z]);
}
}
}
public SquareSetup (NodeController _northwestCorner, NodeController _northeastCorner,
NodeController _southeastCorner, NodeController _southwestCorner){
northwestCorner = _northwestCorner;
northeastCorner = _northeastCorner;
southeastCorner = _southeastCorner;
southwestCorner = _southwestCorner;
north = northwestCorner.nodeRight;
east = southeastCorner.nodeAbove;
south = southwestCorner.nodeRight;
west = southwestCorner.nodeAbove;
//
if(northwestCorner.nodeActive){
config += 8;
}
if(northeastCorner.nodeActive){
config += 4;
}
if(southeastCorner.nodeActive){
config += 2;
}
if(southwestCorner.nodeActive){
config += 1;
}
}
