public void SetUp(LevelSelection master, float scale, float visible, LevelPosition pos = LevelPosition.CENTER, bool hideAll = false) { defaultScale = scale; levelPos = pos; tempColor = image.color; levelMaster = master; tempColor.a = visible; image.color = tempColor; levelTransform.localScale = new Vector3(scale, scale, scale); SetItemsVisibility(hideAll); }
/////////////////////////////////////////////////////////////////////////// void ForceLevelEndToLevelStart(ref int pos) { LevelPosition levelPosition = m_LevelPositionStack.Peek(); // At least one node within this hierarchy? if (pos >= levelPosition.LevelEndPosition_IfLoading) { bool posValid = (pos == levelPosition.LevelEndPosition_IfLoading) && (pos >= levelPosition.LevelStartPosition) && (levelPosition.LevelStartPosition != levelPosition.LevelEndPosition_IfLoading); Debug.Assert(posValid, "Setting ReadPos to position out of Level"); pos = levelPosition.LevelStartPosition; } }
/////////////////////////////////////////////////////////////////////////// int FindNodePos(TNodeID nodeID, out TNodeSize nodeSize, out NodeType nodeType) { nodeSize = -1; nodeType = NodeType.LeafNode; int oldPos = GetCurrentStreamPos(); LevelPosition levelPosition = m_LevelPositionStack.Peek(); // At least one node within this hierarchy? if (levelPosition.LevelStartPosition == levelPosition.LevelEndPosition_IfLoading) { return(-1); } int nextStreamTestPos = levelPosition.CurrentPosition; ForceLevelEndToLevelStart(ref nextStreamTestPos); int firstTestPos = nextStreamTestPos; while (true) { TNodeID nextNodeID = 0; TNodeSize nextNodeSize = 0; NodeType nextNodeType = NodeType.Parent; GotoStreamPos(nextStreamTestPos, false); ReadNextNode(out nextNodeID, out nextNodeSize, out nextNodeType); if (nextNodeID == nodeID) { // found it! GotoStreamPos(oldPos, false); nodeSize = nextNodeSize; nodeType = nextNodeType; return(nextStreamTestPos); } nextStreamTestPos = nextStreamTestPos + nextNodeSize; ForceLevelEndToLevelStart(ref nextStreamTestPos); if (firstTestPos == nextStreamTestPos) { // nothing found :( GotoStreamPos(oldPos, false); return(-1); } } }
/////////////////////////////////////////////////////////////////////////// void GotoStreamPos(int pos, bool updateCurrentLevelPos) { m_BinaryStream.Seek(pos, SeekOrigin.Begin); if (updateCurrentLevelPos) { LevelPosition topPosition = m_LevelPositionStack.Pop(); topPosition.CurrentPosition = pos; m_LevelPositionStack.Push(topPosition); } AssertWithinCurrentLevel(true); }
private int ShortestPathLevels(IEnumerable <string> input) { Dictionary <Point, char> mapData = ParseMap(input.ToList()); var(portals, start, exit) = ParseLabels(mapData); Dictionary <Point, List <Point> > neighborMap = CreateNeighborMap(mapData, portals); var startLevel = new LevelPosition(0, start); var exitLevel = new LevelPosition(0, exit); int width = mapData.Where(md => md.Value == '#').Max(md => md.Key.X); int height = mapData.Where(md => md.Value == '#').Max(md => md.Key.Y); List <LevelPosition> LevelNeighbors(LevelPosition levelPosition) { var levelNeighbors = new List <LevelPosition>(); var neighbors = neighborMap[levelPosition.Position]; foreach (var n in neighbors) { if (portals.ContainsKey(levelPosition.Position) && portals.ContainsKey(n)) { var p = levelPosition.Position; if (p.X == 0 || p.Y == 0 || p.X == width || p.Y == height) { if (levelPosition.Level == 0) { continue; } levelNeighbors.Add(new LevelPosition(levelPosition.Level - 1, new Point(n.X, n.Y))); } else { levelNeighbors.Add(new LevelPosition(levelPosition.Level + 1, new Point(n.X, n.Y))); } } else { levelNeighbors.Add(new LevelPosition(levelPosition.Level, new Point(n.X, n.Y))); } } return(levelNeighbors); } var(terminationNode, _) = startLevel.BreadthFirst(LevelNeighbors, n => n.Equals(exitLevel), -1); return(terminationNode.Depth); }
/////////////////////////////////////////////////////////////////////////// void AssertWithinCurrentLevel(bool allowAtEnd) { int currentPos = GetCurrentStreamPos(); LevelPosition levelPosition = m_LevelPositionStack.Peek(); if (currentPos >= levelPosition.LevelStartPosition && // after start ((currentPos < levelPosition.LevelEndPosition_IfLoading || (currentPos <= levelPosition.LevelEndPosition_IfLoading && allowAtEnd)) || // before/at end (levelPosition.LevelEndPosition_IfLoading == -1))) // saving { return; } Debug.Assert(false); }
public void ActivateLocalNest(LevelName levelName, LevelPosition levelPosition) { GlobalObjectManager.instance.ActivateNest((int)levelName, (int)levelPosition); if (levelPosition == LevelPosition.Start) { UIManager.Instance.SetStartWarp(true); } else if (levelPosition == LevelPosition.Shop) { UIManager.Instance.SetShopWarp(true); } else if (levelPosition == LevelPosition.Boss) { UIManager.Instance.SetBossWarp(true); } }
/////////////////////////////////////////////////////////////////////////// // A1 // *B1 // C1 // C2 // #B2 // C1 // C2 // $B3 // C1 // C2 // // // // * == Level.currentLevelStartPos // # == Level.currentPos // $ == StreamPos void WriteEndParent() { // We finished this level m_LevelPositionStack.Pop(); LevelPosition levelPosition = m_LevelPositionStack.Peek(); int nextStreamPos = GetCurrentStreamPos(); Debug.Assert(nextStreamPos == m_BinaryStream.Length, "Shouldn't we always write to the end of the stream?"); // Overwrite size (2nd param) // SIZE means "From the beginning of the current node to the beginning of the next node" GotoStreamPos(levelPosition.CurrentPosition + TAG_SIZE_NODE_ID, false); m_BinaryWriter.Write(nextStreamPos - levelPosition.CurrentPosition); GotoStreamPos(nextStreamPos, true); }
/////////////////////////////////////////////////////////////////////////// void ReadEndParent() { // old level is finished m_LevelPositionStack.Pop(); LevelPosition oldLevelPos = m_LevelPositionStack.Peek(); GotoStreamPos(oldLevelPos.CurrentPosition, false); TNodeID nextNodeID = 0; TNodeSize nextNodeSize = 0; NodeType nodeType = NodeType.Parent; ReadNextNode(out nextNodeID, out nextNodeSize, out nodeType); int nextPos = oldLevelPos.CurrentPosition + nextNodeSize; GotoStreamPos(nextPos, true); }
public List <DrawMove> GetAvailableMoves(Game game) { List <DrawMove> result = new List <DrawMove>(); List <LevelPosition> pirates = new List <LevelPosition>(); int index = 0; int mindex = 1; foreach (var move in game.GetAvailableMoves()) { var pirate = pirates.FirstOrDefault(p => (p.X == move.From.X) && (p.Y == move.From.Y) && (p.Level == move.From.Level)); if (pirate == null) { pirate = new LevelPosition { PirateNum = mindex++, X = move.From.X, Y = move.From.Y, Level = move.From.Level }; pirates.Add(pirate); } result.Add(new DrawMove { MoveNum = index++, WithCoin = move.WithCoins, WithRespawn = move.WithRespawn, From = pirate, To = new LevelPosition { X = move.To.X, Y = move.To.Y, Level = move.To.Level } }); } return(result); }
/////////////////////////////////////////////////////////////////////////// void ReadDictionaryData() { string key; TNodeID value; while (true) { TNodeID nextNodeID = 0; TNodeSize nextNodeSize = 0; NodeType nextNodeType = NodeType.Parent; int currentPos = GetCurrentStreamPos(); LevelPosition levelPosition = m_LevelPositionStack.Peek(); int levelEndPos = levelPosition.LevelEndPosition_IfLoading; if (currentPos >= levelEndPos) { Debug.Assert(currentPos == levelEndPos); GotoStreamPos(levelPosition.LevelStartPosition, true); return; } ReadNextNode(out nextNodeID, out nextNodeSize, out nextNodeType); Debug.Assert(nextNodeID == (TNodeID)SpecialNodeIDs.DictionaryKey); ReadLeafData(out key, nextNodeSize); ReadNextNode(out nextNodeID, out nextNodeSize, out nextNodeType); Debug.Assert(nextNodeID == (TNodeID)SpecialNodeIDs.DictionaryValue); ReadLeafData(out value, nextNodeSize); m_NodeNameToIds.Add(key, value); } }
public Vector3 GetExactPosition(LevelPosition position) { return(position.GetCoordinates()); }
public Vector3 GetPositionAndHalf(LevelPosition position) { return(position.GetHalfCoordinates()); }
public int Distance(LevelPosition other) { return(Math.Abs(this.x - other.x) + Math.Abs(this.y - other.y)); }
protected bool Equals(LevelPosition other) { return(Level == other.Level && Position.Equals(other.Position)); }