public void Initialize(DirectionFlag directionFlag)
{
wallE.gameObject.SetActive(directionFlag.BitwiseHasFlag(DirectionFlag.E));
wallW.gameObject.SetActive(directionFlag.BitwiseHasFlag(DirectionFlag.W));
wallN.gameObject.SetActive(directionFlag.BitwiseHasFlag(DirectionFlag.N));
wallS.gameObject.SetActive(directionFlag.BitwiseHasFlag(DirectionFlag.S));
}
private DirectionFlag[,] CreateGrid(Vector2Int dimension)
{
DirectionFlag[,] grid = new DirectionFlag[dimension.y, dimension.x];
for (int i = 0; i < dimension.y; i++)
{
for (int j = 0; j < dimension.x; j++)
{
grid[i, j] = DirectionExtensions.ALL_DIRECTIONS; // initialize
}
}
return(grid);
}
private void Carve(Vector2Int startPosition, DirectionFlag[,] grid)
{
// We sort the list in random order, so that the path will meander, rather than having a bias in any particular direction.
directions.Shuffle();
for (int i = 0; i < directions.Length; i++)
{
Vector2Int newPosition = new Vector2Int(startPosition.x + directions[i].DirectionXIndex(), startPosition.y + directions[i].DirectionYIndex());
if (IsValid(newPosition, grid))
{
DirectionFlag dir = directions[i];
grid[startPosition.y, startPosition.x] = grid[startPosition.y, startPosition.x] ^ directions[i]; // remove the wall of the current cell
grid[newPosition.y, newPosition.x] = grid[newPosition.y, newPosition.x] ^ directions[i].OppositeDirection(); // remove the wall from the next cell
Carve(newPosition, grid);
}
}
}
/// <summary>
/// Perform a random walk, carving passages to unvisited neighbors, until the current cell has no unvisited neighbors.
/// </summary>
/// <param name="position"></param>
/// <param name="grid"></param>
/// <returns>Nullable type of Vector2Int, it doesn't create boxing issue: https://stackoverflow.com/a/3775643 </returns>
private Vector2Int?Walk(Vector2Int position, DirectionFlag[,] grid)
{
directions.Shuffle();
for (int i = 0; i < directions.Length; i++)
{
Vector2Int newPosition = new Vector2Int(position.x + directions[i].DirectionXIndex(), position.y + directions[i].DirectionYIndex());
if (IsValid(newPosition, grid) && !IsVisited(newPosition, grid))
{
DirectionFlag dir = directions[i];
grid[position.y, position.x] = grid[position.y, position.x] ^ directions[i]; // remove the wall of the current cell
grid[newPosition.y, newPosition.x] = grid[newPosition.y, newPosition.x] ^ directions[i].OppositeDirection(); // remove the wall from the next cell
return(newPosition);
}
}
return(null);
}
// Cascade the individual bits of the flags register towards the respective variables
private void Flags_OnUpdate(object sender, EventArgs e)
{
CarryFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.CarryFlag) != 0);
ParityFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.ParityFlag) != 0);
AdjustFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.AdjustFlag) != 0);
ZeroFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.ZeroFlag) != 0);
SignFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.SignFlag) != 0);
TrapFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.TrapFlag) != 0);
InterruptEnableFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.InterruptEnableFlag) != 0);
DirectionFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.DirectionFlag) != 0);
OverflowFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.OverflowFlag) != 0);
NestedTaskFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.NestedTaskFlag) != 0);
ResumeFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.ResumeFlag) != 0);
Virtual8086ModeFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.V8086ModeFlag) != 0);
AlignmentCheck.Set((Flags.CurrentValue & (UInt32)FlagMask.AlignmentCheck) != 0);
VirtualInterruptFlag.Set((Flags.CurrentValue & (UInt32)FlagMask.VirtualInterruptFlag) != 0);
VirtualInterruptPending.Set((Flags.CurrentValue & (UInt32)FlagMask.VirtualInterruptPending) != 0);
AllowCPUID.Set((Flags.CurrentValue & (UInt32)FlagMask.AllowCPUID) != 0);
UInt32 iopl = (Flags.CurrentValue & (UInt32)FlagMask.IOPrivilegeLevel) >> 12;
IOPrivilegeLevel.Set((byte)iopl);
}
public RoomFiller(int width, int height, DirectionFlag doors, GrammarPattern[] dungeonPatterns, RoomType roomType, float roomIntensity)
{
graphHeight = width;
graphWidth = width;
doorsPosition = doors;
patternsToApply = dungeonPatterns;
switch (roomType)
{
case RoomType.START:
currentRoomType = RoomTypeFlags.START;
break;
case RoomType.END:
currentRoomType = RoomTypeFlags.END;
break;
case RoomType.BOSS:
currentRoomType = RoomTypeFlags.BOSS;
break;
case RoomType.NORMAL:
currentRoomType = RoomTypeFlags.NORMAL;
break;
case RoomType.KEY:
currentRoomType = RoomTypeFlags.KEY;
break;
default:
break;
}
//currentRoomIntensity = roomIntensity;
allContents = new List <RoomContent>();
}
public static Point RandomDirection(int min, int max, DirectionFlag flag)
{
Point pt = new Point();
var x = r.Next(min, max);
var y = r.Next(min, max);
var z = r.Next(min, max);
switch (flag)
{
case DirectionFlag.AllowDiagonals:
pt = new Point(x, y);
break;
case DirectionFlag.NoDiagonals:
var dir = r.Next(100);
if (dir < 25)
{
pt = Left();
}
else if (dir < 50)
{
pt = Right();
}
else if (dir < 75)
{
pt = Up();
}
else
{
pt = Down();
}
break;
}
return(pt);
}
public void SetFlags(DirectionFlag flag1, DirectionFlag flag2)
{
SetFlag(flag1);
SetFlag(flag2);
}
public void SetFlag(DirectionFlag flag)
{
if(!ActiveFlags.Contains(flag))
ActiveFlags.Add(flag);
}
public void RemoveFlags(DirectionFlag flag1, DirectionFlag flag2)
{
RemoveFlag(flag1);
RemoveFlag(flag2);
}
public void RemoveFlag(DirectionFlag flag)
{
ActiveFlags.Remove(flag);
}
//private DirectionFlag[] ActiveFlags { get; set; }
public bool HasFlag(DirectionFlag flag)
{
if (ActiveFlags == null) return false;
return ActiveFlags.Contains(flag);
}
// We do have directionFlag.HasFlag but we want to avoid it since it is much more resource-intensive including boxing,
// therefore we will use good'ol bitwise implementation.
public static bool BitwiseHasFlag(this DirectionFlag direction, DirectionFlag flag)
{
return((direction & flag) != 0);
}
/// <summary>
/// Returns y index to traverse
/// </summary>
/// <param name="direction"></param>
/// <returns></returns>
public static int DirectionYIndex(this DirectionFlag direction)
{
return(DirectionY[direction]);
}
/// <summary>
/// Returns the opposite direction.
/// </summary>
/// <param name="direction">current direction</param>
/// <returns>Opposite direction</returns>
public static DirectionFlag OppositeDirection(this DirectionFlag direction)
{
return(Opposite[direction]);
}
