pac-man.cx

package main

import "gl"
import "glfw"
import "graphical2d"

// Game constants
var WIDTH_WINDOW i32 = 840
var HEIGHT_WINDOW i32 = 930

// Game flags
var GAME_LEVEL i32 = 1
var GAME_MAX_LEVEL i32 = 10

// Directions
var UP i32 = 0
var DOWN i32 = 1
var LEFT i32 = 2
var RIGHT i32 = 3


// structs
type Cell struct {
  position graphical2d.Position2D
  dimensions graphical2d.Dimensions2D
  color graphical2d.Color
  index_x i32
  index_y i32
  ctype i32
}
var cells [31][28]Cell

type Ghost struct {
  position graphical2d.Position2D
  color graphical2d.Color
  radius f32
  index_x i32
  index_y i32
  direction i32
  gtype i32
  status i32
}
var ghosts [4]Ghost

type Point struct {
  position graphical2d.Position2D
  color graphical2d.Color
  radius f32
  ptype i32
  index_x i32
  index_y i32
  active bool
}
var points [1000] Point
var points_count i32 = 0


/***************************************
 * Declaration of constructor functions.
***************************************/

/* Function     : newCell
   Input        : Spawn line (line i32)
                : Spawn column (column i32)
                : Cell type (ct i32)
   Output       : cell (cell Cell)
   Description  : Constructor for the Cell struct.
*/
func newCell (line i32, column i32, ct i32) (cell Cell) {
  var pos graphical2d.Position2D
  pos = coords2position(line, column)

  var dim graphical2d.Dimensions2D
  dim = graphical2d.newDimensions2D(CELL_HEIGHT, CELL_WIDTH)

  cell = Cell{
    position: pos,
    dimensions: dim,
    color: getCellColor(ct),
    index_x: column,
    index_y: line,
    ctype: ct}
}

/* Function     : newGhost
   Input        : Spawn line (line i32)
                : Spawn column (column i32)
                : Ghost type (gt i32)
                : Ghost movement mode (ghost_mode i32)
   Output       : ghost (ghost Ghost)
   Description  : Constructor for the Ghost struct.
*/
func newGhost(line i32, column i32, gt i32, ghost_mode i32) (ghost Ghost) {
  var pos graphical2d.Position2D
  pos = coords2position(line, column)

  var col graphical2d.Color
  col = getGhostColor(gt)

  ghost = Ghost{
    position: pos,
    color: col,
    radius: GHOST_RADIUS,
    index_x: column,
    index_y: line,
    direction: UP,
    gtype: gt,
    status: ghost_mode}
}

/* Function     : newPoint
   Input        : Spawn line (line i32)
                : Spawn column (column i32)
                : Point type (pt i32)
   Output       : point (point Point)
   Description  : Constructor for the Point struct.
*/
func newPoint (line i32, column i32, pt i32) (point Point) {
  var pos graphical2d.Position2D
  pos = coords2position(line, column)

  var col graphical2d.Color
  col = graphical2d.newColor(POINT_COLOR_RED, POINT_COLOR_GREEN, POINT_COLOR_BLUE)

  var rad f32
  if i32.eq(pt, PATH_CELL_WITH_SIMPLE_POINT) {
    rad = SIMPLE_POINT_RADIUS
  }
  if i32.eq(pt, PATH_CELL_WITH_SUPER_POINT) {
    rad = SUPER_POINT_RADIUS
  }

  point = Point {
    position: pos,
    color: col,
    radius: rad,
    ptype: pt,
    index_x: column,
    index_y: line,
    active: true}
}


/***************************************
 * Color management functions.
***************************************/

/* Function     : getCellColor
   Input        : Cell type (ctype i32)
   Output       : The cell color (color graphical2d.Color)
   Description  : Returns the color corresponding to the cell type.
*/
func getCellColor (ctype i32) (color graphical2d.Color) {
  if i32.eq(ctype, PATH_CELL) {
    color = graphical2d.newColor(0.0, 0.0, 0.0)
  }
  if i32.eq(ctype, WALL_CELL) {
    color = graphical2d.newColor(0.0, 0.0, 1.0)
  }
  if i32.eq(ctype, TELEPORT_CELL) {
    color = graphical2d.newColor(0.0, 1.0, 1.0)
  }
  if i32.eq(ctype, GATE_CELL) {
    color = graphical2d.newColor(1.0, 0.5, 0.0)
  }
}

/* Function     : getGhostColor
   Input        : Ghost type (gtype i32)
   Output       : The ghost color (color graphical2d.Color)
   Description  : Returns the color corresponding to the ghost type.
*/
func getGhostColor (gtype i32) (color graphical2d.Color) {
  if i32.eq(gtype, SHADOW_GHOST) {
    color = graphical2d.newColor(1.0, 0.0, 0.0) // Red color
  }
  if i32.eq(gtype, SPEEDY_GHOST) {
    color = graphical2d.newColor(1.0, 0.5, 1.0) // Pink color
  }
  if i32.eq(gtype, BASHFUL_GHOST) {
    color = graphical2d.newColor(0.0, 1.0, 1.0) // Cyan color
  }
  if i32.eq(gtype, POKEY_GHOST) {
    color = graphical2d.newColor(1.0, 0.5, 0.25) // Orange color
  }
}


/***************************************
 * Movement related functions.
***************************************/

/* Function     : canMove
   Input        : movement direction (direction i32)
                : vertical board position (line i32)
                : horizontal board position (column i32)
   Output       : true (if movement is possible), false (otherwise)
   Description  : Checks if a game object located at (line/column) can move in the input (direction).
*/
func canMove(direction i32, line i32, column i32) (can_move bool)  {
  if bool.and(i32.eq(direction, UP), i32.eq(cells[i32.sub(line, 1)][column].ctype, PATH_CELL)) {
    can_move = true
  }
  if bool.and(i32.eq(direction, DOWN), i32.eq(cells[i32.add(line, 1)][column].ctype, PATH_CELL)) {
    can_move = true
  }
  if bool.and(i32.eq(direction, LEFT), i32.eq(cells[line][i32.sub(column, 1)].ctype, PATH_CELL)) {
    can_move = true
  }
  if bool.and(i32.eq(direction, RIGHT), i32.eq(cells[line][i32.add(column, 1)].ctype, PATH_CELL)) {
    can_move = true
  }
}