Imj.Game.Hamazed.World

Parameters

When the game starts, the player can chose World parameters:

• WorldShape : square or rectangular World where the width is twice the height
• WallDistribution : Should the World have walls, and what kind of walls.

getGameParameters :: (Render e, MonadReader e m, MonadIO m) => m GameParameters

Displays the configuration UI showing the game creation options, and returns when the player has finished chosing the options.

data GameParameters

Constructors

GameParameters

Fields

• _gameParamsWorldShape :: !WorldShape
• _gameParamsWallDistrib :: !WallDistribution

Level

There are 12 levels in Hamazed, numbered from 1 to 12.

data Level

Constructors

Level

Fields

• _levelNumber :: !Int

  From 1 to 12

• _levelTarget :: !Int

  The target number

• _levelStatus :: !(Maybe LevelFinished)

Level termination

Target number

Each level has a different target number which represents the sum of shot Numbers that should be reached to finish the Level.

A Level is finished once the sum of shot Numbers amounts to the target number.

checkTargetAndAmmo

Arguments

:: Int

Remaining ammo

-> Int

The current sum of all shot Numbers

-> Int

The Level 's target number.

-> SystemTime

The current time

-> Maybe LevelFinished

World

A World brings together:

• game elements : Space, BattleShip and Numbers,
• rendering elements: Animations,
• terminal-awareness : InTerminal

data World

Constructors

World

Fields

• _worldNumbers :: ![Number]

  The remaining Numbers (shot Numbers are removed from the list)

• _worldShip :: !BattleShip

  The player's BattleShip

• _worldSpace :: !Space

  The Space in which BattleShip and Numbers evolve

• _worldAnimations :: ![Animation]

  Visual animations. They don't have an influence on the game, they are just here for aesthetics.

• _worldEmbedded :: !InTerminal

  To know where we should draw the World from, w.r.t terminal frame.

Create the world

The World size decreases with increasing Level numbers.

worldSizeFromLevel gives the Size of the World based on the Level number and the WorldShape:

worldSizeFromLevel

Arguments

:: Int

Level number

-> WorldShape

-> Size

Once we have the Size of the World, we can create it using mkWorld:

mkWorld

Arguments

:: MonadIO m

=> InTerminal

Tells where to draw the World from

-> Size

The dimensions

-> WallDistribution

How the Walls should be constructed

-> [Int]

The numbers for which we will create Numbers.

-> Int

Ammunition : how many laser shots are available.

-> m World

Update World

Every gameMotionPeriod seconds, the positions of BattleShip and Numbers are updated according to their speeds:

gameMotionPeriod :: DiffTime

moveWorld

Arguments

:: KeyTime

The current time

-> World

-> World

Moves elements of game logic (Numbers, BattleShip).

Note that Animations are not updated.

Render World

renderWorld :: (Draw e, MonadReader e m, MonadIO m) => World -> m ()

World utilities

laserEventAction returns the effect a laser shot it has on the World.

laserEventAction

Arguments

:: Direction

The direction of the laser shot

-> World

-> ([Number], [Number], Maybe (LaserRay Actual), Int)

Numbers still alive, Numbers destroyed, maybe an actual laser ray, Ammo left.

Computes the effect of an laser shot on the World.

InTerminal

InTerminal allows to place the game in the center of the terminal.

mkInTerminal

Arguments

:: MonadIO m

=> Size

Measures the dimensions of the inner content of the World, excluding the outer frame.

-> m (Either String InTerminal)

Will compute the position of the World so as to display it in the center of the terminal window.

data InTerminal

Constructors

InTerminal

Fields

• _inTerminalSize :: !(Maybe (Window Int))

  The size of the terminal window

• _inTerminalUpperLeft :: !(Coords Pos)

  The World 's RectContainer upper left coordinates, w.r.t terminal frame.

Instances

Show InTerminal

Methods

showsPrec :: Int -> InTerminal -> ShowS

show :: InTerminal -> String

showList :: [InTerminal] -> ShowS

Space

Space describes the environment in which Numbers and the BattleShip live.

It can be composed of Air, where BattleShip and Numbers are free to move, and of Wall.

data Space

data Material

Constructors

Air

In it, ship and numbers can move.

Wall

Ship and numbers rebound on Walls.

Instances

Eq Material

Methods

(==) :: Material -> Material -> Bool

(/=) :: Material -> Material -> Bool

Show Material

Methods

showsPrec :: Int -> Material -> ShowS

show :: Material -> String

showList :: [Material] -> ShowS

Simple creation

mkEmptySpace :: Size -> Space

Creates a rectangular empty space of size specified in parameters.

mkDeterministicallyFilledSpace :: Size -> Space

Creates a rectangular deterministic space of size specified in parameters.

Randomized creation

mkRandomlyFilledSpace places Walls at random and discards resulting Spaces which have more than one Air connected component.

This way, the BattleShip is guaranteed to be able to reach any part of the Space, and Numbers.

Generating a big Space with a very small block size can be computationnaly expensive because the probability to have a single Air connected component drops very fast (probably at least exponentially) towards zero with increasing sizes.

mkRandomlyFilledSpace :: RandomParameters -> Size -> IO Space

Creates a rectangular random space of size specified in parameters, with a one-element border. IO is used for random numbers generation.

data RandomParameters

Parameters for random walls creation.

Constructors

RandomParameters

Fields

• _randomWallsBlockSize :: !Int

  The size of a square wall block.

  Note that the smaller the block size, the harder it will be for the algorithm to find a random world with a single component of air.

• _randomWallsStrategy :: !Strategy

  Space characteristics (only one connected component is available for the moment)

data Strategy

Constructors

StrictlyOneComponent

There should be a single connected component of air.

This way, the ship can reach any allowed location without having to go through Walls.

Collision detection

location is the standard collision detection function that considers that being outside the world means being in collision.

scopedLocation prevides more options with the use of Boundaries to defines the collision detection scopes.

location :: Coords Pos -> Space -> Location

Considers that outside Space, everything is OutsideWorld

scopedLocation

Arguments

:: Space

-> Maybe (Window Int)

The terminal size

-> Coords Pos

The world upper left coordinates w.r.t terminal frame.

-> Boundaries

The scope

-> Coords Pos

The coordinates to test

-> Location

data Boundaries

Constructors

WorldFrame

Just the world.

TerminalWindow

The terminal, not the world.

Both

The terminal.

Instances

Show Boundaries

Methods

showsPrec :: Int -> Boundaries -> ShowS

show :: Boundaries -> String

showList :: [Boundaries] -> ShowS

Collision detection utilities

createRandomNonCollidingPosSpeed :: Space -> IO PosSpeed

Creates a PosSpeed such that its position is not colliding, and moves to precollision and mirrors speed if a collision is detected for the next step (see mirrorSpeedAndMoveToPrecollisionIfNeeded).

Render

renderSpace

Arguments

:: (Draw e, MonadReader e m, MonadIO m)

=> Space

-> Coords Pos

World upper left coordinates w.r.t terminal frame.

-> m (Coords Pos)

Movable items

A movable item's PosSpeed is updated using updateMovableItem at each MoveFlyingItems event:

updateMovableItem

Arguments

:: Space

The surrounding Space will be taken into account for collisions.

-> PosSpeed

The current position and speed of the moving item.

-> PosSpeed

The updated position and speed.

Updates PosSpeed of a movable item, according to Space.

BattleShip

data BattleShip

Constructors

BattleShip

Fields

• _shipPosSpeed :: !PosSpeed

  Discrete position and speed.

• _shipAmmo :: !Int

  How many laser shots are left.

• _shipSafeUntil :: !(Maybe SystemTime)

  At the beginning of each level, the ship is immune to collisions with Numbers for a given time. This field holds the time at which the immunity ends.

• _shipCollisions :: ![Number]

  Which Numbers are currently colliding with the BattleShip.

Instances

Show BattleShip

Methods

showsPrec :: Int -> BattleShip -> ShowS

show :: BattleShip -> String

showList :: [BattleShip] -> ShowS

Accelerate BattleShip

The BattleShip is controlled in (discrete) acceleration by the player using the keyboard.

accelerateShip :: Direction -> BattleShip -> BattleShip

Note that the position of the BattleShip remains unchanged.

Number

 Numbers can be shot by the BattleShip to finish the Level.

Number can collide with the BattleShip, hence triggering colorfull Animation explosions.

Numbers never change speed, except when they rebound on Walls, of course.

data Number

Constructors

Number

Fields

• _numberPosSpeed :: !PosSpeed

  Discrete position and speed.

• _numberNum :: !Int

  Which number it represents (1 to 16).

Instances

Eq Number

Methods

(==) :: Number -> Number -> Bool

(/=) :: Number -> Number -> Bool

Show Number

Methods

showsPrec :: Int -> Number -> ShowS

show :: Number -> String

showList :: [Number] -> ShowS

UI

UI elements around the World are:

• a RectContainer created by mkWorldContainer to visually delimit the World

• ColorString information, placed around the RectContainer:

  • Up: Level target
  • Left: remaining ammunitions / shot Numbers
  • Down: Level number

mkWorldContainer :: World -> RectContainer

Helper function to create a RectContainer containing a World.

Inter-level animations

module Imj.Graphics.UI.Animation

Secondary types

data WallDistribution

How should walls be created?

Constructors

None

No Walls.

Deterministic

A Rectangular Wall in the middle of the level.

Random !RandomParameters

Walls are created with an algorithm involving random numbers.

data WorldShape

Constructors

Square

Width = Height

Rectangle2x1

Width = 2 * Height

data LevelFinished

Constructors

LevelFinished

Fields

• _levelFinishedResult :: !GameStops

  Lost or won

• _levelFinishedWhen :: !SystemTime
• _levelFinishedCurrentMessage :: !MessageState

data GameStops

Constructors

Lost Text

Text is the reason why the Level was lost.

Won

Reexports

module Imj.Graphics.Render

data ColorString :: *

Instances

Show ColorString

Methods

showsPrec :: Int -> ColorString -> ShowS

show :: ColorString -> String

showList :: [ColorString] -> ShowS

IsString ColorString

Methods

fromString :: String -> ColorString

Monoid ColorString

Methods

mempty :: ColorString

mappend :: ColorString -> ColorString -> ColorString

mconcat :: [ColorString] -> ColorString

DiscreteInterpolation ColorString

First interpolating characters, then color.

Methods

interpolate :: ColorString -> ColorString -> Int -> ColorString

interpolateSuccessive :: Successive ColorString -> Int -> ColorString

DiscreteDistance ColorString

First interpolating characters, then color.

Methods

distance :: ColorString -> ColorString -> Int

distanceSuccessive :: Successive ColorString -> Int