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));
}
