private IEnumerator BeginWaveSpawn(WaveNode node)
{
while (!node.IsReady())
{
yield return(new WaitForSeconds(1f));
}
yield return(new WaitForSeconds(node.Delay));
int spawnedEnemiesCount = 0; // node.EnemiesCount;
List <Enemy> enemies = new List <Enemy>();
while (spawnedEnemiesCount < node.EnemiesCount)
{
GameObject enemyGO = Instantiate(node.Enemy);
spawnedEnemiesCount++;
Enemy enemy = enemyGO.GetComponent <Enemy>();
enemies.Add(enemy);
enemy.OnDie.AddListener(
() => { enemies.Remove(enemy); }
);
yield return(new WaitForSeconds(node.SpawnInterval));
}
while (enemies.Count > 0)
{
yield return(new WaitForSeconds(1f));
}
node.Complete();
}
public DeliveryAnalyticsViewModel(
IUnitOfWorkFactory unitOfWorkFactory,
IInteractiveService interactiveService,
INavigationManager navigation,
IEntityAutocompleteSelectorFactory districtSelectorFactory)
: base(interactiveService, navigation)
{
_interactiveService = interactiveService ?? throw new ArgumentNullException(nameof(interactiveService));
DistrictSelectorFactory = districtSelectorFactory ?? throw new ArgumentNullException(nameof(districtSelectorFactory));
if (unitOfWorkFactory is null)
{
throw new ArgumentNullException(nameof(unitOfWorkFactory));
}
Uow = unitOfWorkFactory.CreateWithoutRoot();
Title = "Аналитика объёмов доставки";
WaveList = new GenericObservableList <WaveNode>();
WeekDayName = new GenericObservableList <WeekDayNodes>();
GeographicGroupNodes = new GenericObservableList <GeographicGroupNode>();
WageDistrictNodes = new GenericObservableList <WageDistrictNode>();
foreach (var wage in Uow.GetAll <WageDistrict>().Select(x => x).ToList())
{
var wageNode = new WageDistrictNode(wage);
wageNode.Selected = true;
WageDistrictNodes.Add(wageNode);
}
foreach (var geographic in Uow.GetAll <GeographicGroup>().Select(x => x).ToList())
{
var geographicNode = new GeographicGroupNode(geographic);
geographicNode.Selected = true;
GeographicGroupNodes.Add(geographicNode);
}
foreach (var wave in Enum.GetValues(typeof(WaveNodes)))
{
var waveNode = new WaveNode {
WaveNodes = (WaveNodes)wave, Selected = true
};
WaveList.Add(waveNode);
}
foreach (var week in Enum.GetValues(typeof(WeekDayName)))
{
if ((WeekDayName)week == Domain.Sale.WeekDayName.Today)
{
continue;
}
var weekNode = new WeekDayNodes {
WeekNameNode = (WeekDayName)week, Selected = true
};
WeekDayName.Add(weekNode);
}
}
/// <summary>
/// Retorna la siguiente wave
/// </summary>
/// <param name="node">Nodo actual</param>
/// <returns>La siguiente wave del nodo</returns>
public WaveNode GetNextWave(WaveNode node)
{
if (!NextWaveIsConnected(node))
{
return(null);
}
NodePort output = currentNode.GetOutputPort("nextWave");
return(output.Connection.node as WaveNode);
}
/// <summary>
/// Inicia una wave de un nodo
/// </summary>
/// <param name="node">Nodo con informacion de la wave</param>
public void StartWave(WaveNode node)
{
onStartWave.Invoke();
Debug.Log("Empezando la wave!");
EnemyNode[] enemies = GetWaveEnemyNodes(node).ToArray();
foreach (EnemyNode enemy in enemies)
{
StartCoroutine(WaveManager.Manager.SpawnEnemies(enemy));
}
}
private void OnWaveComplete(WaveNode node)
{
foreach (WaveNode childNode in node.getNext())
{
RunWaveNode(childNode);
}
node.OnComplete -= OnWaveComplete;
ActiveWavesCount--;
}
private void RunWaveNode(WaveNode node)
{
ActiveWavesCount++;
if (node.IsRunning)
{
return;
}
node.IsRunning = true;
StartCoroutine(BeginWaveSpawn(node));
node.OnComplete += OnWaveComplete;
}
/// <summary>
/// Chequea si la wave tiene enemigos ???????????????????????????????????????????????
/// </summary>
/// <param name="node">Nodo a chequear</param>
/// <returns>Si tiene o no enemigos</returns>
public bool WaveHaveEnemies(WaveNode node)
{
if (node.GetOutputPort("enemies").IsConnected)
{
NodePort output = node.GetOutputPort("enemies");
if (output.GetConnections().Count > 0)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Chequea si hay una wave siguiente
/// </summary>
/// <param name="node">Nodo a chequear</param>
/// <returns>Si hay una wave mas</returns>
public bool NextWaveIsConnected(WaveNode node)
{
if (node.GetOutputPort("nextWave").IsConnected)
{
NodePort output = node.GetOutputPort("nextWave");
if (output.GetConnection(0).node.GetOutputPort("nextWave").GetConnections().Count > 0)
{
return(true);
}
}
return(false);
}
public void NextWave()
{
//if (currentNode == null) Debug.LogError("EL NODO ACTUAL ES NULO!");
//if (currentNode.GetOutputPort("nextWave") == null) Debug.LogError("EL OUTPUT ME DA NULO");
NodePort otherPort = currentNode.GetOutputPort("nextWave").Connection;
if (currentNode.GetOutputPort("nextWave").Connection == null)
{
Debug.LogError("EL OUTPUT ME DA NULO");
}
if (otherPort.node != null)
{
currentNode = otherPort.node as WaveNode;
}
}
/// <summary>
/// Nodos de enemigos de la wave
/// </summary>
/// <param name="node">Nodo a revisar</param>
/// <returns>Los nodos de enemigos si hay</returns>
public List <EnemyNode> GetWaveEnemyNodes(WaveNode node)
{
if (!WaveHaveEnemies(node))
{
return(null);
}
List <NodePort> connections = node.GetOutputPort("enemies").GetConnections();
List <EnemyNode> enemies = new List <EnemyNode>();
foreach (NodePort port in connections)
{
enemies.Add(port.node as EnemyNode);
}
return(enemies);
}
public override void OnHeaderGUI()
{
GUI.color = Color.white;
WaveNode node = target as WaveNode;
WavesGraph graph = node.graph as WavesGraph;
string title = target.name;
if (node == graph.initialWave && node.firstWave == true)
{
//Hay un bug y hay un nodo que si lo haces el primero, los demas tambien se ponen rojos
//pero es solo un bug visual lol
title = "Initial wave";
GUI.contentColor = Color.red;
}
GUILayout.Label(title, NodeEditorResources.styles.nodeHeader, GUILayout.Height(30));
GUI.color = Color.white;
}
/// <summary>
/// Accede a la siguiente wave del grafo, si no hay, activa evento de que terminaron
/// </summary>
public void NextWave()
{
if (currentNode.GetOutputPort("nextWave") == null)
{
Debug.LogError("No hay un puerto de salida nextWave", currentNode);
}
if (NextWaveIsConnected(currentNode))
{
wavesGraph.NextWave();
currentNode = wavesGraph.currentNode;
StartWave(currentNode);
}
else
{
Debug.Log("Ya no hay mas waves!");
onAllWavesCompleted.Invoke();
}
}
public override void OnBodyGUI()
{
base.OnBodyGUI();
WaveNode node = target as WaveNode;
WavesGraph graph = node.graph as WavesGraph;
if (node != graph.initialWave)
{
if (GUILayout.Button("Set as first wave"))
{
if (graph.initialWave != null)
{
graph.initialWave.firstWave = false;
}
graph.initialWave = node;
graph.currentNode = node;
node.firstWave = true;
}
}
}
private void PopulatWaveNodes()
{
for (int i = 0; i < _path.Nodes.Count; i++)
{
if (_path.Nodes[i].TangentType == Path.Node.Type.Auto)
{
WaveNode waveNode = new WaveNode();
waveNode.pathNode = i;
Vector3 pointBefore = Vector3.zero;
Vector3 pointAfter = Vector3.zero;
// Define tangent
if (waveNode.pathNode == 0)
{
pointAfter = _path.Nodes[waveNode.pathNode + 1].Position;
pointBefore = _path.Nodes[_path.Nodes.Count - 1].Position;
}
else if (waveNode.pathNode == _path.Nodes.Count - 1)
{
pointAfter = _path.Nodes[0].Position;
pointBefore = _path.Nodes[waveNode.pathNode - 1].Position;
}
else
{
pointAfter = _path.Nodes[waveNode.pathNode + 1].Position;
pointBefore = _path.Nodes[waveNode.pathNode - 1].Position;
}
// Describe values
waveNode.tangent = (pointAfter - pointBefore).normalized;
waveNode.tangentWeight = Vector3.Distance(pointBefore, pointAfter) / Mathf.PI;
waveNode.normal = Vector3.Cross(waveNode.tangent, Vector3.forward);
_waveNodes.Add(waveNode);
}
}
}
void ContextCallback(object obj)
{
string clb = obj.ToString();
if (clb.Equals("noiseNode"))
{
NoiseNode noiseNode = new NoiseNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 150));
//noiseNode.myComputeTextureCreator = computeTextureCreator;
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
noiseNode.index = nodes.Count - 1;
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
//AssetDatabase.ImportAsset(pathName);
}
else if (clb.Equals("calculationNode"))
{
CalculationNode noiseNode = new CalculationNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 150));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("outputNode"))
{
OutputNode noiseNode = new OutputNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 200));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("waveNode"))
{
WaveNode noiseNode = new WaveNode();
noiseNode.windowRect = new Rect(mousePos, new Vector2(200, 200));
nodes.Add(noiseNode);
noiseNode.name = "zzz" + noiseNode.name + saver.assetAmount.ToString();
saver.assetAmount += 1;
saver.nodes.Add(noiseNode);
AssetDatabase.AddObjectToAsset(noiseNode, pathName);
AssetDatabase.SaveAssets();
}
else if (clb.Equals("makeTransition"))
{
bool clickedOnWindow = false;
BaseNode tempSelectedNode = null;
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
tempSelectedNode = node;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
selectedNode = tempSelectedNode;
makeTransitionMode = true;
}
AssetDatabase.SaveAssets();
}
else if (clb.Equals("callMethod"))
{
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
((NoiseNode)(node)).TheMethod(0);
break;
}
}
}
else if (clb.Equals("deleteNode"))
{
bool clickedOnWindow = false;
BaseNode tempSelectedNode = null;
int index = 0;
foreach (BaseNode node in nodes)
{
if (node.windowRect.Contains(mousePos))
{
index = nodes.IndexOf(node);
tempSelectedNode = node;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
//nodes = nodes.Where(x => x.index != index).ToList();
//nodes.Remove(tempSelectedNode);
nodes.Remove(tempSelectedNode);
saver.nodes.Remove(tempSelectedNode);
//nodes.RemoveAt(index);
foreach (BaseNode node in nodes)
{
node.NodeDeleted(tempSelectedNode);
//node.NodeDeleted(index);
}
DestroyImmediate(tempSelectedNode, true);
AssetDatabase.SaveAssets();
//AssetDatabase.ImportAsset(pathName);
}
}
}
/// <summary>
/// Inicia el sistema de waves del nivel
/// </summary>
public void StartLevelWaves()
{
wavesGraph.RestartWave();
currentNode = wavesGraph.currentNode;
StartWave(currentNode);
}
public void RestartWave()
{
currentNode = initialWave;
//if (initialWave == null) Debug.LogError("LA WAVE INICIAL ES NULA!");
//if (currentNode == null) Debug.LogError("EL NODO ACTUAL ES NULO!");
}
