gmich/gem

A cross-platform game engine with GUI and multiplayer support using Monogame, Farseer and Lidgren

gem's Issues

Create a read all properties generic method for runtime types to raise the network events

Create a debugging mechanism

Use debug flags. Debugging should be rendered and logged

Create factories with cache for each builder

Create an input utility class to handle input signals from all the monogame supported devices

Use conditionals to manage different platform builds

Create annotations for methods that get handled by the client's incoming message handler

[Client(Configuration="Default",MessageType="Shoot")]
public void Shoot(NetIncomingMessage im)
{ ........}

Move GemNetwork's configuration singletons to GemClient and GemServer

Create a mechanism for descriptions in cmd for custom commands

Example:
cmd>help
should display all the available help information

cmd>help command
should display the command specific help

Implement visitor to apply logic on the client configurations

var config = NetworkDirector[this.ActiveConfig,incomingMessage.Type,(byte)incomingMessage.ReadByte())];

ConfigurationVisitor.Handle(config);

Create an IO mechanism for xml

Create a sound handling class that takes sfx and songs

Create a command prompt for debugging

Configure line buffer overflow in the command prompt

When the text is larger than the prompt, it goes off bounds. Calculate the cmd's width and change line when exceeding

Create a base physics object

Update Shooter.Client to target .NET 4.5.2 / OpenGL / Monogame 3.3

Authorization for commands

Add caching to prevent INetworkEvent reallocation

HandleWith(this,x=> new Action(x.Do));

cache the object's name as string , and the delegate's (x.Do) name as string
also cache the whole networkConfig (eventHandler etc).

When disposing an eventHandler, the cached entry should be removed as well

For a successful lookup, the networkConfig.INetworkHandler is returned.

It shouldn't be in a hashtable or a dictionary.
Use GenericRepository. The lookup should match both entries.

Create a collidable base class for actors

Log network traffic detailed

Refactor the tile engine's networking mechanism

Handle the client-side connection approval

Update the ListView to align controls according to the specified orientation

Create a base class for incoming messages with encoding / decoding and type num

Create a communication protocol for client - server

ICommunicationProtocol : INetworkPackage

• a reserved byte
  -the deserialization in the constructor via reflection

Create an Incoming / Outgoing message workflow

Client: WithTag ("tag") / ForType (MessageType.Data) / Send(message)
Client: Dynamically create an object with a random name and a string property
Client: .HandleWith <- generic Action that applies to Send
Client: Dynamically create a method that handles objects by tag
Client: Encapsulate the object with its tag
Client: Create an object - stream converter
Client: Serialize it and add it to the Client.SendMessage event with the client's connection (for exclusion)
Server: Broadcast all incoming messages
Client: Receive message and handle it by it's tag

Create a scene management class using scene objects that inherit from IGameComponent

Create a settings class to pass to GemClient constructor

var client = new GemClient(ClientSettings.Default);
where Default is a static property that returns the default settings
OnConnecting() <-- no authorization
OnDisconnecting() <--bye bye message
etc...

Create a flexible Camera class

The camera must have multiple targets.
Al it should be able to take scripts for the movement

Create an object property finder to analyze non-primitive types that are sent via the client

Create run-time POCOs and use the activator constructor override to create objects

Creating a networking mechanism

Create a resolution handler. Also be aware of the multiple platforms and dpi

Create a map class that expands dynamicly

Align text in the Control's Region using the AlignmentContext's properties

Update the client action provider delegate to Action<IClient,NetIncomingMessage>

Configure the server and client classes

Create AnimationStrip class

Configure controls to respond to mouse events

Use WriteTime and ReadTime to calculate delta time for network messages

Enable server-side authentication

Handle network status change

Configure log4net logging

Manage resources for server disposal

Make a generic builder class to support multiple building APIs

Make it unit testable

Manage clients' connection change

Graphics device is clearing the back buffer upon assigning the Gui host target

When this occurs, everything that is drawn before the controls is being discarded

Create a basic project structure

Create a ClientNetworkInfo builder that sets up a unique object

Configuration class for client incoming message handling

• connection approval
• data
• discovery response

Test the NetworkEventBuilder API

Create particles and a particle system