Game.GoreAndAsh.Network

The core module contains API for basic networking for Gore&Ash. The network module is built over Enet library, UDP transport with custom implementation of reliability. The API provides connection handling and basic message handling (bytestring sending and receiving).

The module depends on following core modules:

• logging - Game.GoreAndAsh.Logging

So NetworkT should be placed after LoggingT in monad stack.

The module is NOT pure within first phase (see ModuleStack docs), therefore currently only IO end monad can handler the module.

Example of embedding:

-- | Application monad is monad stack build from given list of modules over base monad (IO)
type AppStack = ModuleStack [LoggingT, NetworkT, ... other modules ... ] IO
newtype AppState = AppState (ModuleState AppStack)
  deriving (Generic)

instance NFData AppState 

-- | Wrapper around type family
newtype AppMonad a = AppMonad (AppStack a)
  deriving (Functor, Applicative, Monad, MonadFix, MonadIO, MonadThrow, MonadCatch, LoggingMonad, NetworkMonad, ... other modules monads ... )
  
instance GameModule AppMonad AppState where 
  type ModuleState AppMonad = AppState
  runModule (AppMonad m) (AppState s) = do 
    (a, s') <- runModule m s 
    return (a, AppState s')
  newModuleState = AppState $ newModuleState
  withModule _ = withModule (Proxy :: Proxy AppStack)
  cleanupModule (AppState s) = cleanupModule s 

-- | Arrow that is build over the monad stack
type AppWire a b = GameWire AppMonad a b

Low-level API

data NetworkState s

Inner state of network layer

s

- State of next module, the states are chained via nesting.

Instances

Generic (NetworkState s)

NFData s => NFData (NetworkState s)

Monad m => MonadState (NetworkState s) (NetworkT s m)

type Rep (NetworkState s)

type Host = Ptr Host

Local endpoint

type Peer = Ptr Peer

Remote endpoint

newtype ChannelID

Wrapper for channel index

Constructors

ChannelID Word8

Instances

Eq ChannelID

Show ChannelID

Storable ChannelID

data NetworkT s m a

Monad transformer of network core module.

s

- State of next core module in modules chain;

m

- Next monad in modules monad stack;

a

- Type of result value;

How to embed module:

type AppStack = ModuleStack [LoggingT, NetworkT, ... other modules ... ] IO

newtype AppMonad a = AppMonad (AppStack a)
  deriving (Functor, Applicative, Monad, MonadFix, MonadIO, LoggingMonad, NetworkMonad)

The module is NOT pure within first phase (see ModuleStack docs), therefore currently only IO end monad can handler the module.

Instances

MonadTrans (NetworkT s)

Monad m => MonadState (NetworkState s) (NetworkT s m)

Monad m => Monad (NetworkT s m)

Functor m => Functor (NetworkT s m)

MonadFix m => MonadFix (NetworkT s m)

Monad m => Applicative (NetworkT s m)

MonadIO m => MonadIO (NetworkT s m)

MonadThrow m => MonadThrow (NetworkT s m)

MonadMask m => MonadMask (NetworkT s m)

MonadCatch m => MonadCatch (NetworkT s m)

(MonadIO m, MonadCatch m) => NetworkMonad (NetworkT s m)

type ModuleState (NetworkT s m) = NetworkState s

class (MonadIO m, MonadCatch m) => NetworkMonad m where

Low-level monadic API of the core module

Methods

networkBind

Arguments

:: LoggingMonad m

=> Maybe SockAddr

Address to listen, Nothing is client

-> Word

Maximum count of connections

-> Word

Number of channels to open

-> Word32

Incoming max bandwidth

-> Word32

Outcoming max bandwidth

-> m ()

Start listening for messages, should be called once

peersConnectedM :: m (Seq Peer)

Returns peers that were connected during last frame

peersDisconnectedM :: m (Seq Peer)

Returns peers that were disconnected during last frame

networkConnect

Arguments

:: LoggingMonad m

=> SockAddr

Address of host

-> Word

Count of channels to open

-> Word32

Additional data (0 default)

-> m (Maybe ())

Initiate connection to the remote host

peerMessagesM :: Peer -> ChannelID -> m (Seq ByteString)

Returns received packets for given peer and channel

peerSendM :: LoggingMonad m => Peer -> ChannelID -> Message -> m ()

Sends a packet to given peer on given channel

networkPeersM :: m (Seq Peer)

Returns list of currently connected peers (servers on client side, clients on server side)

networkSetDetailedLoggingM :: Bool -> m ()

Sets flag for detailed logging (for debug)

networkChannels :: m Word

Return count of allocated network channels

Instances

(MonadIO (mt m), MonadCatch (mt m), LoggingMonad m, NetworkMonad m, MonadTrans mt) => NetworkMonad (mt m)

(MonadIO m, MonadCatch m) => NetworkMonad (NetworkT s m)

data Message

Message that has individual options about reliability

Constructors

Message

Fields

messageType :: !MessageType

messagePayload :: !ByteString

Instances

Show Message

Generic Message

NFData Message

type Rep Message

data MessageType

Strategy how given message is delivered to remote host

Constructors

ReliableMessage

TCP like, ordered reliable delivery

UnreliableMessage

Unrelieable, sequenced but fragments are sent with reliability

UnsequencedMessage

Unreliable and unsequenced (not sort while receiving)

UnreliableFragmentedMessage

Unreliable, sequenced sent with fragments sent within unreliable method

UnsequencedFragmentedMessage

Unreliable, unsequenced with fragments sent within unreliable method

Instances

Bounded MessageType

Enum MessageType

Eq MessageType

Ord MessageType

Show MessageType

Generic MessageType

NFData MessageType

type Rep MessageType

Arrow API

Peer handling

peersConnected :: (LoggingMonad m, NetworkMonad m) => GameWire m a (Event (Seq Peer))

Fires when one or several clients were connected

peersDisconnected :: (LoggingMonad m, NetworkMonad m) => GameWire m a (Event (Seq Peer))

Fires when one of connected peers is disconnected for some reason

peerDisconnected :: (LoggingMonad m, NetworkMonad m) => Peer -> GameWire m a (Event ())

Fires when statically known peer is disconnected

currentPeers :: (LoggingMonad m, NetworkMonad m) => GameWire m a (Seq Peer)

Returns list of current peers (clients on server, servers on client)

onPeers

Arguments

:: (MonadFix m, LoggingMonad m, NetworkMonad m)

=> (Seq Peer -> GameWire m a b)

Wire that uses current peer collection

-> GameWire m a b

Sometimes you want to listen all peers and use statefull computations at the same time.

The helper maintance internal collection of current peers and switches over it each time it changes.

Messaging support

peerMessages :: (LoggingMonad m, NetworkMonad m) => Peer -> ChannelID -> GameWire m a (Event (Seq ByteString))

Returns sequence of packets that were recieved during last frame from given peer and channel id

peerSend :: (LoggingMonad m, NetworkMonad m) => Peer -> ChannelID -> GameWire m (Event Message) (Event ())

Send message to given peer with given channel id

peerSendMany :: (LoggingMonad m, NetworkMonad m, Foldable t) => Peer -> ChannelID -> GameWire m (Event (t Message)) (Event ())

Send several messages to given peer with given channel id