// ----------------------------- GET -------------------------- //
private GameObject[] GetWallByDirection(Direction4D direction)
{
switch (direction)
{
case Direction4D.Down:
{
return(Map.tiles.downWallTiles);
}
case Direction4D.Up:
{
return(Map.tiles.walltiles);
}
case Direction4D.Left:
{
return(Map.tiles.leftWallTiles);
}
case Direction4D.Right:
{
return(Map.tiles.rightWallTiles);
}
}
return(null);
}
void Look(Direction4D dir, bool oneHanded, Weapon weapon) //1 вверх 0 вправо -1 вниз
{
if (dir == Direction4D.Up) //Если смотрит вверх
{
parent.animator.SetFloat("LooksUp", 1f);
hands.SetLocalPosition(Direction4D.Up, -2);
}
else if (dir == Direction4D.Right) //Если смотрит вправо
{
parent.animator.SetFloat("LooksUp", 0f);
hands.SetLocalPosition(Direction4D.Right, 2);
}
else if (dir == Direction4D.Down) //Если смотрит вниз
{
parent.animator.SetFloat("LooksUp", -1f);
if (oneHanded == false)
{
hands.SetLocalPosition(Direction4D.Down, 2);
}
else
{
hands.SetLocalPosition(Direction4D.Right, 2);
}
}
}
public Wall CreateWall(Vector2 position, Direction4D direction)
{
GameObject[] tileSet = GetWallByDirection(direction);
Wall wall = new Wall(direction)
{
gameObject = GameObject.Instantiate(tileSet[UnityEngine.Random.Range(0, tileSet.Length)], position, tileSet[0].transform.rotation) as GameObject
};
wall.gameObject.transform.parent = place.wallGrid.transform;
switch (direction)
{
case Direction4D.Up:
UpWalls.Add(wall);
// Vector2 upper = new Vector2(position.x, position.y + 1);
break;
case Direction4D.Down:
DownWalls.Add(wall);
break;
case Direction4D.Left:
LeftWalls.Add(wall);
break;
case Direction4D.Right:
RightWalls.Add(wall);
break;
}
wall.info = wall.gameObject.name + " pos: " + wall.gameObject.transform.position;
return(wall);
}
public Direction4D Mirror(Direction4D value)
{
if (value == d1)
return d2;
if (value == d2)
return d1;
//throw new ArgumentException(value + " is not valid.");
return Mirror(value.Reverse());
}
Direction4D Increase_direction(Direction4D direction)
{
direction += 1;
if ((int)direction >= 4)
{
direction = 0;
}
return(direction);
}
public Texture2D Get(Direction4D direction)
{
switch(direction)
{
case Direction4D.Up: return up;
case Direction4D.Down: return down;
case Direction4D.Left: return left;
case Direction4D.Right: return right;
}
return null;
}
void DestroyRect(Vector2 startPos, int height, int width, Placement place)
{
transform.position = startPos;
Direction4D moveSide = Direction4D.Right;
Direction4D moveUpDown = Direction4D.Up;
if (height == 0)
{
height = 1;
}
if (width == 0)
{
width = 1;
}
if (height < 0)
{
height = Mathf.Abs(height);
moveUpDown = Direction4D.Down;
}
if (width < 0)
{
width = Mathf.Abs(width);
moveSide = Direction4D.Left;
}
for (int i = 1; i <= height; i++)
{
for (int j = 1; j <= width; j++)
{
if (i == 1 || j == 1 || i == height || j == width)
{
place.smartGrid.RemoveFloor(transform.position);
}
else
{
place.smartGrid.RemoveFloor(transform.position);
}
if (j != width)
{
MoveGenerator(moveSide);
}
}
if (i != height)
{
MoveGenerator(moveUpDown);
transform.position = new Vector2(startPos.x, transform.position.y);
}
}
}
public PlayerAvatar(Texture2D4D aTextures, Vector2 initialGridPos, Block[,] grid, IEnumerable<Laserbeam> laserBeams, MainGame game, bool isSilverBot = false)
{
gridPos = initialGridPos;
animPos = gridPos * 32.0f;
animTarget = animPos;
textures = aTextures;
facing = Direction4D.Right;
this.grid = grid;
this.laserBeams = laserBeams;
this.game = game;
explosionTexture = game.textures.explosion;
Arrive += PlayerAvatar_Arrive;
this.isSilverBot = isSilverBot;
}
private IEnumerator GenerateNextLevel()
{
byte roomNumber = System.Convert.ToByte(roomsAmount + shopsAmount + secretAmount);
int roombehind = System.Convert.ToByte(roomsAmount); // комната сзади (last)
byte height = 6;
byte width = 6;
Direction4D randDirection = RandomDirection((float)randomGenerator.NextDouble()); //Рандомное направление
TryCreateRoom(roomNumber, roombehind, width, height, randDirection, roomType.nextlevel);
yield return(0);
}
IEnumerator GenerateRooms()
{
for (byte roomCount = 0; roomCount < roomsAmount + 1; roomCount++)
{
yield return(new WaitForSecondsRealtime(0.1f));
if (roomCount == 0)
{
GameObject roomObj = new GameObject
{
name = "Room" + roomCount,
tag = "Room"
};
Room room = roomObj.AddComponent <Room>();
Map.roomObjs.Add(room);
room.SetupRoom(roomCount, 16, 16, transform.position, roomType.playerStart, RoomMaxWidth, RoomMaxHeight);
CreateRoom(Map.roomObjs[roomCount]);
}
else
{
byte corridor_length = minCorridorLength;
int roombehind = roomCount - 1; // комната сзади
byte height = System.Convert.ToByte(randomGenerator.Next(RoomMinHeight, RoomMaxHeight));
byte width = System.Convert.ToByte(randomGenerator.Next(RoomMinWidth, RoomMaxWidth)); //Рандоманая высота и ширина
Direction4D randDirection = RandomDirection((float)randomGenerator.NextDouble()); //Рандомное направление
if (branchChance > (float)randomGenerator.NextDouble() && roomCount > 5) //Дополнительное разветвление
{
roombehind -= 1;
}
if (roomCount == roomsAmount)
{
TryCreateRoom(roomCount, roombehind, width, height, randDirection, roomType.last);
}
else
{
TryCreateRoom(roomCount, roombehind, width, height, randDirection, roomType.common);
}
}
}
yield return(0);
}
private IEnumerator GenerateSecret()
{
for (int i = 0; i < secretAmount; i++)
{
byte roomNumber = System.Convert.ToByte(roomsAmount + shopsAmount + i);
int roombehind = System.Convert.ToByte(randomGenerator.Next(0, roomsAmount)); // комната сзади
byte height = 9;
byte width = 9;
Direction4D randDirection = RandomDirection((float)randomGenerator.NextDouble()); //Рандомное направление
TryCreateRoom(roomNumber, roombehind, width, height, randDirection, roomType.secret);
}
yield return(0);
}
Direction4D DoorInvert(Direction4D door)
{
switch (door)
{
case Direction4D.Up:
return(Direction4D.Down);
case Direction4D.Down:
return(Direction4D.Up);
case Direction4D.Left:
return(Direction4D.Right);
case Direction4D.Right:
return(Direction4D.Left);
}
return(Direction4D.Up);
}
public void SetLocalPosition(Direction4D position, int sortLayer)
{
switch (position)
{
case Direction4D.Down:
SetHandsLayer(sortLayer);
transform.localPosition = new Vector3(lookDownHandsPos.x, lookDownHandsPos.y, 0);
break;
case Direction4D.Up:
SetHandsLayer(sortLayer);
transform.localPosition = new Vector3(defaultHandsPos.x, defaultHandsPos.y, 0);
break;
default:
SetHandsLayer(sortLayer);
transform.localPosition = new Vector3(defaultHandsPos.x, defaultHandsPos.y, 0);
break;
}
}
private IEnumerator GenerateShops()
{
for (int i = 0; i < shopsAmount; i++)
{
yield return(new WaitForSecondsRealtime(0.1f));
byte roomNumber = System.Convert.ToByte(roomsAmount + i);
int roombehind = System.Convert.ToByte(randomGenerator.Next(0, roomsAmount)); // комната сзади
byte height = 14;
byte width = 16;
Direction4D randDirection = RandomDirection((float)randomGenerator.NextDouble()); //Рандомное направление
TryCreateRoom(roomNumber, roombehind, width, height, randDirection, roomType.shop);
}
yield return(0);
}
void MoveGenerator(Direction4D direction)
{
switch (direction)
{
case Direction4D.Up:
transform.position = new Vector2(transform.position.x, transform.position.y + 1);
break;
case Direction4D.Down:
transform.position = new Vector2(transform.position.x, transform.position.y - 1);
break;
case Direction4D.Right:
transform.position = new Vector2(transform.position.x + 1, transform.position.y);
break;
case Direction4D.Left:
transform.position = new Vector2(transform.position.x - 1, transform.position.y);
break;
}
}
public void SetupCorridor(Direction4D direction, byte length, System.Random rand)
{
GameObject cor = new GameObject();
Corridor corridor = cor.AddComponent <Corridor>();
Vector2 startCorner = Vector2.zero;
Vector2 endCorner = Vector2.zero;
int offsetW = SimpleFunctions.Min(width, prevRoom.width);
int offsetH = SimpleFunctions.Min(height, prevRoom.height);
int tempX = rand.Next(2, offsetW);
int tempY = rand.Next(1, offsetH);
switch (direction)
{
case Direction4D.Up:
startCorner = new Vector2(start.x + tempX, end.y);
endCorner = new Vector2(startCorner.x, startCorner.y + length);
break;
case Direction4D.Down:
startCorner = new Vector2(start.x + tempX, start.y);
endCorner = new Vector2(startCorner.x, startCorner.y - length);
break;
case Direction4D.Right:
startCorner = new Vector2(end.x, start.y + tempY);
endCorner = new Vector2(startCorner.x + length, startCorner.y);
break;
case Direction4D.Left:
startCorner = new Vector2(start.x, start.y + tempY);
endCorner = new Vector2(startCorner.x - length, startCorner.y);
break;
}
corridor.Setup(startCorner, endCorner, this, prevRoom, direction);
}
void MoveRoomGenerator(Room previousRoom, Direction4D direction)
{
//Выставляем генератор в нужное положение
switch (direction)
{
case Direction4D.Up:
transform.position = new Vector2(previousRoom.transform.position.x, previousRoom.transform.position.y + minCorridorLength + RoomMaxHeight);
break;
case Direction4D.Down:
transform.position = new Vector2(previousRoom.transform.position.x, previousRoom.transform.position.y - (minCorridorLength + RoomMaxHeight));
break;
case Direction4D.Right:
transform.position = new Vector2(previousRoom.transform.position.x + minCorridorLength + RoomMaxWidth, previousRoom.transform.position.y);
break;
case Direction4D.Left:
transform.position = new Vector2(previousRoom.transform.position.x - (minCorridorLength + RoomMaxWidth), previousRoom.transform.position.y);
break;
}
}
internal void FireLaser (uint x, uint y, uint width, uint height, Direction4D direction, Block[,] grid, ContentManager Content, LaserbeamManager laserManager, ref int laserIndex)
{
SilverBotMirrorPosition[] mirrorPositions = new SilverBotMirrorPosition[0];
if (silverBot != null)
mirrorPositions = GetSilverBotPositions(new Vector2(silverBot.gridPos.X, silverBot.gridPos.Y));
Laserbeam current = laserManager.GetBeam(laserIndex);
current.SetStartDirection(direction);
Vector2 currentPosition = new Vector2(x, y) + direction.ToVector2();
while(true)
{
if (currentPosition.X == -1 || currentPosition.Y == -1)
break;
if (currentPosition.X == width)
break;
if (currentPosition.Y == height)
break;
foreach (var mirror in mirrorPositions)
{
if (mirror == currentPosition)
{
direction = mirror.Mirror(direction.Reverse());
break;
}
}
if(grid[(int)currentPosition.X, (int)currentPosition.Y].LaserPassesThrough())
{
current.Add(currentPosition);
currentPosition += direction.ToVector2();
}
else
{
break;
}
}
current.SetEndDirection(direction);
laserIndex++;
}
public void SetStartDirection(Direction4D direction)
{
startDirection = direction;
}
public void SetEndDirection(Direction4D direction)
{
if( squares.Count() > 0)
{
squares.Last().endDirection = direction;
}
}
public void DrawPartial(Direction4D direction, LaserbeamTextures textures, SpriteBatch spriteBatch, Vector2 cameraPos)
{
switch (direction)
{
case Direction4D.Up:
spriteBatch.Draw(textures.beamV, pos - cameraPos, new Rectangle(0, 0, 32, 16), Color.White);
break;
case Direction4D.Down:
spriteBatch.Draw(textures.beamV, pos + new Vector2(0, 16.0f) - cameraPos, new Rectangle(0, 16, 32, 16), Color.White);
break;
case Direction4D.Left:
spriteBatch.Draw(textures.beamH, pos - cameraPos, new Rectangle(0, 0, 16, 32), Color.White);
break;
case Direction4D.Right:
spriteBatch.Draw(textures.beamH, pos + new Vector2(16.0f, 0.0f) - cameraPos, new Rectangle(16, 0, 16, 32), Color.White);
break;
}
}
public bool GotPushed(Direction4D direction, PlayerAvatar sender)
{
Vector2 offset = direction.ToVector2();
Point position = (gridPos + offset).ToPoint();
if (isSilverBot)
{
if (!IsPositionFree(position))
return false;
if (!IsPositionFree(position + new Point(1,0)))
return false;
if (!IsPositionFree(position + new Point(0,1)))
return false;
if (!IsPositionFree(position + new Point(1,1)))
return false;
}
else
{
if (!IsPositionFree(position))
return false;
if( position.X == game.silverBot.gridPos.X || position.X == game.silverBot.gridPos.X+1 )
{
if( position.Y == game.silverBot.gridPos.Y || position.Y == game.silverBot.gridPos.Y+1 )
{
//can't push things into silverbot
return false;
}
}
}
gridPos += offset;
animTarget = gridPos * 32.0f;
isPushing = true;
return true;
}
public void Setup(Vector2 Start, Vector2 End, Room First, Room Second, Direction4D corDirection)
{
CorridorForRoom corForRoom = new CorridorForRoom();
corForRoom.corridor = this;
corForRoom.positionByRoom = Direction4D.Down;
if (First.roomType == roomType.secret || Second.roomType == roomType.secret)
{
tag = "SecretCorridor";
name = "SecretCorridor";
}
else
{
tag = "Corridor";
name = "Corridor " + First.number;
}
positioning = Positioning.Vertical;
switch (corDirection)
{
case Direction4D.Down:
{
corForRoom.positionByRoom = Direction4D.Down;
First.corridors.Add(corForRoom);
corForRoom.positionByRoom = Direction4D.Up;
Second.corridors.Add(corForRoom);
break;
}
case Direction4D.Up:
{
corForRoom.positionByRoom = Direction4D.Up;
First.corridors.Add(corForRoom);
corForRoom.positionByRoom = Direction4D.Down;
Second.corridors.Add(corForRoom);
break;
}
case Direction4D.Right:
{
corForRoom.positionByRoom = Direction4D.Right;
First.corridors.Add(corForRoom);
corForRoom.positionByRoom = Direction4D.Left;
Second.corridors.Add(corForRoom);
positioning = Positioning.Horizontal;
break;
}
case Direction4D.Left:
{
corForRoom.positionByRoom = Direction4D.Left;
First.corridors.Add(corForRoom);
corForRoom.positionByRoom = Direction4D.Right;
Second.corridors.Add(corForRoom);
positioning = Positioning.Horizontal;
break;
}
}
Rooms[0] = First;
Rooms[1] = Second;
start = Start;
end = End;
boxCollider = this.gameObject.AddComponent <BoxCollider2D>();
boxCollider.isTrigger = true;
SetHeightAndWidth();
Map.corridors.Add(this);
}
private void TryCreateRoom(byte number, int prevRoomIndex, byte width, byte height, Direction4D direction, roomType type)
{
Room prevRoom = Map.roomObjs[prevRoomIndex].GetComponent <Room>();
MoveRoomGenerator(prevRoom, direction); //Сдвигаем в начало новой комнаты
Vector2 roomstartpos = new Vector2(transform.position.x, transform.position.y);
Vector2 roomendpos = new Vector2(transform.position.x + RoomMaxWidth, transform.position.y + RoomMaxHeight);
bool fixDir = Check_All_Superimpose(roomstartpos, roomendpos);
//FixDir == true => комнаты пересекаются
for (int k = 1; k <= 4; k++)
{
if (fixDir == true)
{
direction = Increase_direction(direction); //Меняем направление
prevRoom = Map.roomObjs[prevRoomIndex].GetComponent <Room>();
MoveRoomGenerator(prevRoom, direction); //Двигаем в начало следующей комнаты
roomstartpos = new Vector2(transform.position.x, transform.position.y);
roomendpos = new Vector2(transform.position.x + RoomMaxWidth, transform.position.y + RoomMaxHeight);
fixDir = Check_All_Superimpose(roomstartpos, roomendpos);
if (fixDir == false)
{
break;
}
if (k == 4) // Разветвление если не подошло 4 направления
{
prevRoomIndex -= 1;
if (prevRoomIndex == 1)
{
Debug.Log("GGGGG");
return; //Если дошло до ласт комнаты то GG
}
prevRoom = Map.roomObjs[prevRoomIndex].GetComponent <Room>();
k = 1;
}
}
}
GenerateRoom(number, prevRoom, width, height, direction, type);
}
public bool TryStep(Direction4D moveDirection, out Vector2 moveTo)
{
isPushing = false;
moveTo = new Vector2();
if (moveDirection == Direction4D.None)
return false;
facing = moveDirection;
moveTo = moveDirection.ToVector2() + gridPos;
if (moveTo.X < 0 || moveTo.Y < 0 ||
moveTo.X >= grid.GetLength(0) || moveTo.Y >= grid.GetLength(1) ||
(isSilverBot ? (moveTo.X == grid.GetLength(0) - 1 || (moveTo.Y == grid.GetLength(1) - 1)) : false))
{
return false;
}
Block moveToBlock = grid[(int)moveTo.X, (int)moveTo.Y];
Block moveToBlock1XPlus = default(Block);
Block moveToBlock1YPlus = default(Block);
Block moveToBlock1XYPlus = default(Block);
if (isSilverBot)
{
moveToBlock1XPlus = grid[(int)moveTo.X + 1, (int)moveTo.Y];
moveToBlock1YPlus = grid[(int)moveTo.X, (int)moveTo.Y + 1];
moveToBlock1XYPlus = grid[(int)moveTo.X + 1, (int)moveTo.Y + 1];
}
if (moveToBlock == Block.Crate)
{
Vector2 crateMovePlus = moveDirection.ToVector2();
if (IsTouchingSilverBot(crateMovePlus + moveTo) || isSilverBot)
return false;
Point targetPos = new Point( (int)(moveTo.X + crateMovePlus.X), (int)(moveTo.Y + crateMovePlus.Y) );
if (targetPos.X < 0 || targetPos.Y < 0 || targetPos.X >= grid.GetLength(0) || targetPos.Y >= grid.GetLength(1))
return false;
if (grid[targetPos.X, targetPos.Y].IsSolid())
return false;
grid[targetPos.X, targetPos.Y] = Block.Crate;
grid[(int)(moveTo.X), (int)moveTo.Y] = Block.Floor;
game.AddPushAnim(Block.Crate, targetPos, this, moveDirection);
gridPos = moveTo;
animTarget = gridPos * 32.0f;
game.ReloadLasers();
isPushing = true;
sounds.cratePush.Play();
return true;
}
if (IsTouchingSilverBot(moveTo))
{
if (game.silverBot.GotPushed(moveDirection, this))
{
isPushing = true;
}
else
{
return false;
}
}
if (isSilverBot)
goto SkipForeach;
SkipForeach:
if ((!MainGame.IsSolid(moveToBlock) || moveToBlock == Block.Panel || moveToBlock == Block.Exit) &&
(!isSilverBot || (!MainGame.IsSolid(moveToBlock1XPlus) && !MainGame.IsSolid(moveToBlock1YPlus) && !MainGame.IsSolid(moveToBlock1XYPlus))))
{
gridPos = moveTo;
animTarget = gridPos * 32.0f;
game.ReloadLasers();
return true;
}
return false;
}
public Laserbeam(LaserbeamTextures aTextures)
{
startDirection = Direction4D.Right;
textures = aTextures;
}
private void CreateWall(Room room, GameObject[] walls, Vector2 pos, Direction4D direction)
{
int tileindex = randomGen.Next(0, walls.Length);
room.smartGrid.CreateWall(pos, direction);
}
public LaserbeamSquare(Vector2 aCoord, Direction4D aStartDirection, Direction4D aEndDirection)
{
coord = aCoord;
startDirection = aStartDirection;
endDirection = aEndDirection;
}
private IEnumerator CreateAdditionalCorridors()
{
GetDistanceBetweenRooms();
bool skip = true; // if true skips corridor
foreach (Room thisRoom in Map.roomObjs)
{
skip = !skip;
if (skip == false)
{
foreach (DistanceToTheRoom d in thisRoom.distances)
{
if (d.closestDistance < 7)
{
bool alreadyHasConnectionWithThisRoom = false;
foreach (CorridorForRoom cor in thisRoom.corridors)
{
foreach (Room room in cor.corridor.Rooms)
{
if (room == d.room)
{
alreadyHasConnectionWithThisRoom = true;
break;
}
}
}
if (alreadyHasConnectionWithThisRoom == false)
{
List <Room> rooms = new List <Room>();
rooms.Add(thisRoom);
rooms.Add(d.room);
Vector2 start = d.closestCorner;
Vector2 end = d.toOtherRoomClosestCorner;
if (d.closestCorner.x != d.toOtherRoomClosestCorner.x && d.closestCorner.y == d.toOtherRoomClosestCorner.y) //Слева или справо
{
Direction4D direction = Direction4D.Right;
if (d.closestCorner.y == thisRoom.end.y) //Если справа
{
start = new Vector2(start.x, start.y - 1 - randomGenerator.Next(0, thisRoom.height));
end = new Vector2(end.x + 1, start.y);
}
else
{
start = new Vector2(start.x, start.y + 1 + randomGenerator.Next(0, thisRoom.height));
end = new Vector2(end.x - 1, start.y);
direction = Direction4D.Left;
}
if (Check_All_Superimpose(start, end) == false)
{
GameObject cor = new GameObject();
cor.name = "Corridor ROOM " + thisRoom.number + " and " + d.room.number;
Corridor corridor = cor.AddComponent <Corridor>();
cor.transform.position = start;
corridor.Setup(start, end, thisRoom, d.room, direction);
}
}
else if (d.closestCorner.y != d.toOtherRoomClosestCorner.y && d.closestCorner.x == d.toOtherRoomClosestCorner.x)
{
Direction4D direction = Direction4D.Up;
if (d.closestCorner.x == thisRoom.end.x)
{
start = new Vector2(start.x - 1 - randomGenerator.Next(0, thisRoom.width), start.y);
end = new Vector2(start.x, end.y + 1);
}
else
{
start = new Vector2(start.x + 1 + randomGenerator.Next(0, thisRoom.width), start.y);
end = new Vector2(start.x, end.y - 1);
direction = Direction4D.Down;
}
if (Check_All_Superimpose(start, end, rooms) == false)
{
GameObject cor = new GameObject();
cor.name = "Corridor ROOM " + thisRoom.number + " and " + d.room.number;
Corridor corridor = cor.AddComponent <Corridor>();
cor.transform.position = start;
corridor.Setup(start, end, thisRoom, d.room, direction);
}
}
}
}
}
}
yield return(new WaitForSecondsRealtime(0.1f));
}
}
void GenerateRoom(byte number, Room prevRoom, byte width, byte height, Direction4D dir, roomType type) //Дверь входящая в комнату
{
GameObject roomObj;
switch (type)
{
case roomType.playerStart:
{
roomObj = new GameObject
{
name = "Start Room " + number,
tag = "Room"
};
break;
}
case roomType.common:
{
roomObj = new GameObject
{
name = "Room " + number,
tag = "Room"
};
break;
}
case roomType.shop:
{
roomObj = new GameObject
{
name = "Shop " + number,
tag = "Shop"
};
break;
}
case roomType.last:
{
roomObj = new GameObject
{
name = "Last Room",
tag = "Room"
};
break;
}
case roomType.secret:
{
roomObj = new GameObject
{
name = "Secret Room " + number,
tag = "Room"
};
break;
}
case roomType.nextlevel:
{
roomObj = new GameObject
{
name = "Next Level Room " + number,
tag = "Room"
};
break;
}
default:
{
roomObj = new GameObject
{
name = "Room " + number,
tag = "Room"
};
break;
}
}
Room room = roomObj.AddComponent <Room>();
Map.roomObjs.Add(room);
room.SetupRoom(number, width, height, transform.position, prevRoom, type, RoomMaxWidth, RoomMaxHeight); //room count - roombehind
room.SetupCorridor(DoorInvert(dir), minCorridorLength, randomGenerator); //Обычно count-1 - пред.комната
//Но иногда приходится идти на несколько комнат назад
CreateRoom(room);
}
public void Clear()
{
startDirection = Direction4D.Right;
squares.Clear();
}
internal void AddPushAnim(Block block, Point destination, PlayerAvatar pusher, Direction4D moveDirection)
{
switch(block)
{
case Block.Crate:
pushAnims.Add( new PushAnim(textures.crate, pusher, moveDirection.ToVector2() * widthOfBlock, destination) );
break;
}
}
public SilverBotMirrorPosition(Vector2 position, Direction4D d1, Direction4D d2)
{
this.position = position;
this.d1 = d1;
this.d2 = d2;
}
public Wall(Direction4D dir)
{
direction = dir;
}
