HGE2D

A 2D game engine.

Connecting the state

Games can be written by defining a GameState and the EngineState event handlers for it. Example of a possible GameState you might define:

data GameState = GameState
    { gsSize :: (Double, Double) -- size of the window
    , time   :: Millisecond      -- current time of your game's state
    , player :: Player           -- your definition for a player
    , world  :: World            -- your definition for the world    
    }

The EngineState which has to be implemented for your GameState:

data EngineState a = EngineState
    { click           :: PosX -> PosY -> a -> a -- how your game should change when clicked
    , hover           :: PosX -> PosY -> a -> a -- how your game should change when hovered
    , drag            :: PosX -> PosY -> a -> a -- how your game should change when dragged
    , resize          :: (Width, Height) -> a -> a -- how to resize your game
    , getSize         :: a -> (Width, Height) -- how to get the size of your game
    , moveTime        :: Millisecond -> a -> a -- how your game should change over time
    , getTime         :: a -> Millisecond -- how to get the current time of your game
    , setTime         :: Millisecond -> a -> a -- how to set the time of your game
    , getTitle        :: a -> String -- how to get the title of your game
    , toGlInstr       :: a -> RenderInstruction -- how to receive a render instruction to display your game
    }

Rendering

Rendering is done by implementing GlInstructable for your GameState, which requires you to define a RenderInstruction for your state. This type is very composable and can be used to define any combination of basic shapes:

--- The class you have to implement
class GlInstructable a where
    toGlInstruction :: a -> RenderInstruction

--- The RenderInstruction type and its constructors
data RenderInstruction = RenderNothing
                       | RenderWithCamera GlPosX GlPosY GlScaleX GlScaleY RenderInstruction
                       | RenderText String
                       | RenderLineStrip GlShape GL.GLfloat
                       | RenderTriangle GlShape
                       | RenderLineLoop GlShape GL.GLfloat
                       | RenderScale GlScaleX GlScaleY
                       | RenderTranslate GlPosX GlPosY
                       | RenderRotate Double
                       | RenderColorize GlColorRGB
                       | RenderColorizeAlpha GlColorRGBA
                       | RenderPreserve RenderInstruction
                       | RenderMany [RenderInstruction]

--- Some example shapes included within HGE2D which can be used to define the RenderInstruction of your GameState
rectangle :: GlWidth -> GlHeight -> RenderInstruction
rectangle w h = RenderTriangle [ll, lr, ur, ur, ul, ll]
  where
    ll = point2 xMin yMin
    lr = point2 xMax yMin
    ur = point2 xMax yMax
    ul = point2 xMin yMax

    xMin = - (w/2)
    xMax =   (w/2)
    yMin = - (h/2)
    yMax = (h/2)

borderedRectangle :: GlWidth -> GlHeight -> GlThickness -> GlColorRGB -> GlColorRGBA -> RenderInstruction
borderedRectangle w h t colorInner colorBorder = RenderMany
    [ RenderColorize colorInner
    , rectangle w h
    , RenderColorizeAlpha colorBorder
    , wireFrame w h t
    ]

--- In a game this might look like this
instance GlInstructable Tower where
    toGlInstruction t = RenderMany
      [ baseRender (base t)
      , centerRender (center t)
      , RenderPreserve $ RenderMany
        [ RenderTranslate (rtf centerX) (rtf centerY)
        , RenderRotate (radGun $ gun t)
        , gunSkinRender (gunSkin $ gun t)
        , radarRender (radarSkin $ radar t)
        , rangeRenders
        ]
      ]
      where
          centerX = getX t
          centerY = getY t

          rangeRenders | not (towerHighlighted t) = RenderNothing
                       | otherwise = RenderMany [shotRangeRender (shotRange $ shot $ gun t), radarRangeRender (scanRange $ radar t)]

          baseRender :: Base -> RenderInstruction
          ...

          centerRender :: Center -> RenderInstruction
          ...

Some more types, classes and functions

-- | For types which are positioned in space
class Positioned a where
    getPos :: a -> RealPosition
    getX   :: a -> Double
    getY   :: a -> Double

-- | For types which are affected by time
class Dynamic a where
    moveInTime :: Millisecond -> a -> a

-- | Tests whether two objects collide (overlap in any way)
doCollide :: (HasBoundingBox a, HasBoundingBox b) => a -> b -> Bool

-- | A bounding box tree for fast collision detection
data (HasBoundingBox a) => AABBTree a = AABBTreeEmpty
                                      | AABBTreeLeaf [a] BoundingBox
                                      | AABBTreeBranch (AABBTree a) (AABBTree a) BoundingBox