Graphics.UI.Fungen

This is the main module of FunGEN (Functional Game Engine), which re-exports the rest.

Execution

Starting and stopping a game.

funInit

Arguments

:: WindowConfig

main window layout

-> GameMap v

background/map(s)

-> [ObjectManager s]

object groups

-> u

initial game state

-> t

initial game attribute

-> [InputBinding t s u v]

input bindings

-> IOGame t s u v ()

step action

-> RefreshType

main loop timing

-> FilePictureList

image files

-> IO ()

Configure a FunGEn game and start it running.

funExit :: IOGame t s u v ()

Exit the program successfully (from within a game action).

Types

Some basic types.

type WindowConfig = ((Int, Int), (Int, Int), String)

position, size and name of the window

type Point2D = (GLdouble, GLdouble)

a bidimensional point in space

type ColorList3 = [(GLubyte, GLubyte, GLubyte)]

color in RGB format

type AwbfBitmap = (GLsizei, GLsizei, PixelData GLubyte)

width, height and data of bitmap

type InvList = Maybe [(Int, Int, Int)]

invisible colors (in RGB) of bitmap

Images

Loading BMP image files.

loadBitmap :: FilePath -> Maybe ColorList3 -> IO AwbfBitmap

Loads a bitmap from a file.

loadBitmapList :: [(FilePath, Maybe ColorList3)] -> IO [AwbfBitmap]

Loads n bitmaps from n files.

type FilePictureList = [(FilePath, InvList)]

Text

Printing text on the screen.

data BitmapFont :: *

The bitmap fonts available in GLUT. The exact bitmap to be used is defined by the standard X glyph bitmaps for the X font with the given name.

Constructors

Fixed8By13

A fixed width font with every character fitting in an 8 by 13 pixel rectangle. (-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1)

Fixed9By15

A fixed width font with every character fitting in an 9 by 15 pixel rectangle. (-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1)

TimesRoman10

A 10-point proportional spaced Times Roman font. (-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1)

TimesRoman24

A 24-point proportional spaced Times Roman font. (-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1)

Helvetica10

A 10-point proportional spaced Helvetica font. (-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1)

Helvetica12

A 12-point proportional spaced Helvetica font. (-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1)

Helvetica18

A 18-point proportional spaced Helvetica font. (-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1)

Instances

Eq BitmapFont

Ord BitmapFont

Show BitmapFont

Font BitmapFont

type Text = (String, BitmapFont, Point2D, GLclampf, GLclampf, GLclampf)

String to be printed, font, screen position, color RGB.

putGameText :: [Text] -> IO ()

Display these texts on screen.

Maps/backgrounds

Game backgrounds, tile maps.

data GameMap t

A game background (flat color, scrollable texture, or tile map), or several of them.

type Tile t

Arguments

 = (Int, Bool, Float, t)

index of picture, possibility to move, cost to move, additional params

type TileMatrix t = [[Tile t]]

creating

colorMap :: GLclampf -> GLclampf -> GLclampf -> GLdouble -> GLdouble -> GameMap t

creates a PreColorMap

textureMap :: Int -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GameMap t

creates a PreTextureMap

tileMap :: TileMatrix t -> GLdouble -> GLdouble -> GameMap t

creates a PreTileMap, cheking if the tileMatrix given is valid and automatically defining the map size

multiMap :: [GameMap t] -> Int -> GameMap t

creates a multimap

map attributes

isTileMap :: GameMap t -> Bool

isMultiMap :: GameMap t -> Bool

getMapSize :: GameMap t -> Point2D

getTileMapTileMatrix :: GameMap t -> TileMatrix t

getTileMapScroll :: GameMap t -> Point2D

getTileMapSize :: GameMap t -> Point2D

getTileMapTileSize :: GameMap t -> Point2D

map tiles

getTilePictureIndex :: Tile t -> Int

getTileBlocked :: Tile t -> Bool

getTileMoveCost :: Tile t -> Float

getTileSpecialAttribute :: Tile t -> t

setting the current map

getCurrentMap :: GameMap t -> GameMap t

updateCurrentMap :: GameMap t -> GameMap t -> GameMap t

updateCurrentIndex :: GameMap t -> Int -> GameMap t

drawing

drawGameMap :: GameMap t -> Point2D -> [TextureObject] -> IO ()

draw the background map

clearGameScreen :: GLclampf -> GLclampf -> GLclampf -> IO ()

clear the screen

Objects

Game objects (sprites).

data ObjectManager t

data GameObject t

data ObjectPicture

Constructors

Tex (GLdouble, GLdouble) Int

Basic Primitive

data Primitive

Constructors

Polyg [Point2D] GLfloat GLfloat GLfloat FillMode

Circle GLdouble GLfloat GLfloat GLfloat FillMode

data FillMode

Constructors

Filled

Unfilled

Instances

Eq FillMode

creating

object :: String -> ObjectPicture -> Bool -> (GLdouble, GLdouble) -> (GLdouble, GLdouble) -> t -> GameObject t

object attributes

getGameObjectId :: GameObject t -> Integer

getGameObjectName :: GameObject t -> String

getGameObjectManagerName :: GameObject t -> String

getGameObjectAsleep :: GameObject t -> Bool

getGameObjectPosition :: GameObject t -> (GLdouble, GLdouble)

getGameObjectSize :: GameObject t -> (GLdouble, GLdouble)

getGameObjectSpeed :: GameObject t -> (GLdouble, GLdouble)

getGameObjectAttribute :: GameObject t -> t

updating

updateObject :: (GameObject t -> GameObject t) -> Integer -> String -> [ObjectManager t] -> [ObjectManager t]

updateObjectAsleep :: Bool -> GameObject t -> GameObject t

updateObjectSize :: (GLdouble, GLdouble) -> GameObject t -> GameObject t

updateObjectPosition :: (GLdouble, GLdouble) -> GameObject t -> GameObject t

updateObjectSpeed :: (GLdouble, GLdouble) -> GameObject t -> GameObject t

updateObjectAttribute :: t -> GameObject t -> GameObject t

updateObjectPicture :: Int -> Int -> GameObject t -> GameObject t

drawing

drawGameObjects :: [ObjectManager t] -> QuadricPrimitive -> [TextureObject] -> IO ()

drawGameObject :: GameObject t -> QuadricPrimitive -> [TextureObject] -> IO ()

moving

moveGameObjects :: [ObjectManager t] -> [ObjectManager t]

destroying

destroyGameObject :: String -> String -> [ObjectManager t] -> [ObjectManager t]

groups of objects

objectGroup :: String -> [GameObject t] -> ObjectManager t

addObjectsToManager :: [GameObject t] -> String -> [ObjectManager t] -> [ObjectManager t]

getObjectManagerName :: ObjectManager t -> String

getObjectManagerCounter :: ObjectManager t -> Integer

getObjectManagerObjects :: ObjectManager t -> [GameObject t]

searching

findObjectFromId :: GameObject t -> [ObjectManager t] -> GameObject t

searchObjectManager :: String -> [ObjectManager t] -> ObjectManager t

searchGameObject :: String -> ObjectManager t -> GameObject t

Input

User input from mouse and keyboard.

type InputBinding t s u v = (Key, KeyEvent, InputHandler t s u v)

A mapping from an input event to an input handler.

type InputHandler t s u v = Modifiers -> Position -> IOGame t s u v ()

A FunGEn input handler is like an IOGame (game action) that takes two extra arguments: the current keyboard modifiers state, and the current mouse position. (For a StillDown event, these will be the original state and position from the Press event.)

data KeyEvent

Constructors

Press

StillDown

Release

Instances

Eq KeyEvent

data Key :: *

A generalized view of keys

Constructors

Char Char

SpecialKey SpecialKey

MouseButton MouseButton

Instances

Eq Key

Ord Key

Show Key

data SpecialKey :: *

Special keys

Constructors

KeyF1

KeyF2

KeyF3

KeyF4

KeyF5

KeyF6

KeyF7

KeyF8

KeyF9

KeyF10

KeyF11

KeyF12

KeyLeft

KeyUp

KeyRight

KeyDown

KeyPageUp

KeyPageDown

KeyHome

KeyEnd

KeyInsert

KeyNumLock

KeyBegin

KeyDelete

KeyShiftL

KeyShiftR

KeyCtrlL

KeyCtrlR

KeyAltL

KeyAltR

KeyUnknown Int

You should actually never encounter this value, it is just here as a safeguard against future changes in the native GLUT library.

Instances

Eq SpecialKey

Ord SpecialKey

Show SpecialKey

data MouseButton :: *

Mouse buttons, including a wheel

Constructors

LeftButton

MiddleButton

RightButton

WheelUp

WheelDown

AdditionalButton Int

Instances

Eq MouseButton

Ord MouseButton

Show MouseButton

data Modifiers :: *

The state of the keyboard modifiers

Constructors

Modifiers

Fields

shift :: KeyState

ctrl :: KeyState

alt :: KeyState

Instances

Eq Modifiers

Ord Modifiers

Show Modifiers

data Position :: *

A 2-dimensional position, measured in pixels.

Constructors

Position !GLint !GLint

Instances

Eq Position

Ord Position

Show Position

funInitInput :: [InputBinding t s u v] -> Game t s u v -> IO (KeyBinder, StillDownHandler)

Initialise the input system, which keeps a list of input event to action bindings and executes the the proper actions automatically. Returns a function for adding bindings (GLUT's - should return the FunGEn-aware one instead ?), and another which should be called periodically (eg from refresh) to trigger still-down actions.

Timing

Timing control.

data RefreshType

Used by funInit to configure the main loop's timing strategy.

Constructors

Idle

Timer Int

setRefresh :: RefreshType -> StillDownHandler -> IO ()

Change the current timing strategy.

Game

Game management and various game utilities.

data Game t s u v

A game has the type Game t s u v, where

• t is the type of the game special attributes
• s is the type of the object special attributes
• u is the type of the game levels (state)
• v is the type of the map tile special attribute, in case we use a Tile Map as the background of our game

For a mnemonic, uh...

• t - Top-level game attribute type,
• s - Sprite object attribute type,
• u - Updating game state type,
• v - Vicinity (map tile) attribute type.

Internally, a Game consists of:

• gameMap       :: IORef (GameMap v)         -- a map (background)

• gameState     :: IORef u                   -- initial game state

• gameFlags     :: IORef GameFlags           -- initial game flags

• objManagers   :: IORef [(ObjectManager s)] -- some object managers

• textList      :: IORef [Text]              -- some texts

• quadricObj    :: QuadricPrimitive          -- a quadric thing

• windowConfig  :: IORef WindowConfig        -- a config for the main window

• gameAttribute :: IORef t                   -- a game attribute

• pictureList   :: IORef [TextureObject]     -- some pictures

• fpsInfo       :: IORef (Int,Int,Float)     -- only for debugging

data IOGame t s u v a

IOGame is the monad in which game actions run. An IOGame action takes a Game (with type parameters t s u v), performs some IO, and returns an updated Game along with a result value (a):

newtype IOGame t s u v a = IOG (Game  t s u v -> IO (Game t s u v,a))

The name IOGame was chosen to remind that each action deals with a Game, but an IO operation can also be performed between game actions (such as the reading of a file or printing something in the prompt).

Instances

Monad (IOGame t s u v)

Functor (IOGame t s u v)

Applicative (IOGame t s u v)

creating

createGame :: GameMap v -> [ObjectManager s] -> WindowConfig -> u -> t -> FilePictureList -> IO (Game t s u v)

IO utilities

runIOGame :: IOGame t s u v a -> Game t s u v -> IO (Game t s u v, a)

runIOGameM :: IOGame t s u v a -> Game t s u v -> IO ()

liftIOtoIOGame :: IO a -> IOGame t s u v a

liftIOtoIOGame' :: (a -> IO ()) -> a -> IOGame t s u v ()

game state

getGameState :: IOGame t s u v u

setGameState :: u -> IOGame t s u v ()

getGameAttribute :: IOGame t s u v t

setGameAttribute :: t -> IOGame t s u v ()

game flags

getGameFlags :: IOGame t s u v GameFlags

setGameFlags :: GameFlags -> IOGame t s u v ()

enableGameFlags :: IOGame t s u v ()

disableGameFlags :: IOGame t s u v ()

enableMapDrawing :: IOGame t s u v ()

disableMapDrawing :: IOGame t s u v ()

enableObjectsDrawing :: IOGame t s u v ()

disableObjectsDrawing :: IOGame t s u v ()

enableObjectsMoving :: IOGame t s u v ()

disableObjectsMoving :: IOGame t s u v ()

map operations

drawMap :: IOGame t s u v ()

draws the background map

clearScreen :: GLclampf -> GLclampf -> GLclampf -> IOGame t s u v ()

paint the whole screen with a specified RGB color

getTileFromIndex :: (Int, Int) -> IOGame t s u v (Tile v)

returns a mapTile, given its index (x,y) in the tile map

getTileFromWindowPosition :: (GLdouble, GLdouble) -> IOGame t s u v (Tile v)

returns a mapTile, given its pixel position (x,y) in the screen

setCurrentMapIndex :: Int -> IOGame t s u v ()

set the current map for a MultiMap

object operations

getObjectManagers :: IOGame t s u v [ObjectManager s]

setObjectManagers :: [ObjectManager s] -> IOGame t s u v ()

drawAllObjects :: IOGame t s u v ()

draws all visible objects

drawObject :: GameObject s -> IOGame t s u v ()

draw one object

moveAllObjects :: IOGame t s u v ()

changes objects position according to its speed

destroyObjects :: [GameObject s] -> IOGame t s u v ()

destroys objects from the game

destroyObject :: GameObject s -> IOGame t s u v ()

destroys an object from the game

getObjectsFromGroup :: String -> IOGame t s u v [GameObject s]

returns the list of all objects from the group whose name is given

addObjectsToGroup :: [GameObject s] -> String -> IOGame t s u v ()

adds an object to a previously created group

addObjectsToNewGroup :: [GameObject s] -> String -> IOGame t s u v ()

adds an object to a new group

findObjectManager :: String -> IOGame t s u v (ObjectManager s)

returns an object manager of the game, given its name (internal use)

findObject :: String -> String -> IOGame t s u v (GameObject s)

returns an object of the game, given its name and is object manager name

getObjectName :: GameObject s -> IOGame t s u v String

there is no need to search through the managers, because the name of an object is never modified so the result of this function will always be safe.

getObjectGroupName :: GameObject s -> IOGame t s u v String

because an object can have its group (manager) name modified, it is necessary to search through the managers to find it, otherwise this functions won't be safe.

getObjectAsleep :: GameObject s -> IOGame t s u v Bool

because an object can have its sleeping status modified, it is necessary to search through the managers to find it, otherwise this functions won't be safe.

getObjectSize :: GameObject s -> IOGame t s u v (GLdouble, GLdouble)

because an object can have its size modified, it is necessary to search through the managers to find it, otherwise this functions won't be safe.

getObjectPosition :: GameObject s -> IOGame t s u v (GLdouble, GLdouble)

because an object can have its position modified, it is necessary to search through the managers to find it, otherwise this functions won't be safe.

getObjectSpeed :: GameObject s -> IOGame t s u v (GLdouble, GLdouble)

because an object can have its speed modified, it is necessary to search through the managers to find it, otherwise this functions won't be safe.

getObjectAttribute :: GameObject s -> IOGame t s u v s

because an object can have its attribute modified, it is necessary to search through the managers to find it, otherwise this functions won't be safe.

setObjectPosition :: (GLdouble, GLdouble) -> GameObject s -> IOGame t s u v ()

changes the position of an object, given its new position

setObjectAsleep :: Bool -> GameObject s -> IOGame t s u v ()

changes the sleeping status of an object, given its new status

setObjectSpeed :: (GLdouble, GLdouble) -> GameObject s -> IOGame t s u v ()

changes the speed of an object, given its new speed

setObjectCurrentPicture :: Int -> GameObject s -> IOGame t s u v ()

changes the current picture of a multitextured object

setObjectAttribute :: s -> GameObject s -> IOGame t s u v ()

changes the attribute of an object, given its new attribute

replaceObject :: GameObject s -> (GameObject s -> GameObject s) -> IOGame t s u v ()

replaces an object by a new one, given the old object and the function that must be applied to it.

reverseXSpeed :: GameObject s -> IOGame t s u v ()

reverseYSpeed :: GameObject s -> IOGame t s u v ()

collision detection

objectsCollision :: GameObject s -> GameObject s -> IOGame t s u v Bool

checks the collision between two objects

objectsFutureCollision :: GameObject s -> GameObject s -> IOGame t s u v Bool

checks the collision between two objects in the next game cicle

objectListObjectCollision :: [GameObject s] -> GameObject s -> IOGame t s u v Bool

objectListObjectFutureCollision :: [GameObject s] -> GameObject s -> IOGame t s u v Bool

objectTopMapCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the top of the map

objectBottomMapCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the bottom of the map

objectRightMapCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the right side of the map

objectLeftMapCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the left side of the map

pointsObjectCollision :: GLdouble -> GLdouble -> GLdouble -> GLdouble -> GameObject s -> IOGame t s u v Bool

pointsObjectListCollision :: GLdouble -> GLdouble -> GLdouble -> GLdouble -> [GameObject s] -> IOGame t s u v Bool

objectTopMapFutureCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the top of the map in the next game cicle

objectBottomMapFutureCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the bottom of the map in the next game cicle

objectRightMapFutureCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the right side of the map in the next game cicle

objectLeftMapFutureCollision :: GameObject s -> IOGame t s u v Bool

checks the collision between an object and the left side of the map in the next game cicle

text operations

printOnPrompt :: Show a => a -> IOGame t s u v ()

prints a string in the prompt

printOnScreen :: String -> BitmapFont -> (GLdouble, GLdouble) -> GLclampf -> GLclampf -> GLclampf -> IOGame t s u v ()

prints a string in the current window

printText :: IOGame t s u v ()

internal use of the engine

random numbers

randomFloat :: (Float, Float) -> IOGame t s u v Float

randomInt :: (Int, Int) -> IOGame t s u v Int

randomDouble :: (Double, Double) -> IOGame t s u v Double

utilities

showFPS :: BitmapFont -> (GLdouble, GLdouble) -> GLclampf -> GLclampf -> GLclampf -> IOGame t s u v ()

shows the frame rate (or frame per seconds)

wait :: Int -> IOGame t s u v ()

delay for N seconds while continuing essential game functions

Display

Rendering the game window.

display :: Game t s u v -> IOGame t s u v () -> DisplayCallback

Given a fungen Game and IOGame step action, generate a GLUT display callback that steps the game and renders its resulting state. funInit runs this automatically.

Util

Miscellaneous utilities.

texCoord2 :: GLdouble -> GLdouble -> IO ()

vertex3 :: GLdouble -> GLdouble -> GLdouble -> IO ()

texStuff :: [TextureObject] -> [AwbfBitmap] -> IO ()

toRad :: Float -> Float

randInt :: (Int, Int) -> IO Int

randFloat :: (Float, Float) -> IO Float

randDouble :: (Double, Double) -> IO Double

shiftLeft :: String -> Int -> String

toDecimal :: String -> GLsizei

pow2 :: GLsizei -> GLsizei

toBinary :: Int -> String

make0 :: Int -> String

dropGLsizei :: GLsizei -> [a] -> [a]

ord2 :: Char -> GLubyte

addNoInvisibility :: [FilePath] -> [(FilePath, Maybe ColorList3)]

to be used when no invisibility must be added when loading a file

racMod :: GLdouble -> GLdouble -> GLdouble

matrixToList :: [[a]] -> [a]

matrixSize :: [[a]] -> (Int, Int)

return the max indexes of a matrix (assumed that its lines have the same length)

inv2color3 :: InvList -> Maybe ColorList3

pathAndInv2color3List :: (FilePath, InvList) -> (FilePath, Maybe ColorList3)

point2DtoVertex3 :: [Point2D] -> [Vertex3 GLdouble]

isEmpty :: [a] -> Bool

when :: Monad m => Bool -> m () -> m ()

unless :: Monad m => Bool -> m () -> m ()

bindTexture :: TextureTarget2D -> TextureObject -> IO ()

tracewith :: (a -> String) -> a -> a

trace an expression using a custom show function

strace :: Show a => a -> a

trace a showable expression

ltrace :: Show a => String -> a -> a

labelled trace - like strace, with a label prepended

mtrace :: (Monad m, Show a) => a -> m a

monadic trace - like strace, but works as a standalone line in a monad