public static bool IsPlaceable <TForeground, TBackground>
(PlaceSendMessage p, IReadOnlyWorld <TForeground, TBackground> world)
where TForeground : struct
where TBackground : struct
{
return(p.X >= 0 && p.Y >= 0 && p.X < world.Width && p.Y < world.Height);
}
/// <summary>
/// Constructor to create a game.
/// </summary>
/// <param name="x">X/Row.</param>
/// <param name="y">Y/Column.</param>
public Game(int x, int y)
{
world = new World(x, y);
ui = new ConsoleUserInterface(this, world);
random = new Random();
agents = new List <Agent>();
}
/// <summary>
/// Constructor that accepts a Game and a read-only World.
/// </summary>
/// <param name="game">Reference to Game.</param>
/// <param name="world">Reference to World.</param>
public FileReader(Game game, IReadOnlyWorld world)
{
scores = new List <Highscore>();
this.game = game;
this.world = world;
CreateFile();
}
public static ReadOnlyWorldAreaEnumerable <TForeground, TBackground> AsReadOnlyWorldAreaEnumerable <TForeground, TBackground>(
this IReadOnlyWorld <TForeground, TBackground> world)
where TForeground : struct
where TBackground : struct
{
return(new ReadOnlyWorldAreaEnumerable <TForeground, TBackground>(world, new Rectangle(0, 0, world.Width, world.Height)));
}
/// <summary>
/// Constructor to create a UI.
/// </summary>
/// <param name="game">Reference to the game's properties.</param>
/// <param name="world">Reference to a read-only world.</param>
public ConsoleUserInterface(Game game, IReadOnlyWorld world)
{
Console.OutputEncoding = Encoding.UTF8;
Console.CursorVisible = false;
this.game = game;
fr = new FileReader(this.game, world);
}
/// <summary>
/// Construtor, cria uma nova instância desta classe.
/// </summary>
/// <param name="options">Opções do jogo.</param>
public Game(Options options)
{
// Guardar as opções do jogo numa variável de instância
this.options = options;
// Criar o mundo de jogo com o tamanho indicado nas opções do jogo
world = new World((int)options.XDim, (int)options.YDim);
// Instanciar o array de agentes com o tamanho exacto para todos
// os agentes
agents = new Agent[options.Zombies + options.Humans];
// Instanciar o gerador de números aleatórios
rand = new Random();
// Criar os zombies
for (uint i = 0; i < options.Zombies; i++)
{
if (i < options.PlayerZombies)
{
// Criar novo zombie controlado pelo jogador
NewAgent(AgentKind.Zombie, AgentMovement.Player, (int)i);
}
else
{
// Criar novo zombie controlado pela IA
NewAgent(AgentKind.Zombie, AgentMovement.AI, (int)i);
}
}
// Criar os humanos
for (uint i = 0; i < options.Humans; i++)
{
if (i < options.PlayerHumans)
{
// Criar novo humano controlado pelo jogador
NewAgent(AgentKind.Human, AgentMovement.Player,
(int)(options.Zombies + i));
}
else
{
// Criar novo humano controlado pela IA
NewAgent(AgentKind.Human, AgentMovement.AI,
(int)(options.Zombies + i));
}
}
}
public static void UploadWorld(this IBlockAreaEnumerable blockArea, IReadOnlyWorld <ForegroundBlock, BackgroundBlock> world)
{
var area = blockArea.Area;
if (world.Width > area.Width || world.Height > area.Height)
{
throw new ArgumentException("The world is too big for this area.", nameof(world));
}
for (var y = area.Top; y < area.Top + world.Height; y++)
{
for (var x = area.Left; x < area.Left + world.Width; x++)
{
blockArea.Blocks.Place(x, y, world.Foreground[x - area.Left, y - area.Top]);
blockArea.Blocks.Place(x, y, world.Background[x - area.Left, y - area.Top]);
}
}
}
/// <summary>
/// Atualiza a visualização do mundo de simulação no ecrã.
/// </summary>
/// <remarks>
/// Este método é uma implementação de
/// <see cref="IUserInterface.RenderWorld(IReadOnlyWorld)"/> para
/// consola.
/// </remarks>
/// <param name="world">
/// Referência só de leitura ao objeto que define o mundo de simulação.
/// </param>
public void RenderWorld(IReadOnlyWorld world)
{
// Percorrer linhas do mundo de simulação (até ao máximo calculado)
for (int y = 0; y < worldYRenderNCells; y++)
{
// Caso a cache ainda não tenha sido inicializada, colocar o
// cursor no início da linha atual
if (cache[0, y] == UNINITIALIZED)
{
SetCursor(posWorldLeft, posWorldTop + y);
}
// Percorrer colunas do mundo para a linha atual (até ao máximo
// calculado)
for (int x = 0; x < worldXRenderNCells; x++)
{
// Obter objeto posição para os valores atuais de x e y
Coord coord = new Coord(x, y);
// Está alguém na posição atual?
if (world.IsOccupied(coord))
{
// Em caso afirmativo, tratar de mostrar esse "alguém"
// Variável que representa o ID único do agente
string agentID;
// Agent na posição atual
Agent agent = world.GetAgentAt(coord);
// Obter o ID único do agente
agentID = agent.ToString();
// Se o ID único do agente tiver mais de 3 carateres,
// reduzir para 3 de modo a não desformatar mundo
if (agentID.Length > 3)
{
agentID =
agentID.Substring(0, 3);
}
// Este agente já cá estava no turno anterior? Se sim,
// não é necessário desenhá-lo novamente, pelo que
// podemos passar para a próxima iteração do ciclo
if (cache[x, y] == agentID)
{
continue;
}
// Caso a cache já tenha sido inicializada, colocar o
// cursos na posição correta (caso contrário já lá
// estaria)
if (cache[x, y] != UNINITIALIZED)
{
SetCursor(
posWorldLeft + worldCellLength * x,
posWorldTop + y);
}
// Ativar cor correta para o agente atual
SetAgentColor(agent.Kind, agent.Movement);
// Mostrar agente bem como o espaço que lhe se segue
Console.Write(agentID);
SetDefaultColor();
Console.Write(" ");
// Atualizar cache com a informação sobre este agente
// nesta posição
cache[x, y] = agentID;
}
else
{
// Se chegarmos aqui é porque não está ninguém na
// posição atual
// Se a cache indicar que não estava cá ninguém no
// turno anterior, escusamos de desenhar "..." e
// saltamos para a próxima iteração do ciclo
if (cache[x, y] == EMPTY)
{
continue;
}
// Caso a cache já tenha sido inicializada, colocar o
// cursos na posição correta (caso contrário já lá
// estaria)
if (cache[x, y] != UNINITIALIZED)
{
SetCursor(
posWorldLeft + worldCellLength * x,
posWorldTop + y);
}
// Ativar cor por omissão e desenhar "...", que
// corresponde a um espaço vazio
SetDefaultColor();
Console.Write("... ");
// Atualizar a cache sobre esta posição, nomeadamente
// com a indicação que não está cá ninguém
cache[x, y] = EMPTY;
}
}
// É suposto desenhar o nevoeiro horizontal? Só o precisamos de
// fazer uma vez, antes do mundo ser renderizado pela primeira
// vez
if (worldXRenderFog && !worldRendered)
{
// Posicionar cursor no fim da linha atual
SetCursor(
posWorldLeft + worldCellLength * worldXRenderNCells,
posWorldTop + y);
// Desenhar nevoeiro
Console.Write("~~~ ");
}
}
// É suposto desenhar o nevoeiro vertical? Só o precisamos de fazer
// uma vez, antes do mundo ser renderizado pela primeira vez.
if (worldYRenderFog && !worldRendered)
{
// Vamos usar um string builder para construir uma linha
// inteira de nevoeiro, que será a última linha do mundo,
// contendo um nevoeiro para cada coluna
string fogLine = new StringBuilder().Insert(
// Inserir nevoeiro a partir da posição 0 do string builder
0, "~~~ ",
// Repetir esse nevoeiro o número de vezes necessária
worldXRenderNCells + (worldXRenderFog ? 1 : 0)).ToString();
// Posicionar cursos no início da última linha
SetCursor(posWorldLeft, posWorldTop + worldYRenderNCells);
// Desenhar nevoeiro guardado no string builder
Console.Write(fogLine);
}
// Especificar que o mundo já foi renderizado uma vez
worldRendered = true;
}
/// <summary>
/// Empty Constructor that extends from the constructor from
/// the class AbstractMovement
/// </summary>
/// <param name="world"> World </param>
/// <returns></returns>
public PlayerMovement(IReadOnlyWorld world) : base(world)
{
}
public ReadOnlyWorldAreaEnumerable(IReadOnlyWorld <TForeground, TBackground> world, Rectangle area)
{
this.World = world;
this.Area = area;
}
/// <summary>
/// Construtor, que simplesmente aceita e guarda uma referência, só de
/// leitura, ao mundo de simulação.
/// </summary>
/// <param name="world">
/// Referência, só de leitura, ao mundo de simulação.
/// </param>
protected AbstractMovement(IReadOnlyWorld world)
{
this.world = world;
}
/// <summary>
/// Constructor inherited from base.
/// </summary>
/// <param name="world">Read-only world reference.</param>
public EnemyMovement(IReadOnlyWorld world) : base(world)
{
}
/// <summary>
/// Renders the interface to the side of the board.
/// </summary>
/// <param name="world">Read-only world reference.</param>
private void RenderInterface(IReadOnlyWorld world)
{
Console.SetCursorPosition(0 + world.XDim * 4, 0);
Console.Write("Your health: " + game.PlayerHP + " HP.");
Console.SetCursorPosition(0 + world.XDim * 4, 1);
Console.Write("Current level : " + game.Level);
Console.SetCursorPosition(0 + world.XDim * 4, 2);
SetColor(playerColor, 0);
Console.Write("P");
SetDefaultColor();
Console.Write(" - player");
Console.SetCursorPosition(0 + world.XDim * 4, 3);
SetColor(fgExitColor, 0);
Console.Write("O");
SetDefaultColor();
Console.Write(" - Objective");
Console.SetCursorPosition(0 + world.XDim * 4, 4);
SetColor(enemyColor, 0);
Console.Write("e");
SetDefaultColor();
Console.Write(" - Enemy");
Console.SetCursorPosition(0 + world.XDim * 4, 5);
SetColor(enemyColor, 0);
Console.Write("E");
SetDefaultColor();
Console.Write(" - Boss");
Console.SetCursorPosition(0 + world.XDim * 4, 6);
SetColor(powerUpColor, 0);
Console.Write("q");
SetDefaultColor();
Console.Write(" - Small PowerUp");
Console.SetCursorPosition(0 + world.XDim * 4, 7);
SetColor(powerUpColor, 0);
Console.Write("p");
SetDefaultColor();
Console.Write(" - PowerUp");
Console.SetCursorPosition(0 + world.XDim * 4, 8);
SetColor(powerUpColor, 0);
Console.Write("Q");
SetDefaultColor();
Console.Write(" - Big PowerUp");
Console.SetCursorPosition(0 + world.XDim * 4, 9);
SetColor(obstacleColor, 0);
Console.Write("{0}", blockedTile);
SetDefaultColor();
Console.Write(" - Wall");
Console.SetCursorPosition(0 + world.XDim * 4, 12);
Console.Write(" UP ");
Console.SetCursorPosition(0 + world.XDim * 4, 13);
Console.Write(" {0} ", upArrow);
Console.SetCursorPosition(0 + world.XDim * 4, 14);
Console.Write("LEFT {0} {1} RIGHT", leftArrow, rightArrow);
Console.SetCursorPosition(0 + world.XDim * 4, 15);
Console.Write(" {0} ", downArrow);
Console.SetCursorPosition(0 + world.XDim * 4, 16);
Console.Write(" DOWN ");
Console.SetCursorPosition(0, world.YDim);
}
public ReadOnlyWorldItem(IReadOnlyWorld <TForeground, TBackground> world, int x, int y)
{
this._world = world;
this.X = x;
this.Y = y;
}
/// <summary>
/// Método construtor, cria uma nova instância desta classe.
/// </summary>
/// <param name="world">
/// Referência só de leitura ao mundo de simulação.
/// </param>
public PlayerMovement(IReadOnlyWorld world) : base(world)
{
// Este construtor simplesmente chama o construtor da classe base.
}
/// <summary>
/// Método construtor.
/// </summary>
/// <param name="enemy">Agentes inimigos, a perseguir ou evitar.</param>
/// <param name="runAway">
/// Indica se os agentes inimigos devem ser evitados (<c>true</c>)
/// ou perseguidos (<c>false</c>).</param>
/// <param name="world">
/// Referência, só de leitura, ao mundo de simulação.
/// </param>
public AIMovement(AgentKind enemy, bool runAway, IReadOnlyWorld world)
: base(world)
{
this.enemy = enemy;
this.runAway = runAway;
}
/// <summary>
/// Renders the world and outputs it as a board.
/// </summary>
/// <param name="world">Read-only world reference.</param>
public void RenderWorld(IReadOnlyWorld world)
{
Console.SetCursorPosition(0, 0);
for (int x = 0; x < world.XDim; x++)
{
for (int y = 0; y < world.YDim; y++)
{
Position pos = new Position(x, y);
if (world.IsOccupied(pos))
{
Agent agent = world.GetAgentAt(pos);
if (agent.Type == AgentType.Player)
{
AgentColor(agent.Type);
Console.Write(" P ");
}
else if (agent.Type == AgentType.Exit)
{
AgentColor(agent.Type);
Console.Write(" O ");
}
else if (agent.Type == AgentType.SmallEnemy)
{
AgentColor(agent.Type);
Console.Write(" e ");
}
else if (agent.Type == AgentType.BigEnemy)
{
AgentColor(agent.Type);
Console.Write(" E ");
}
else if (agent.Type == AgentType.SmallPowerUp)
{
AgentColor(agent.Type);
Console.Write(" q ");
}
else if (agent.Type == AgentType.MediumPowerUp)
{
AgentColor(agent.Type);
Console.Write(" p ");
}
else if (agent.Type == AgentType.BigPowerUp)
{
AgentColor(agent.Type);
Console.Write(" Q ");
}
else if (agent.Type == AgentType.Obstacle)
{
AgentColor(agent.Type);
Console.Write(" {0} ", blockedTile);
}
}
else
{
SetDefaultColor();
Console.Write(" . ");
}
}
Console.WriteLine();
}
RenderInterface(world);
}
