/// <summary>
/// Change size of current grid.
/// </summary>
/// <param name="newSize"></param>
private void ResizeGrid(Vector2Int newSize)
{
ClearElements();
ClearGrid();
ElementType[,] oldElements = elementTypes;
ElementType[,] elements = new ElementType[newSize.y, newSize.x];
for (int y = 0; y < newSize.y; y++)
{
for (int x = 0; x < newSize.x; x++)
{
if (y < oldElements.GetLength(0) && x < oldElements.GetLength(1))
{
elements[y, x] = oldElements[y, x];
}
else
{
elements[y, x] = ElementType.Air;
}
}
}
for (int y = 0; y < mapSize.y; y++)
{
for (int x = 0; x < mapSize.x; x++)
{
elementTypes[y, x] = ElementType.Air;
}
}
isPlayer = false;
IsDeleting = false;
InitializeEditor(elements, newSize, biomeType, Difficulty.Easy, mapName);
}
private static bool CheckIfGameIsOver(ElementType[,] field)
{
int numberOfRows = field.GetUpperBound(0) + 1;
int numberOfCols = field.GetUpperBound(1) + 1;
for (int i = 0; i < numberOfRows; i++)
{
for (int j = 0; j < numberOfCols; j++)
{
switch (field[i, j])
{
case ElementType.X:
if (CheckConsecutiveElements(field, numberOfCols, numberOfRows, i, j, ElementType.X))
{
return(true);
}
break;
case ElementType.O:
if (CheckConsecutiveElements(field, numberOfCols, numberOfRows, i, j, ElementType.O))
{
return(true);
}
break;
default:
break;
}
}
}
return(false);
}
/// <summary>
/// Checks whether count of boxes equals count of targets.
/// </summary>
public static bool ValidateBoxes(ref ElementType[,] map)
{
int boxesCount = 0, targetsCount = 0;
for (int i = 0; i < map.GetLength(0); i++)
{
for (int j = 0; j < map.GetLength(1); j++)
{
if (map[i, j] == ElementType.Box)
{
boxesCount++;
}
if (map[i, j] == ElementType.Target || map[i, j] == ElementType.PlayerOnTarget)
{
targetsCount++;
}
}
}
if (boxesCount != targetsCount)
{
return(false);
}
else
{
return(boxesCount > 0 ? true : false);
}
}
private static void DrawField(ElementType[,] field)
{
int numberOfRows = field.GetUpperBound(0);
int numberOfColumns = field.GetUpperBound(1);
for (int rowIndex = 0; rowIndex <= numberOfRows; rowIndex++)
{
for (int columnIndex = 0; columnIndex <= numberOfColumns; columnIndex++)
{
switch (field[rowIndex, columnIndex])
{
case ElementType.X:
Console.Write("|X|");
break;
case ElementType.O:
Console.Write("|O|");
break;
case ElementType.Blank:
int index = (numberOfColumns + 1) * rowIndex + columnIndex;
Console.Write("|" + index + "|");
break;
default:
break;
}
}
Console.WriteLine();
}
}
/// <summary>
/// Returns cloned map.
/// </summary>
/// <returns></returns>
public Map Clone()
{
ElementType[,] elements = (ElementType[, ])mapDefinition.Clone();
Map map = new Map(name, elements, biomeType, difficulty);
return(map);
}
private static void InitializeField(int numberOfRows, int numberOfColumns,
ElementType[,] field)
{
for (int i = 0; i < numberOfRows; i++)
{
for (int j = 0; j < numberOfColumns; j++)
{
field[i, j] = ElementType.Blank;
}
}
}
private static void ImplementInput(ElementType[,] field, ElementType x, string input)
{
int rowIndex = -1;
int colIndex = -1;
int intInput = Convert.ToInt32(input);
ConvertIndexToMatrix(intInput, ref rowIndex,
ref colIndex, field.GetUpperBound(1) + 1);
field[rowIndex, colIndex] = x;
}
public void LoadMap(MapDescription desc)
{
mapSize = desc.Size;
//加载地形
m_Terrain.Size = MapSize;
terrainLayer = new TerrainType[MapSize.x, MapSize.y];
generateTerrain(desc.terrainDict);
//加载元素
m_Element.Size = MapSize;
elementLayer = new ElementType[MapSize.x, MapSize.y];
generateElement(desc.elementDict);
}
private static bool CheckIfAvaibleSpaceLeft(ElementType[,] field)
{
int numOfRows = field.GetUpperBound(0) + 1;
int numOfCols = field.GetUpperBound(1) + 1;
for (int i = 0; i < numOfRows; i++)
{
for (int j = 0; j < numOfCols; j++)
{
if (field[i, j] == ElementType.Blank)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Initializes new editor session and loads map with given size with elements from given 2D array.
/// </summary>
/// <param name="mapDefinition">Map elements</param>
/// <param name="mapSize">Size of map</param>
/// <param name="biomeType">Type of biome</param>
/// <param name="difficulty">Difficulty of map</param>
/// <param name="mapName">Name of map</param>
public void InitializeEditor(ElementType[,] mapDefinition, Vector2Int mapSize, Biomes biomeType, Difficulty difficulty, string mapName)
{
if (!Directory.Exists(PathToMapsDir))
{
Directory.CreateDirectory(PathToMapsDir);
}
IsEditor = true;
this.mapSize = mapSize;
this.mapName = mapName;
this.biomeType = biomeType;
nameField.SetValue(mapName);
CameraSettings();
editorUI.SetBool("show", true);
CreateGrid(mapSize);
elements = new List <GameObject> [mapSize.y, mapSize.x];
elementTypes = new ElementType[mapSize.y, mapSize.x];
for (int y = 0; y < mapSize.y; y++)
{
for (int x = 0; x < mapSize.x; x++)
{
elementTypes[y, x] = ElementType.Air;
}
}
for (int y = 0; y < mapSize.y; y++)
{
for (int x = 0; x < mapSize.x; x++)
{
elements[y, x] = new List <GameObject>();
SelectElement(mapDefinition[y, x]);
PlaceElement(new Vector3(x, 0f, -y));
}
}
LevelManager.CurrentManager.SetBackgroundColor(biomeType);
SelectElement(ElementType.Ground);
SetButtons();
}
/// <summary>
/// Creates new map which contains given elements.
/// </summary>
/// <param name="map">Elements</param>
public Map(string name, ElementType[,] map)
{
mapSize = new Vector2Int(map.GetLength(1), map.GetLength(0));
if (!IsOnePlayer(ref map))
{
Debug.LogError("Map has to contain only one player element!");
return;
}
if (!ValidateBoxes(ref map))
{
Debug.LogError("Count of boxes has to equal count of targets and must at least one");
return;
}
this.name = name;
mapDefinition = (ElementType[, ])map.Clone();
}
public Robot(Position position, int battery, string[] strategies,
FacingControl facingControl, MovingControl movingControl,
ElementType[,] terrainElementTypes, Stack <CommandType> stackCommandTypes)
{
Position = position;
Battery = (battery > 0) ? battery : 0;
NextStrategy = 0;
FacingControl = facingControl;
MovingControl = movingControl;
Strategies = strategies;
Terrain = terrainElementTypes;
StackCommandTypes = stackCommandTypes;
VisitedCells = new List <Location> {
Position.Location
};
SamplesCollected = new List <ElementType>();
SolutionStepByStep = new List <Result>();
_robotMemento = new RobotMemento(position, battery, strategies, facingControl, movingControl);
}
// Factory Method
public static Robot Create(JToken initialPosition, JToken battery, string[] robotStrategies,
FacingControl facingControl, MovingControl movingControl,
ElementType[,] terrainElementTypes, Stack <CommandType> stackCommandTypes)
{
// Validate parameters, throw exceptions
var locationObject = JObject.Parse(initialPosition.ToString())["location"];
int x = (int)JObject.Parse(locationObject.ToString())["x"];
int y = (int)JObject.Parse(locationObject.ToString())["y"];
var facingObject = (JToken)JObject.Parse(initialPosition.ToString())["facing"];
var facing = (Facing)Enum.Parse(typeof(Facing), facingObject.ToString());
Location location = new Location(x, y);
Position position = new Position(location, facing);
return(new Robot(position, battery.Value <int>(), robotStrategies,
facingControl, movingControl,
terrainElementTypes, stackCommandTypes));
}
private static bool CheckIfInputIsValid(int fieldSize, string input, ElementType[,] field,
int numOfCol, int numOfRow)
{
try
{
int intInput = Convert.ToInt32(input);
int rowIndex = -1;
int colIndex = -1;
ConvertIndexToMatrix(intInput, ref rowIndex, ref colIndex, numOfCol);
if (intInput >= field.Length)
{
Console.Clear();
DrawField(field);
Console.WriteLine("{0} is not a valid index.", intInput);
return(false);
}
else if (field[rowIndex, colIndex] != ElementType.Blank)
{
Console.Clear();
DrawField(field);
Console.WriteLine("That place is already occupied.");
return(false);
}
return(true);
}
catch (FormatException)
{
Console.Clear();
DrawField(field);
Console.WriteLine(input + " is not a number.");
return(false);
}
}
private static bool CheckConsecutiveElements(ElementType[,] field, int numberOfCols, int numberOfRows, int i, int j, ElementType element)
{
//Case 1 left-right
if (j + 2 < numberOfCols)
{
if (field[i, j + 1] == element && field[i, j + 2] == element)
{
return(true);
}
}
// Case 2 Right-Down Cross
if (i + 2 < numberOfRows && j + 2 < numberOfCols)
{
if (field[i + 1, j + 1] == element && field[i + 2, j + 2] == element)
{
return(true);
}
}
// Case 3 Up-Down
if (i + 2 < numberOfRows)
{
if (field[i + 1, j] == element && field[i + 2, j] == element)
{
return(true);
}
}
// Case 4 Left-Down Cross
if (i + 2 < numberOfRows && j - 2 >= 0)
{
if (field[i + 1, j - 1] == element && field[i + 2, j - 2] == element)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Returns back to menu, note that it doesn't save map.
/// </summary>
public void BackToMenu()
{
editorUI.SetBool("show", false);
ClearGrid();
ClearElements();
cam.transform.rotation = Quaternion.identity;
LevelManager.CurrentManager.SetMainMenuBackgroundColor();
Animator camAnim = cam.GetComponent <Animator>();
camAnim.enabled = true;
mainMenu.OpenPage(MainMenu.ModuleNumber == 2 ? 2 : 0);
camAnim.SetTrigger("switch");
elementTypes = new ElementType[0, 0];
elements = new List <GameObject> [0, 0];
mapSize = Vector2Int.zero;
isPlayer = false;
mapName = string.Empty;
mapPath = string.Empty;
cam.GetComponent <MapEditorCamera>().DeactivateController();
}
/// <summary>
/// Checks whether the given map has only one player.
/// </summary>
/// <param name="map">Array to check.</param>
public static bool IsOnePlayer(ref ElementType[,] map)
{
bool hasPlayer = false;
for (int i = 0; i < map.GetLength(0); i++)
{
for (int j = 0; j < map.GetLength(1); j++)
{
if (hasPlayer && (map[i, j] == ElementType.Player || map[i, j] == ElementType.PlayerOnTarget))
{
return(false);
}
if (!hasPlayer && (map[i, j] == ElementType.Player || map[i, j] == ElementType.PlayerOnTarget))
{
hasPlayer = true;
}
}
}
return(true);
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="map_width">ilosc komorek w poziomie mapy</param>
/// <param name="map_height">ilosc komorek w pionie mapy</param>
public RandomOperator(int map_width, int map_height)
{
this.map_width = map_width;
this.map_height = map_height;
Map = new ElementType[map_width, map_height];
}
public Terrain(ElementType[,] map)
{
Map = map;
}
/// <summary>
/// Konwersja tablicy enum-ów na tablice obiektów MapObject
/// </summary>
/// <param name="map_obj">zwracana tablica po konwersji</param>
/// <param name="objects">pobierana tablica int-ów</param>
private void CovertIntToObjects(ref MapObject[,] map_obj, ElementType[,] objects)
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
switch (objects[x, y])
{
case ElementType.AMEBA:
map_obj[x, y] = new DestroyableObjects.Ameba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.BLOB:
map_obj[x, y] = new Characters.Blob(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.CHODZACABOMBA:
map_obj[x, y] = new Characters.ChodzacaBomba(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.CIEZKIMUR:
map_obj[x, y] = new NonDestroyableObjects.CiezkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.DYNAMIT:
map_obj[x, y] = new Weapon.Dynamit(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.GIGANTYCZNYSZCZUR:
map_obj[x, y] = new Characters.GigantycznySzczur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.GOBLIN:
map_obj[x, y] = new Characters.Goblin(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.KAMIEN:
map_obj[x, y] = new DestroyableObjects.Kamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.LEKKIMUR:
map_obj[x, y] = new DestroyableObjects.LekkiMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.MAGICZNYMUR:
map_obj[x, y] = new NonDestroyableObjects.MagicznyMur(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.MARMUROWYKAMIEN:
map_obj[x, y] = new NonDestroyableObjects.MarmurowyKamien(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.PEKDYNAMITOW:
map_obj[x, y] = new Weapon.PekDynamitow(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.POLESILOWE:
map_obj[x, y] = new Weapon.PoleSilowe(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.PUSTE:
map_obj[x, y] = new NonDestroyableObjects.Puste(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.RACKET:
map_obj[x, y] = new Weapon.Racket(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.RADIOAKTYWNYGLAZ:
map_obj[x, y] = new NonDestroyableObjects.RadioaktywnyGlaz(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.VANDAL:
this.vandal = new Characters.Vandal(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
map_obj[x, y] = vandal;
break;
case ElementType.ZIEMIA:
map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.CELMISJI:
map_obj[x, y] = new DestroyableObjects.CelMisji(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y, gameLevel);
break;
case ElementType.BECZKAZGAZEM:
map_obj[x, y] = new DestroyableObjects.BeczkaZGazem(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
case ElementType.NIESTABILNABECZKA:
map_obj[x, y] = new DestroyableObjects.NiestabilnaBeczka(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
default:
map_obj[x, y] = new DestroyableObjects.Ziemia(content, new Rectangle(x * tile_size, y * tile_size, tile_size, tile_size), x, y);
break;
}
}
}
}
public Level(int width, int height)
{
this.Width = width;
this.Height = height;
arrTile = new ElementType[Width, Height];
}