Pārlūkot izejas kodu

WIP: Report part 1

tags/v1.0b1
Christos Choutouridis pirms 4 gadiem
vecāks
revīzija
a96bb62966
6 mainītis faili ar 148 papildinājumiem un 71 dzēšanām
  1. +39
    -18
      src/host/labyrinth/Board.java
  2. +55
    -32
      src/host/labyrinth/Common.java
  3. +16
    -5
      src/host/labyrinth/Game.java
  4. +25
    -7
      src/host/labyrinth/Player.java
  5. +6
    -4
      src/host/labyrinth/Supply.java
  6. +7
    -5
      src/host/labyrinth/Tile.java

src/net/hoo2/auth/labyrinth/Board.java → src/host/labyrinth/Board.java Parādīt failu

@@ -1,11 +1,13 @@
/**
* @file Board.java
*
* @author Christos Choutouridis AEM:8997
* @email cchoutou@ece.auth.gr
* @author
* Christos Choutouridis
* <cchoutou@ece.auth.gr>
* AEM:8997
*/

package net.hoo2.auth.labyrinth;
package host.labyrinth;

import java.util.ArrayList;
import java.util.function.IntFunction;
@@ -131,7 +133,8 @@ class Board {
}

/**
* Predicate to check if a direction is Walkable
* Predicate to check if a direction is Walkable.
*
* @param tileId The starting tileId.
* @param direction The desired direction.
* @return True if it is walkable.
@@ -142,9 +145,10 @@ class Board {
}

/**
* Predicate to check if a direction is Walkable
* Predicate to check if a direction is Walkable.
*
* @param row Row position of the starting tile.
* @param column Column position of the starting tile.
* @param col Column position of the starting tile.
* @param direction The desired direction.
* @return True if it is walkable.
*/
@@ -175,7 +179,7 @@ class Board {
* @return A random direction;
*/
int dice () {
ShuffledRange d = new ShuffledRange(Direction.Begin, Direction.End, Direction.Step);
ShuffledRange d = new ShuffledRange(DirRange.Begin, DirRange.End, DirRange.Step);
return d.get();
}

@@ -205,6 +209,13 @@ class Board {
*/
Supply[] getSupplies() { return supplies; }

/**
* @note Use it with care. Any use of this function results to what Sean Parent calls "incidental data-structure".
* <a href="https://github.com/sean-parent/sean-parent.github.io/blob/master/better-code/03-data-structures.md"> see also here</a>
* @return Reference to inner walls array.
*/
ArrayList<Edge> getWalls() { return walls; }

void setN(int N) { this.N = N; }
void setS(int S) { this.S = S; }
void setW(int W) { this.W = W; }
@@ -221,6 +232,14 @@ class Board {
* Any call to this function will probably add memory for the garbage collector.
*/
void setSupplies(Supply[] supplies) { this.supplies= supplies; }

/**
* @param walls Reference to walls that we want to act as replacement for the inner walls vector.
* @note Use with care.
* Any call to this function will probably add memory for the garbage collector.
*/
void setWalls (ArrayList<Edge> walls) { this.walls= walls; }

/** @} */


@@ -269,16 +288,16 @@ class Board {
/**
* Predicate to check if a wall creates a closed room.
*
* This algorithm has a complexity of O(N^2logN) where N represents the total
* This algorithm has a complexity of @f$ O(N^2logN) @f$ where N represents the total
* number of tiles.
* It should be used with care.
*
* @param tileId The tileId of the wall where the wall is.
* @param direction The wall's relative direction from the tile.
* @param tileId The tileId of the wall.
* @param direction The wall's relative direction.
* @return True if the wall creates a closed room, false otherwise.
*/
private boolean makesClosedRoom (int tileId, int direction) {
// Get a snapshot list of all the walls (all the walls on the board)
// Clone the list of all the walls locally.
ArrayList<Edge> w = new ArrayList<Edge>();
for (Edge it : walls)
w.add(new Edge(it));
@@ -288,14 +307,14 @@ class Board {
int size;
do {
size = w.size(); // mark the size (before the pass)
for (int i =0, S=w.size() ; i<S ; ++i)
if (g.attach(w.get(i))) { // Can we attach the edge(wall) to the graph ?
w.remove(i); // If yes remove it from the wall list
for (int i =0, S=w.size() ; i<S ; ++i) // for each edge(wall) on the local wall list
if (g.attach(w.get(i))) { // can we attach the edge(wall) to the graph ?
w.remove(i); // if yes remove it from the local wall list
--i; --S; // decrease iterator and size to match ArrayList's new values
}
} while (size != w.size()); // If the size hasn't change(no new graph leafs) exit

// Search if a vertex is attached more than once.
// Search if a vertex is attached to the graph more than once.
// This means that there is at least 2 links to the same node
// so the graph has a closed loop
for (Edge it : walls) {
@@ -365,7 +384,7 @@ class Board {
return false;
if (tiles[tileId].hasWalls() >= Const.maxTileWalls)
return false;
Range dirs = new Range(Direction.Begin, Direction.End, Direction.Step);
Range dirs = new Range(DirRange.Begin, DirRange.End, DirRange.Step);
for (int dir ; (dir = dirs.get()) != Const.noTileId ; )
if (isWallableDir(tileId, dir))
return true;
@@ -388,6 +407,7 @@ class Board {
boolean right = isRightSentinel(i);
wallCount += ((up?1:0) + (down?1:0) + (left?1:0) + (right?1:0));
tiles[i] = new Tile (i, up, down, left, right);
// If we have loopGuard enable we populate walls also.
if (Session.loopGuard) {
if (up) walls.add(new Edge(i, Direction.UP));
if (down) walls.add(new Edge(i, Direction.DOWN));
@@ -404,14 +424,16 @@ class Board {
*/
private void createInnerWall(int tileId) {
// Randomly pick a wallable direction in that tile.
ShuffledRange randDirections = new ShuffledRange(Direction.Begin, Direction.End, Direction.Step);
ShuffledRange randDirections = new ShuffledRange(DirRange.Begin, DirRange.End, DirRange.Step);
int dir;
do
dir = randDirections.get();
while (!isWallableDir(tileId, dir));
// Add wall to tileId and the adjacent tileId
Position neighbor = new Position(Position.toRow(tileId), Position.toCol(tileId), dir);
tiles[tileId].setWall(dir);
tiles[neighbor.getId()].setWall(Direction.opposite(dir));
// If we have loopGuard enable we populate walls also.
if (Session.loopGuard)
walls.add(new Edge(tileId, dir));
}
@@ -419,7 +441,6 @@ class Board {
/**
* This utility creates the inner walls of the board.
*
* @param walls The number of walls to create
* @return The number of walls failed to create.
*/
private int createInnerWalls () {

src/net/hoo2/auth/labyrinth/Common.java → src/host/labyrinth/Common.java Parādīt failu

@@ -1,10 +1,12 @@
/**
* @file Common.java
*
* @author Christos Choutouridis AEM:8997
* @email cchoutou@ece.auth.gr
* @author
* Christos Choutouridis
* <cchoutou@ece.auth.gr>
* AEM:8997
*/
package net.hoo2.auth.labyrinth;
package host.labyrinth;

import java.util.ArrayList;
import java.util.Collections;
@@ -36,16 +38,31 @@ class Direction {
static final int RIGHT =3; /**< East direction */
static final int DOWN =5; /**< South direction */
static final int LEFT =7; /**< West direction */
static final int Begin =1; /**< Iterator style begin of range direction (starting north) */
static final int End =8; /**< Iterator style end of range direction (one place after the last) */
static final int Step =2; /**< Step for iterator style direction */

/**
* Utility to get the opposite
* Utility to get the opposite direction.
* @param direction Input direction
* @return The opposite direction
*/
static int opposite (int direction) { return (direction+4)%End; }
static int opposite (int direction) { return (direction+4)%DirRange.End; }
}

/**
* Helper C++ like enumerator class for direction ranged loops.
*
* We can make use of this in loops like:
* <pre>
* for (int i=DirRange.Begin ; i<DirRange.End ; i += DirRange.Step) { }
*
* or
*
* Range directions = new Range(DirRange.Begin, DirRange.End, DirRange.Step);
* </pre>
*/
class DirRange {
static final int Begin =1; /**< Iterator style begin of range direction (starting north) */
static final int End =8; /**< Iterator style end of range direction (one place after the last) */
static final int Step =2; /**< Step for iterator style direction */
}

/**
@@ -55,7 +72,7 @@ class Direction {
* Position is a helper class to enable us cope with the redundant position data (id and coordinates).
* This class provide both static conversion functionalities between id and coordinates
* and data representation in the coordinates system.
* For clarity we adopt a row-column naming convention.
* For clarity we adopt a tileId convention.
*/
class Position {

@@ -219,18 +236,21 @@ class ShuffledRange extends Range {
* This class is the wall representation we use in the room preventing algorithm.
* In this algorithm we represent the crosses between tiles as nodes (V) of a graph and the
* walls as edges. So for example:
*
* _ V = 15
* /
* +---+---+---+ We have a 4x4=16 vertices board(nodes) and 14 edges(walls).
* | | To represent the vertices on the board we use the
* + +---+ + same trick as the tileId.
* | | | The edges are represented as vertices pairs.
* + + + + <.
* | | | \_ V = 7
* + +---+---+
* ^ ^
* V = 0 V = 3
* <pre>
* 12--13--14---15
* | |
* 8 9--10 11
* | | |
* 4 5 6 7
* | | |
* 0 1---2---3
* </pre>
* In this example we have a 4x4=16 vertices board(nodes) and 14 edges(walls).
* To represent the vertices on the board we use the same trick as the tileId
*
* V = Row*(N+1) + Column, where N is the board's tile size.
*
* The edges are represented as vertices pairs. For example (0, 4) or (13, 14).
*
* @note
* Beside the fact that we prefer this kind of representation of the walls in
@@ -242,7 +262,7 @@ class ShuffledRange extends Range {
*/
class Edge {
/**
* This constructor as as the interface between the application's wall
* This constructor acts as the interface between the application's wall
* representation and the one based on graph.
* @param tileId The tile id of the wall.
* @param direction The direction of the tile where the wall should be.
@@ -286,13 +306,13 @@ class Edge {
* @brief
* Provides a graph functionality for the room preventing algorithm.
* We use a graph to represent the wall structure of the walls. This way
* is easy to find any closed loops. Using graph we transform the problem
* of the closed room in the problem of finding a non simple graph.
* its easy to find any closed loops. Using graph we transform the problem
* of the closed room into the problem of finding a non simple graph.
*
* If the board has non connected wall structure then we need more than
* If the board has non connected wall structure then we would need more than
* one graph to represent it.
*
* An example graph from a board, starting from V=1 is:
* An example graph we can create from the board bellow, starting from V=1 is:
* <pre>
* 6---7 8 (1)
* | | / \
@@ -327,7 +347,7 @@ class Graph {

/**
* Attach an edge into a graph IFF the graph already has a vertex
* with the same value of one of the vertices of the edge.
* with the same value as one of the vertices of the edge.
* @param e The edge to attach.
* @return The status of the operation.
* @arg True on success
@@ -348,17 +368,18 @@ class Graph {

/**
* Recursive algorithm that tries to attach an edge into a graph
* IFF the graph already has a vertex.
* with the same value of one of the vertices of the edge.
* IFF the graph already has a vertex with the same value as one
* of the vertices of the edge.
*
* @param e The edge to attach.
* @param count An initial count value to feed to the algorithm.
* @param count An initial count value to feed the algorithm.
* @return The status of the operation.
* @arg True on success
* @arg False on failure
*/
private int tryAttach (Edge e, int count) {
for (Graph n: E)
count += n.tryAttach (e, count);
count = n.tryAttach (e, count);
if (V == e.getV1()) {
E.add(new Graph(e.getV2()));
++count;
@@ -372,7 +393,8 @@ class Graph {

/**
* Recursive algorithm that tries to count the number of vertices
* on the graph with the value of `v`
* on the graph with the same value as `v`.
*
* @param v The vertex to count
* @param count An initial count value to feed to the algorithm.
* @return The number of vertices with value `v`
@@ -384,6 +406,7 @@ class Graph {
return ++count;
return count;
}

private int V; /**< The value of the current vertex/node */
private ArrayList<Graph> E; /**< A list of all the child nodes */
}

src/net/hoo2/auth/labyrinth/Game.java → src/host/labyrinth/Game.java Parādīt failu

@@ -1,11 +1,22 @@
/**
* @file Game.java
*
* @author Christos Choutouridis AEM:8997
* @email cchoutou@ece.auth.gr
* @author
* Christos Choutouridis
* <cchoutou@ece.auth.gr>
* AEM:8997
*/

package net.hoo2.auth.labyrinth;
/**
* @mainpage A labyrinth board game
*
* @section intro_sec Introduction
*
* This is the introduction.
*
* etc...
*/
package host.labyrinth;

import java.util.Scanner;

@@ -28,8 +39,8 @@ public class Game {
int nextRound() { return ++round; }

/**
* Utility to hold the execution of the program waiting for user input.
* This is true only if the user passed the interactive flag.
* Utility to hold the execution of the program waiting for user input.
* This is true only if the user passed the interactive flag.
*/
void waitUser () {
if(Session.interactive) {

src/net/hoo2/auth/labyrinth/Player.java → src/host/labyrinth/Player.java Parādīt failu

@@ -1,5 +1,13 @@
package net.hoo2.auth.labyrinth;
/**
* @file Player.java
*
* @author
* Christos Choutouridis
* <cchoutou@ece.auth.gr>
* AEM:8997
*/

package host.labyrinth;

/**
* @brief
@@ -11,9 +19,12 @@ class Player {

/**
* Create a new player and put him at the row-column coordinates
* @param id The id of the player
* @param name The name of the player
* @param board Reference to the board of the game
* @param id The id of the player
* @param name The name of the player
* @param champion Flag to indicate if a player is a `champion`
* @param board Reference to the board of the game
* @param row The row coordinate of initial player position
* @param column The column coordinate of initial player's position
*/
Player(int id, String name, boolean champion, Board board, int row, int column) {
this.playerId = id;
@@ -27,9 +38,11 @@ class Player {

/**
* Create a new player and put him at the row-column coordinates
* @param id The id of the player
* @param name The name of the player
* @param board Reference to the board of the game
* @param id The id of the player
* @param name The name of the player
* @param champion Flag to indicate if a player is a `champion`
* @param board Reference to the board of the game
* @param tileId The tileId coordinate of player's initial position
*/
Player(int id, String name, boolean champion, Board board, int tileId) {
this.playerId = id;
@@ -105,6 +118,7 @@ class Player {
int getScore () { return score; }
int getX() { return x; }
int getY() { return y; }
boolean getChampion(){ return champion; }

void setPlayerId(int id) { playerId = id; }
void setName(String name) { this.name = name; }
@@ -118,6 +132,10 @@ class Player {
assert (y >= 0 && y< Session.boardSize) : "Y(row) coordinate must be in the range [0, Session.boardSize)";
this.y = y;
}
void setChampion (boolean champion) {
this.champion = champion;
}

/** @} */
/** @name Class data */

src/net/hoo2/auth/labyrinth/Supply.java → src/host/labyrinth/Supply.java Parādīt failu

@@ -1,11 +1,13 @@
/**
* @file Supply.java
*
* @author Christos Choutouridis AEM:8997
* @email cchoutou@ece.auth.gr
* @author
* Christos Choutouridis
* <cchoutou@ece.auth.gr>
* AEM:8997
*/

package net.hoo2.auth.labyrinth;
package host.labyrinth;

/**
* @brief
@@ -76,7 +78,7 @@ class Supply {
int supplyId () { return supplyId; }
/**
* Set the supplyId
* @param sId The Id to set
* @param sID The Id to set
* @return The supplyId
* @note This function also returns the supplyId to help in chained expressions.
*/

src/net/hoo2/auth/labyrinth/Tile.java → src/host/labyrinth/Tile.java Parādīt failu

@@ -1,11 +1,13 @@
/**
* @file Tile.java
*
* @author Christos Choutouridis AEM:8997
* @email cchoutou@ece.auth.gr
* @author
* Christos Choutouridis
* <cchoutou@ece.auth.gr>
* AEM:8997
*/

package net.hoo2.auth.labyrinth;
package host.labyrinth;

/**
* @brief
@@ -132,7 +134,7 @@ class Tile {

/**
* Sets the tile's wall in the requested direction.
* @param up The direction for the wall.
* @param direction The direction for the wall.
*/
void setWall (int direction) {
switch (direction) {
@@ -145,7 +147,7 @@ class Tile {

/**
* Clears the tile's wall in the requested direction.
* @param up The direction for the wall
* @param direction The direction for the wall
*/
void clearWall (int direction) {
switch (direction) {

Notiek ielāde…
Atcelt
Saglabāt