{- $Id: Object.hs,v 1.2 2003/11/10 21:28:58 antony Exp $
******************************************************************************
* I N V A D E R S *
* *
* Module: Object *
* Purpose: Definition of objects in the world and their static *
* properties. *
* Author: Henrik Nilsson *
* *
* Copyright (c) Yale University, 2003 *
* *
******************************************************************************
-}
module Object (
Object,
ObjInput(..),
ObjOutput(..),
ObsObjState(..),
oosGun, -- :: Position2 -> Velocity2 -> ObsObjState
oosMissile, -- :: Position2 -> Velocity2 -> ObsObjState
oosAlien, -- :: Position2 -> Heading -> Velocity2 -> ObsObjState
isGun, -- :: ObsObjState -> Bool
isMissile, -- :: ObsObjState -> Bool
isAlien, -- :: ObsObjState -> Bool
touches, -- :: ObsObjState -> ObsObjState -> Bool
approaches, -- :: ObsObjState -> ObsObjState -> Bool
colliding, -- :: ObsObjState -> ObsObjState -> Bool
gunRadius, -- :: Length
gunBase, -- :: Length
gunHeight, -- :: Length
gunSpeedMax, -- :: Speed
gunAccMax, -- :: Acceleration
missileRadius, -- :: Length
missileInitialSpeed,-- :: Speed
missileLifeSpan, -- :: Time
alienRadius, -- :: Length
alienWingRadius, -- :: Length
alienAccMax -- :: Acceleration
) where
import FRP.Yampa (SF, Event)
import FRP.Yampa.Geometry
import FRP.Yampa.Forceable
import Parser (GameInput)
import PhysicalDimensions
import WorldGeometry
------------------------------------------------------------------------------
-- Object and related types
------------------------------------------------------------------------------
-- Objects are represented by signal functions, i.e. they are reactive and
-- can carry internal state.
type Object = SF ObjInput ObjOutput
data ObjInput = ObjInput {
oiHit :: Event (),
oiGameInput :: GameInput
}
data ObjOutput = ObjOutput {
ooObsObjState :: !ObsObjState,
ooKillReq :: Event (),
ooSpawnReq :: Event [Object]
}
-- Note: ObsObjState (Observable Object State) should only be constructed/
-- updated through the provided constructors/update functions since some of
-- the fields (e.g. if a bounding box field were added) might be dependent on
-- others. The reason ObsObjState is not exported abstractly is that it is
-- convenient to inspect it by pattern matching.
--
-- To avoid space leaks, all fields (except possibly dependent ones) are
-- strict.
data ObsObjState =
OOSGun {
oosPos :: !Position2,
oosVel :: !Velocity2,
oosRadius :: !Length,
oosAmLvl :: !Int
}
| OOSMissile {
oosPos :: !Position2,
oosVel :: !Velocity2,
oosRadius :: !Length
}
| OOSAlien {
oosPos :: !Position2,
oosHdng :: !Heading,
oosVel :: !Velocity2,
oosRadius :: !Length
}
------------------------------------------------------------------------------
-- Instances
------------------------------------------------------------------------------
instance Forceable ObsObjState where
-- If non-strict fields: oosNonStrict1 obj `seq` ... `seq` obj
force obj = obj
------------------------------------------------------------------------------
-- Smart constructors
------------------------------------------------------------------------------
-- If dependent fields (such as a bounding box) are added, these should also
-- be computed here.
oosGun :: Position2 -> Velocity2 -> Int -> ObsObjState
oosGun p v l = OOSGun {
oosPos = p,
oosVel = v,
oosRadius = gunRadius,
oosAmLvl = l
}
oosMissile :: Position2 -> Velocity2 -> ObsObjState
oosMissile p v = OOSMissile {
oosPos = p,
oosVel = v,
oosRadius = missileRadius
}
oosAlien :: Position2 -> Heading -> Velocity2 -> ObsObjState
oosAlien p h v = OOSAlien {
oosPos = p,
oosHdng = normalizeHeading h,
oosVel = v,
oosRadius = alienRadius
}
------------------------------------------------------------------------------
-- Recognizers
------------------------------------------------------------------------------
isGun :: ObsObjState -> Bool
isGun (OOSGun {}) = True
isGun _ = False
isMissile :: ObsObjState -> Bool
isMissile (OOSMissile {}) = True
isMissile _ = False
isAlien :: ObsObjState -> Bool
isAlien (OOSAlien {}) = True
isAlien _ = False
------------------------------------------------------------------------------
-- Object and bounding box geometrical predicates
------------------------------------------------------------------------------
-- Check if two objects touch each other.
-- Currently only a radius-based intersection test.
touches :: ObsObjState -> ObsObjState -> Bool
oos1 `touches` oos2 =
norm ((oosPos oos2) .-. (oosPos oos1)) < (oosRadius oos2 + oosRadius oos1)
-- Check if two objects are approaching each other.
approaches :: ObsObjState -> ObsObjState -> Bool
oos1 `approaches` oos2 =
(oosVel oos2 ^-^ oosVel oos1) `dot` (oosPos oos2 .-. oosPos oos1) < 0.0
-- Check if two objects are colliding.
colliding :: ObsObjState -> ObsObjState -> Bool
oos1 `colliding` oos2 = oos1 `touches` oos2 && oos1 `approaches` oos2
------------------------------------------------------------------------------
-- Constants defining various object properties
------------------------------------------------------------------------------
-- All objects are treated as round as far as intersection tests etc. are
-- concerned, but they may be drawn using a different shape. It is assumed
-- that that shape is centered around the position of the object, and that
-- its size roughly corresponds to the size implied by the object radius.
-- Constants for gun.
-- Gun: drawn triangular
gunRadius, gunBase, gunHeight :: Length
gunRadius = 25
gunBase = 2 * gunRadius
gunHeight = gunBase
gunSpeedMax :: Speed
gunSpeedMax = 500
gunAccMax :: Acceleration
gunAccMax = 500
-- Constants for missile.
-- Missiles: drawn circular.
missileRadius :: Length
missileRadius = 5.0
missileInitialSpeed :: Speed
missileInitialSpeed = 200
missileLifeSpan :: Time
missileLifeSpan = 5.0
-- Constants for alien.
-- Alien: drawn as a sphere with equatorial wing plane ("saturn-shaped")
alienRadius, alienWingRadius :: Length
alienRadius = 25
alienWingRadius = 2 * alienRadius
alienAccMax :: Acceleration
alienAccMax = 100
------------------------------------------------------------------------------
-- Support functions
------------------------------------------------------------------------------
{-
-- Old stuff
-- Bounding box is calculated once and cached inside object.
computeObjBBox :: Object -> BBox
computeObjBBox (ObjBlock {objPos = p}) = BBox (p .-^ d) (p .+^ d)
where
d = vector2 (blockSide / 2) (blockSide / 2)
computeObjBBox (ObjNSWall {objPos = p}) = BBox (p .-^ d) (p .+^ d)
where
d = vector2 (nsWallXSide / 2) (nsWallYSide / 2)
computeObjBBox (ObjEWWall {objPos = p}) = BBox (p .-^ d) (p .+^ d)
where
d = vector2 (ewWallXSide / 2) (ewWallYSide / 2)
computeObjBBox (ObjSimbotA {objPos = p}) = BBox (p .-^ d) (p .+^ d)
where
d = vector2 simbotARadius simbotARadius
computeObjBBox (ObjSimbotB {objPos = p, objHdng = d}) = BBox p1 p2
where
Point2 x1 y1 = p .+^ (vector2Polar simbotBRadius d) -- Nose
Point2 x2 y2 = p .+^ (vector2Polar simbotBRadius (d + 2*pi/3))
Point2 x3 y3 = p .+^ (vector2Polar simbotBRadius (d - 2*pi/3))
p1 = Point2 (minimum [x1,x2,x3]) (minimum [y1,y2,y3])
p2 = Point2 (maximum [x1,x2,x3]) (maximum [y1,y2,y3])
computeObjBBox (ObjBall {objPos = p}) = BBox (p .-^ d) (p .+^ d)
where
d = vector2 ballRadius ballRadius
-}