public virtual void UpdateLogic(Time timeElapsed)
{
if (this.levelNode != null)
{
this.levelNode.UpdateLogic(this, timeElapsed);
if (this.levelNode.NodeState == NodeState.NOT_ACTIVE)
{
this.levelNode.VisitEnd(this);
if (this.levelNode.NextNode == null)
{
this.levelNode = null;
}
else
{
this.levelNode = this.levelNode.NextNode as LevelNode;
this.levelNode.VisitStart(this);
}
}
}
foreach (ALayer layer in this.layers)
{
layer.UpdateLogic(this, timeElapsed);
}
}
private void InsertLevel()
{
selectedObject = Selection.activeGameObject;
var selectedNodeIndex = selectedObject.transform.GetSiblingIndex();
GameObject insertedLevelObject = new GameObject("Level Node " + levelNodeRoot.childCount, typeof(LevelNode));
insertedLevelObject.transform.SetParent(levelNodeRoot, false);
LevelNode levelNode = insertedLevelObject.GetComponent <LevelNode>();
if (levelNodeRoot.childCount > 1)
{
levelNode.previousLevel = levelNodeRoot.GetChild(selectedNodeIndex).gameObject.GetComponent <LevelNode>();
levelNode.nextLevel = levelNode.previousLevel.nextLevel;
levelNode.previousLevel.nextLevel = levelNode;
levelNode.nextLevel.previousLevel = levelNode;
levelNode.transform.position = (levelNode.nextLevel.transform.position + levelNode.previousLevel.transform.position) / 2;
levelNode.transform.forward = levelNode.previousLevel.transform.forward;
}
insertedLevelObject.transform.SetSiblingIndex(selectedNodeIndex + 1);
ResetNames(1);
}
private void InsertAnchor()
{
selectedObject = Selection.activeGameObject;
var selectedNodeIndex = selectedObject.transform.GetSiblingIndex();
GameObject levelAnchorObject = new GameObject("Anchor Node " + anchorNodeRoot.childCount, typeof(LevelNode));
levelAnchorObject.transform.SetParent(anchorNodeRoot, false);
LevelNode levelAnchor = levelAnchorObject.GetComponent <LevelNode>();
if (anchorNodeRoot.childCount >= 1)
{
levelAnchor.previousLevel = levelNodeRoot.GetChild(selectedNodeIndex).gameObject.GetComponent <LevelNode>();
levelAnchor.nextLevel = levelAnchor.previousLevel.nextLevel;
levelAnchor.previousLevel.nextLevel = levelAnchor;
levelAnchor.nextLevel.previousLevel = levelAnchor;
levelAnchor.transform.position = (levelAnchor.nextLevel.transform.position + levelAnchor.previousLevel.transform.position) / 2;
levelAnchor.transform.forward = levelAnchor.previousLevel.transform.forward;
}
levelAnchorObject.transform.SetSiblingIndex(selectedNodeIndex + 1);
ResetNames(3);
}
private void GenerateNodes(LevelMapSO _levelFlowSO)
{
//Start Data
foreach (StartNodeData _data in _levelFlowSO.startNodeDatas)
{
StartNode _startNode = graphView.CreateStartNode(_data.position);
_startNode.NodeGuid = _data.guid;
_startNode.startName = _data.startName;
_startNode.portSet = _data.portSet;
_startNode.LoadValueIntoField();
graphView.AddElement(_startNode);
}
//Level Node
foreach (LevelNodeData _data in _levelFlowSO.levelNodeDatas)
{
LevelNode _lvNode = graphView.CreateLevelNode(_data.position);
_lvNode.NodeGuid = _data.guid;
//_lvNode.scene = _data.scene;
//_lvNode.scenePath = _data.scenePath;
_lvNode.scenAssetGuid = _data.sceneAssestGuid;
_lvNode.asyncType = _data.asyncType;
_lvNode.loadType = _data.loadType;
_lvNode.portSets = _data.portSets;
_lvNode.scenePath = _data.scenePath;
Debug.Log("1. GenerateNodes port count" + _data.portSets.Count);
_lvNode.LoadValueIntoField();
graphView.AddElement(_lvNode);
}
}
void CheckTouch()
{
Touch touch = Input.GetTouch(0);
RaycastHit hit;
Ray ray = camera.ScreenPointToRay(touch.position);
if (Physics.Raycast(ray, out hit))
{
Debug.Log("Touch Hit " + hit.collider.gameObject.name);
currentSelected = hit.collider.gameObject.GetComponent <LevelNode>();
if (currentSelected != null)
{
//set the previous cube as not selected
if (previousSelectedNode != null)
{
previousSelectedNode.isSelected = false;
}
//set the current cube as selected
currentSelected.isSelected = true;
//assgn the currently selected cube as the previous cube, for the next round
previousSelectedNode = currentSelected;
}
}
}
/// <summary>
/// Returns whether or not the given path could continue in the given direction.
/// </summary>
/// <param name="path">The path to check.</param>
/// <param name="dir">The direction to check.</param>
/// <returns>True if the path could continue in that direction; false otherwise.</returns>
private bool IsDirectionPossibleForPathContinuation(LevelPath path, Direction dir)
{
// Verify that the path has a tail node
LevelNode tailNode = path.TailNode;
if (tailNode == null)
{
throw new ArgumentException("Cannot operate on given path; path has no nodes.");
}
// Get the new coordinates
Tuple <int, int> newCoordinates = GetNewCoordinatesInDirection(tailNode.WorldRow, tailNode.WorldColumn, dir);
int newRow = newCoordinates.First;
int newCol = newCoordinates.Second;
// If the coordinates are outside the world, we can't continue here
if (!AreCoordinatesInsideWorld(path.ParentWorld, newRow, newCol))
{
return(false);
}
// If there is a non tail node at these coordinates, we can't continue here
LevelNode nodeAtCoordinates = path.ParentWorld.ChildNodes[newRow, newCol];
if (nodeAtCoordinates != null && !nodeAtCoordinates.IsTailNodeOfPath())
{
return(false);
}
return(true);
}
/// <summary>
/// Continues the given path from the given node in the given direction.
/// </summary>
/// <param name="path">The path to continue.</param>
/// <param name="previousNode">The previous node that connects to the new node or join. Typically, this will be the given path's tail node.</param>
/// <param name="directionToContinue">The direction to continue the path in from the previous node.</param>
/// <exception cref="InvalidOperationException">Thrown if the new node's coordinates would be outside the world.</exception>
/// <returns>True if the path can continue after this step; false otherwise.</returns>
private bool ProcessPathContinuation(LevelPath path, LevelNode previousNode, Direction directionToContinue)
{
Tuple <int, int> newNodeCoords = GetNewCoordinatesInDirection(previousNode, directionToContinue);
bool pathContinuesNextIteration = false;
// Verify that the new coordinates are inside the world
if (!AreCoordinatesInsideWorld(previousNode.ParentWorld, newNodeCoords.First, newNodeCoords.Second))
{
throw new InvalidOperationException(string.Format(
"Cannot add new node at the given direction from the given node. New node would have coordinates ({0}, {1}), which are outside the world.", newNodeCoords.First, newNodeCoords.Second));
}
// If there's no node at these coordinates, create a new node
LevelNode nodeAtCoordinates = path.ParentWorld.ChildNodes[newNodeCoords.First, newNodeCoords.Second];
if (nodeAtCoordinates == null)
{
nodeAtCoordinates = new LevelNode(path, newNodeCoords.First, newNodeCoords.Second);
// Since we added a new node (and didn't join paths), this path continues
pathContinuesNextIteration = true;
}
// Join the nodes
previousNode.UpdateOpenSideStatus(directionToContinue, true);
nodeAtCoordinates.UpdateOpenSideStatus(GetOppositeDirection(directionToContinue), true);
return(pathContinuesNextIteration);
}
protected override void DoUpdate(SAMTime gameTime, InputState istate)
{
var sel = ((GDWorldHUD)HUD).SelectedNode;
tabTimer += gameTime.ElapsedSeconds;
tab = (int)(tabTimer / TAB_SWITCHTIME) % 3;
if (sel != null && progressDisplay < 1)
{
tabTimer = 0;
tab = 0;
FloatMath.ProgressInc(ref progressDisplay, gameTime.ElapsedSeconds * SPEED_BLEND);
node = sel;
}
else if (sel == null && progressDisplay > 0)
{
FloatMath.ProgressDec(ref progressDisplay, gameTime.ElapsedSeconds * SPEED_BLEND);
}
else if (sel != null && node != null && sel != node)
{
node = sel;
}
IsVisible = FloatMath.IsNotZero(progressDisplay);
}
public Vector3 Load(LevelNode levelNode, int levelId, int stageId, Vector3 startpos)
{
stageEntity = LevelResManager.Instance.GetStage(levelId, levelNode.type);
//stageEntity.gameObject.transform.position = levelNode.GetPosition (LevelManager.width,LevelManager.heigh);
Vector3 local = startpos;
local.x = local.x + stageEntity.getXSize() * 0.5f;
local.y = local.y + stageEntity.getYSize() * 0.5f;
stageEntity.gameObject.transform.position = local;
if (levelNode.type == eNodeType.Start)
{
stageEntity.gameObject.name = "start";
}
if (levelNode.type == eNodeType.End)
{
stageEntity.gameObject.name = "end";
}
if (levelNode.type == eNodeType.Boss)
{
stageEntity.gameObject.name = "boss";
}
if (levelNode.type == eNodeType.Normal)
{
stageEntity.gameObject.name = "normal";
}
stageEntity.InitDoorState(levelNode, stageId);
stageEntity.OpenAllEnableDoor();
startpos.x = startpos.x + stageEntity.getXSize();
return(startpos);
}
private void Init()
{
// create level nodes
levelNodes = new List <LevelNode>();
for (int i = 0; i < levelCount; i++)
{
var node = new LevelNode();
int worldIndex = i / levelPerWorld;
int index = i % levelPerWorld;
node.Name = string.Format("{0}-{1}", (char)('A' + worldIndex), index);
node.StarNumber = (i % 3) + 1;
node.SelectCommand = new DelegateCommand(() => SelectLevel(node));
levelNodes.Add(node);
}
// create boss level nodes
bossLevelNodes = new List <BossLevelNode>();
for (int i = 0; i < bossLevelCount; i++)
{
var node = new BossLevelNode();
node.Name = string.Format("Boss {0}", (char)('A' + i));
node.RequiredStarNumber = 10 * (i + 1);
node.SelectCommand = new DelegateCommand(() => SelectBossLevel(node));
bossLevelNodes.Add(node);
}
}
public void CancelRoadSign()
{
LevelNode node = levelNode.GetComponent <LevelNode>();
node.notOpen.SetActive(true);
node.roadSign.SetActive(false);
node.levelSprite.enabled = false;
}
//Methods
//---------------------------------------------
public LevelNodeController()
{
Previous = null;
_step = null;
_length = 0;
_levelNode = World.Instance.Level.CreateLevelNode <DefaultNode>(this);
OnLengthChanged += _levelNode.OnPreviousNodeChangedLength;
}
//----------------//
// Updating Nodes //
//----------------//
/// <summary>
/// Adds a node to this path and the parent world at the given location.
/// </summary>
/// <param name="node">The node to add.</param>
/// <param name="row">The row to place the node in.</param>
/// <param name="col">The column to place the node in.</param>
public void AddNode(LevelNode node, int row, int col)
{
if (!ChildNodes.Contains(node))
{
ParentWorld.AddNode(node, row, col);
ChildNodes.Add(node);
}
}
/// <summary>
/// Removes the given node from this world.
/// </summary>
/// <param name="node">The node to remove.</param>
public void RemoveNode(LevelNode node)
{
if (ChildNodes.Contains(node))
{
ParentWorld.RemoveNode(node);
ChildNodes.Remove(node);
}
}
public void SetLevel(LevelNode target)
{
if (nodes[target.reference] != null)
{
currentLevel = target.reference;
currentNode = target.id;
}
}
//---------------//
// Build Helpers //
//---------------//
/// <summary>
/// Continues building the world given the current active paths in it.
/// </summary>
/// <param name="world">The world to continue building.</param>
/// <param name="currentActivePaths">The current active paths in the world.</param>
/// <returns>The world after all active paths have completed.</returns>
private LevelWorld BuildWorldFromExistingPaths(LevelWorld world, List <LevelPath> currentActivePaths)
{
while (currentActivePaths.Count > 0)
{
List <LevelPath> nextIterationActivePaths = new List <LevelPath>();
foreach (var path in currentActivePaths)
{
// Verify that the path has at least one node already
LevelNode tailNode = path.TailNode;
Debug.Assert(tailNode != null);
// Get the possible directions to move
List <Direction> possibleDirections = GetPossibleDirectionsForPathContinuation(path);
// Check to see if we're out of possible directions
if (possibleDirections.Count == 0)
{
// Note that we don't add this current path to the next iteration's paths; this path is done
continue;
}
// Continue the path in a random direction
Direction dirToContinueIn = GetRandomDirection(possibleDirections);
bool addPathToNextIteration = ProcessPathContinuation(path, tailNode, dirToContinueIn);
if (addPathToNextIteration)
{
nextIterationActivePaths.Add(path);
}
// Check for a split
float splitCheck = UnityEngine.Random.Range(0.0f, 1.0f);
if (splitCheck < splitChance)
{
possibleDirections.Remove(dirToContinueIn);
// Check if there are any directions to continue in
if (possibleDirections.Count != 0)
{
// Get the direction for the new node
Direction dirToSplitIn = GetRandomDirection(possibleDirections);
// Create the new path and add a node to it
LevelPath splitPath = new LevelPath(world);
addPathToNextIteration = ProcessPathContinuation(splitPath, tailNode, dirToSplitIn);
if (addPathToNextIteration)
{
nextIterationActivePaths.Add(splitPath);
}
}
}
}
// Update the current paths for the next iteration
currentActivePaths = nextIterationActivePaths;
}
return(world);
}
//----------------//
// Updating Nodes //
//----------------//
/// <summary>
/// Adds a node to this path and the parent world at the given location.
/// </summary>
/// <param name="node">The node to add.</param>
/// <param name="row">The row to place the node in.</param>
/// <param name="col">The column to place the node in.</param>
public void AddNode(LevelNode node, int row, int col)
{
if (!ChildNodes.Contains(node))
{
ParentWorld.AddNode(node, row, col);
ChildNodes.Add(node);
}
}
static void NodeAnchorCallback()
{
LevelNode selectedNode = Selection.activeGameObject.GetComponent <LevelNode>();
isAnchor = !isAnchor;
/* if(isAnchor) selectedNode.isAnchorNode = true;
* else selectedNode.isAnchorNode = false;*/
}
public void InitDoorState(LevelNode node, int stageId)
{
leftDoor.mStageId = stageId;
rightDoor.mStageId = stageId;
leftDoor.SetDoorState(node.left);
rightDoor.SetDoorState(node.right);
type = node.type;
this.stageId = stageId;
}
public void Add(LevelNode url, uint level)
{
if (!Levels.ContainsKey(level)) // if it does not contain the key, create it
{
Levels = Levels.Add(level, ImmutableList <LevelNode> .Empty);
}
Levels = Levels.SetItem(level, Levels[level].Add(url));
}
public void OnNodeDeselected()
{
selectedLevel = null;
// update details pane
if (DetailsPane != null)
{
DetailsPane.SetBool("IsLevelSelected", false);
}
}
private void nextLevel()
{
//Good animation
Animation("AnimationSuccess");
this.s.playCorrectVoice(); // When the kid answer is correct
currentLevel = currentLevel.next;
changeLetter();
restart();
}
void SetLevelNode(LevelNode node)
{
Vector3 target = node.transform.position;
target.y += yOffset;
playerAnim.transform.position = target;
playerMoving = false;
playerAnim.SetBool("isMoving", false);
panelText.text = node.name;
node.SetCurrentNodeSprite(true);
}
//----------------//
// Updating Nodes //
//----------------//
/// <summary>
/// Adds a node to this world at the given location. Will throw an exception if this location is not empty.
/// </summary>
/// <param name="node">The node to add.</param>
/// <param name="row">The row to place the node in.</param>
/// <param name="col">The column to place the node in.</param>
/// <exception cref="InvalidOperationException">Thrown if the given location is not empty.</exception>
public void AddNode(LevelNode node, int row, int col)
{
// Make sure this location is empty
if (ChildNodes[row, col] != null)
{
throw new InvalidOperationException(string.Format(
"Cannot add node to location ({0}, {1}); location already has a node.", row, col));
}
// If we got here, we're good to proceed and add the node
ChildNodes[row, col] = node;
}
public TheGame(bool isRightHand)
{
this.isRightHand = isRightHand;
s = new Sounds.Sounds();
InitializeComponent();
//Init GameFlow
currentLevel = GameFlow.createGameFlow();
Loaded += delegate
{
if (currentLevel.getLetter().ToString().Length > 1)
{
getScreenSize(currentLevel.getLetter());
}
};
this.speechEngine = SpeechRecognition.init();
this.speechEngine.SpeechRecognized += this.SpeechRecognized;
_sensor = KinectSensor.GetDefault();
if (_sensor != null)
{
_sensor.Open();
_width = _sensor.ColorFrameSource.FrameDescription.Width;
_height = _sensor.ColorFrameSource.FrameDescription.Height;
_colorReader = _sensor.ColorFrameSource.OpenReader();
_colorReader.FrameArrived += ColorReader_FrameArrived;
_bodyReader = _sensor.BodyFrameSource.OpenReader();
_bodyReader.FrameArrived += BodyReader_FrameArrived;
_pixels = new byte[_width * _height * 4];
_bitmap = new WriteableBitmap(_width, _height, 96.0, 96.0, PixelFormats.Bgra32, null);
_bodies = new Body[_sensor.BodyFrameSource.BodyCount];
camera.Source = _bitmap;
changeLetter();
}
polylines = new List <Polyline>();
addNewPolyline();
isSecondClick = false;
}
public void SelectNode(LevelNode n)
{
SelectedNode = n;
InfoDisplay.ResetCycle();
foreach (var node in GDOwner.GetEntities <LevelNode>())
{
var s = node.StateSum;
if (node != n && (s == BistateProgress.Open || s == BistateProgress.Opening || s == BistateProgress.Undefined))
{
node.CloseNode();
}
}
}
void MovePlayerToNode(LevelNode node)
{
Vector3 target = node.transform.position;
target.y += yOffset;
if (Vector3.Distance(playerAnim.transform.position, target) > 0.1f)
{
playerAnim.transform.position = Vector3.MoveTowards(playerAnim.transform.position, target, moveSpeed * Time.deltaTime);
}
else
{
SetLevelNode(node);
}
}
public LevelEdge(LevelNode A, LevelNode B)
{
start = A;
end = B;
if (start.xIndex == end.xIndex)
{
edgeType = eEdgeType.Vetical;
}
else
{
edgeType = eEdgeType.Horizon;
}
pos = GetPosition(LevelManager.h1, LevelManager.h2);
}
public OfficeWorld()
{
this.objectsById = new Dictionary <string, AObject>();
this.layers = new List <ALayer>();
// Level creation
TutoLevelNode tutoLevelNode = new TutoLevelNode();
LevelNode firstLevelNode = this.CreateGame("Levels", 5);
// Level links
tutoLevelNode.NextNode = firstLevelNode;
this.levelNode = tutoLevelNode;
}
public LevelNodeController(LevelNodeController previous, Scenario.IScenarioStep step)
{
Previous = previous;
_step = step;
_length = step.DefaultLength;
//instantiate the corresponding LevelNode for the step by calling Level's templated method via reflection
Type type = ScenarioStepToLevelNodeTypeDictionary[step.GetType()];
Debug.Assert(type.IsSubclassOf(typeof(LevelNode)));
// ReSharper disable once PossibleNullReferenceException
var genericMethod = typeof(View.Level.Level).GetMethod("CreateLevelNode").MakeGenericMethod(type);
_levelNode = (LevelNode)genericMethod.Invoke(World.Instance.Level, new object[] { this });
OnLengthChanged += _levelNode.OnPreviousNodeChangedLength;
}
/// <summary>
/// Removes the given node from this world. Will throw an exception if the node's store coordinates do not match its actual coordinates.
/// </summary>
/// <param name="node">The node to remove.</param>
/// <exception cref="InvalidOperationException">Thrown if the given node's location is occupied by a different node.</exception>
public void RemoveNode(LevelNode node)
{
// Check to make sure this node is registered at the correct location
if (ChildNodes[node.WorldRow, node.WorldColumn] == node)
{
// If it is, remove it
ChildNodes[node.WorldRow, node.WorldColumn] = null;
}
// If it's not, throw an exception
else
{
throw new InvalidOperationException(string.Format(
"Cannot remove node from location({0}, {1}); this location is occupied by a different node.", node.WorldRow, node.WorldColumn));
}
}
//-------------//
// Constructor //
//-------------//
/// <summary>
/// Instantiates a new level world with the given dimensions.
/// </summary>
/// <param name="rows">The number of rows in the world.</param>
/// <param name="cols">The number of columns in the world.</param>
public LevelWorld(int rows, int cols)
{
ChildPaths = new List<LevelPath>();
ChildNodes = new LevelNode[rows, cols];
}
/// <summary>
/// Draw the level tiles
/// </summary>
/// <param name="level"></param>
public void DrawLevel(LevelNode level)
{
// Bind sprite batcher
m_spriteBatch.Begin( );
// Draw background "brick"
Vector2 backgroundSize = new Vector2(((float)m_graphicsDevice.Viewport.Width * 0.55f), ((float)m_graphicsDevice.Viewport.Height * 0.55f));
Vector2 backgroundPos = new Vector2(((float)m_graphicsDevice.Viewport.Width / 2) - (backgroundSize.X / 2), ((float)m_graphicsDevice.Viewport.Height / 2) - (backgroundSize.Y / 2) - 50.0f);
Rectangle rc = new Rectangle((int)(((float)m_graphicsDevice.Viewport.Width * (float)level.x) + backgroundPos.X), (int)backgroundPos.Y, (int)backgroundSize.X, (int)backgroundSize.Y);
m_spriteBatch.Draw(m_levelBackground, rc, Color.White);
// Calculate a new camera scale to fit the level to as much as possible of the background brick
// minus the border level height as reference
float newCameraScaleX = ((float)backgroundSize.X + BORDER_SIZE) / ((float)(((float)level.level.Width + 1) * m_tileWidth * m_camera.Scale.X));
float newCameraScaleY = ((float)backgroundSize.Y + BORDER_SIZE) / ((float)(((float)level.level.Height + 1) * m_tileHeight * m_camera.Scale.Y));
float smallestScale = newCameraScaleX < newCameraScaleY ? newCameraScaleX : newCameraScaleY;
smallestScale = smallestScale > 1 ? 1 : smallestScale;
m_camera.SetScale(smallestScale, smallestScale);
// Translate camera to center on the level
float cameraX = (m_graphicsDevice.Viewport.Width / 2) - ((level.level.Width * m_tileWidth * m_camera.Scale.X) / 2);
float cameraY = (m_graphicsDevice.Viewport.Height / 2) - ((level.level.Height * m_tileHeight * m_camera.Scale.Y) / 2);
m_camera.Translate(cameraX + ((float)m_graphicsDevice.Viewport.Width * (float)level.x), cameraY - 50.0f);
// Draw statical tiles
List<Tile> staticTiles = level.level.StaticTiles;
foreach (Tile tile in staticTiles)
{
DrawTile(level.level, tile);
}
// Draw moveable tiles
List<Tile> moveableTiles = level.level.MoveableTiles;
foreach (Tile tile in moveableTiles)
{
DrawTile(level.level, tile);
}
// Unbind the sprite batcher
m_spriteBatch.End();
// Reset camera scale
m_camera.SetScale(1, 1);
}
/// <summary>
/// Builds a new world with the class's parameters and returns the start node of the world.
/// </summary>
/// <exception cref="InvalidOperationException">Thrown if world dimensions, start coordinates, or split chance is invalid.</exception>
/// <returns>The start node in the new world.</returns>
public LevelNode BuildNewWorld()
{
// Verify world dimensions
if (rowsInWorld < 1 || colsInWorld < 1)
{
throw new InvalidOperationException(
string.Format("Invalid world dimensions ({0}, {1}). Dimensions must be >= 1.", rowsInWorld, colsInWorld));
}
// Verify split chance
if (splitChance < 0 || splitChance > 1)
{
throw new InvalidOperationException(
string.Format("Invalid split chance {0}. Split chance must be >= 0 and <= 1.", splitChance));
}
// Create the world
LevelWorld world = new LevelWorld(rowsInWorld, colsInWorld);
// Verify start coordinates
if (!AreCoordinatesInsideWorld(world, startRow, startCol))
{
throw new InvalidOperationException(
string.Format("Invalid start coordinates ({0}, {1}) for world with dimensions ({0}, {1}). Coordinates must be located inside world.", startRow, startCol, rowsInWorld, colsInWorld));
}
// Add the first path and start node
LevelPath firstPath = new LevelPath(world);
LevelNode startNode = new LevelNode(firstPath, startRow, startCol);
// Get the directions for the next two nodes
List<Direction> possibleDirections = GetPossibleDirectionsForPathContinuation(firstPath);
Debug.Assert(possibleDirections.Count >= 2); // Since the world is square and there are no other nodes, there should always be at least 2 possible directions
Direction dirOfFirstPath = GetRandomDirection(possibleDirections);
possibleDirections.Remove(dirOfFirstPath);
Direction dirOfSecondPath = GetRandomDirection(possibleDirections);
// Add the nodes to the world
AddNodeToWorld(startNode, firstPath, dirOfFirstPath);
LevelPath secondPath = new LevelPath(world);
AddNodeToWorld(startNode, secondPath, dirOfSecondPath);
// Begin adding paths
List<LevelPath> currentActivePaths = new List<LevelPath>()
{
firstPath,
secondPath
};
while (currentActivePaths.Count > 0)
{
List<LevelPath> nextIterationActivePaths = new List<LevelPath>();
foreach (var path in currentActivePaths)
{
// Verify that the path has at least one node already
Debug.Assert(path.TailNode != null);
// Get the possible directions to move
possibleDirections = GetPossibleDirectionsForPathContinuation(path);
// Check to see if we're out of possible directions
if (possibleDirections.Count == 0)
{
// Note that we don't add this current path to the next iteration's paths; this path is done
continue;
}
// Get the direction for the new node
Direction dirToContinueIn = GetRandomDirection(possibleDirections);
// Check if this is a join or if we're adding a new node
Tuple<int, int> newCoordinates = GetNewCoordinatesInDirection(path.TailNode, dirToContinueIn);
LevelNode nodeAtCoordinates = world.ChildNodes[newCoordinates.First, newCoordinates.Second];
// If there's no node at these coordinates, add the node
if (nodeAtCoordinates == null)
{
AddNodeToWorld(path.TailNode, path, dirToContinueIn);
// This path continues next iteration
nextIterationActivePaths.Add(path);
}
// Otherwise, process a path join
else
{
JoinNodes(path.TailNode, nodeAtCoordinates);
// Note that we don't add this current path to the next iteration's paths; this path is done
continue;
}
// Check for a split
float splitCheck = UnityEngine.Random.Range(0.0f, 1.0f);
if (splitCheck < splitChance)
{
possibleDirections.Remove(dirToContinueIn);
// Check if there are any directions to continue in
if (possibleDirections.Count == 0)
{
// Get the direction for the new node
Direction dirToSplitIn = GetRandomDirection(possibleDirections);
// TODO: Implement. Perhaps refactor lines 103 to 125
}
}
}
// Update the current paths for the next iteration
currentActivePaths = nextIterationActivePaths;
}
return startNode;
}
//----------------//
// Updating Nodes //
//----------------//
/// <summary>
/// Adds a node to this world at the given location. Will throw an exception if this location is not empty.
/// </summary>
/// <param name="node">The node to add.</param>
/// <param name="row">The row to place the node in.</param>
/// <param name="col">The column to place the node in.</param>
/// <exception cref="InvalidOperationException">Thrown if the given location is not empty.</exception>
public void AddNode(LevelNode node, int row, int col)
{
// Make sure this location is empty
if (ChildNodes[row, col] != null)
{
throw new InvalidOperationException(string.Format(
"Cannot add node to location ({0}, {1}); location already has a node.", row, col));
}
// If we got here, we're good to proceed and add the node
ChildNodes[row, col] = node;
}
/// <summary>
/// Removes the given node from this world.
/// </summary>
/// <param name="node">The node to remove.</param>
public void RemoveNode(LevelNode node)
{
if (ChildNodes.Contains(node))
{
ParentWorld.RemoveNode(node);
ChildNodes.Remove(node);
}
}
public virtual void UseLadder(float dir, LevelNode ladder)
{
// Note should be something here to check if on ladder but just for testing now
Vector3 p = _transform.position;
p.x = ladder.Centre.x;
_transform.position = p;
_moveVector = new Vector2(0, dir * _walkSpeed);
}
public Neighbour GetNeighbour(LevelNode neighbourNode)
{
for (int i = 0; i < _neighbours.Length; ++i)
{
if (_neighbours[i].node == neighbourNode) return _neighbours[i];
}
return new Neighbour();
}
/// <summary>
/// Removes the given node from this world. Will throw an exception if the node's store coordinates do not match its actual coordinates.
/// </summary>
/// <param name="node">The node to remove.</param>
/// <exception cref="InvalidOperationException">Thrown if the given node's location is occupied by a different node.</exception>
public void RemoveNode(LevelNode node)
{
// Check to make sure this node is registered at the correct location
if (ChildNodes[node.WorldRow, node.WorldColumn] == node)
{
// If it is, remove it
ChildNodes[node.WorldRow, node.WorldColumn] = null;
}
// If it's not, throw an exception
else
{
throw new InvalidOperationException(string.Format(
"Cannot remove node from location({0}, {1}); this location is occupied by a different node.", node.WorldRow, node.WorldColumn));
}
}
void Update()
{
if (Input.GetAxisRaw("Mouse ScrollWheel") > 0) {
zoomLimited(1f / zoomSpeed);
}
if (Input.GetAxisRaw("Mouse ScrollWheel") < 0) {
zoomLimited(zoomSpeed);
}
if (Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1) || Input.GetMouseButtonDown(2)) {
draggingWorldPoint = camera.ScreenToWorldPoint(Input.mousePosition);
}
if (Input.GetMouseButton(0) || Input.GetMouseButton(1) || Input.GetMouseButton(2)) {
var mouseWorldPoint = camera.ScreenToWorldPoint(Input.mousePosition);
move(draggingWorldPoint - mouseWorldPoint);
}
if (Input.GetMouseButtonDown(0)) {
if (hovered != null) {
if (hovered.level.Unlocked() || Cheats.on) {
GameManager.instance.Play(hovered.level);
}
}
}
move(new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical")) * keyboardSpeed * currentZoom);
var oldHovered = hovered;
this.hovered = null;
Physics.Raycast(camera.ScreenToWorldPoint(Input.mousePosition), Vector3.forward, out hit);
if (hit.collider != null) {
var hoveredNode = hit.collider.GetComponent<LevelNode>();
if (hoveredNode != null) {
this.hovered = hoveredNode;
}
}
if (oldHovered != hovered) {
levelNameSubstitution.Recalculate();
levelStatusSubstitution.Recalculate();
DynamicTextManager.instance.Invalidate();
}
}
/// <summary>
/// Adds a new node to the world given the previous node, the direction to the new node, and parent path.
/// </summary>
/// <param name="previousNode">The node that connects to the new node; often the previous node in the path.</param>
/// <param name="parentPathOfNewNode">The parent path of the new node.</param>
/// <param name="directionToNewNode">The direction from the previous node to the new node.</param>
/// <exception cref="InvalidOperationException">Thrown if the new node's coordinates would be outside the world or if there is already a node at these coordinates.</exception>
/// <returns>The newly created node.</returns>
private LevelNode AddNodeToWorld(LevelNode previousNode, LevelPath parentPathOfNewNode, Direction directionToNewNode)
{
Tuple<int, int> newNodeCoords = GetNewCoordinatesInDirection(previousNode, directionToNewNode);
// Verify that the new coordinates are inside the world
if (!AreCoordinatesInsideWorld(previousNode.ParentWorld, newNodeCoords.First, newNodeCoords.Second))
{
throw new InvalidOperationException(string.Format(
"Cannot add new node at the given direction from the given node. New node would have coordinates ({0}, {1}), which are outside the world.", newNodeCoords.First, newNodeCoords.Second));
}
// Verify that there is no node at these coordinates already
if (parentPathOfNewNode.ParentWorld.ChildNodes[newNodeCoords.First, newNodeCoords.Second] != null)
{
throw new InvalidOperationException(string.Format(
"Cannot add new node at location ({0}, {1}); location already has a node.", newNodeCoords.First, newNodeCoords.Second));
}
// Create the new node
LevelNode newNode = new LevelNode(parentPathOfNewNode, newNodeCoords.First, newNodeCoords.Second);
// Update the open side statuses
previousNode.UpdateOpenSideStatus(directionToNewNode, true);
newNode.UpdateOpenSideStatus(GetOppositeDirection(directionToNewNode), true);
return newNode;
}
/// <summary>
/// Joins the two given nodes. Nodes must be adjacent.
/// </summary>
/// <param name="firstNode">The first node to join.</param>
/// <param name="secondNode">The second node to join.</param>
/// <exception cref="InvalidOperationException">Thrown if the two nodes are not adjacent.</exception>
private void JoinNodes(LevelNode firstNode, LevelNode secondNode)
{
Direction dirToSecondNode = GetDirectionToCoordinates(firstNode.WorldRow, firstNode.WorldColumn, secondNode.WorldRow, secondNode.WorldColumn);
// Verify that we found a direction
if (dirToSecondNode == Direction.NONE)
{
throw new InvalidOperationException(string.Format(
"Cannot join nodes at locations ({0}, {1}) and ({2}, {3}); nodes are not adjacent.", firstNode.WorldRow, firstNode.WorldColumn, secondNode.WorldRow, secondNode.WorldColumn));
}
firstNode.UpdateOpenSideStatus(dirToSecondNode, true);
secondNode.UpdateOpenSideStatus(GetOppositeDirection(dirToSecondNode), true);
}
/// <summary>
/// Gets the new coordinates for the given node after moving one unit in the given direction.
/// </summary>
/// <param name="node">The node whose coordinates to use.</param>
/// <param name="dir">The direction to move in.</param>
/// <returns>The new coordinates.</returns>
private Tuple<int, int> GetNewCoordinatesInDirection(LevelNode node, Direction dir)
{
return GetNewCoordinatesInDirection(node.WorldRow, node.WorldColumn, dir);
}
public Node(int value, int levelCount)
{
Value = value;
LevelCount = levelCount;
LevelNodes = new LevelNode[levelCount];
}
