teamhypersomnia/hypersomnia

Multiplayer top-down shooter made from scratch in C++. Comes with an in-game Editor!

hypersomnia's Issues

create entity-specific callbacks

either through callback_component with registering enums or std::function or scripting

will come in handy with stupid interactions like rotating an entity to face crosshair

introduce padding in atlas to avoid linear scalling artifact

strange glitch after killing npc

for action events like shooting, remember to assign a non-loopable animation

or it will never finish and free the animation slot for lower priority animations (e.g. movement)!

introduce gun management systems: reloading, switching weapons etc.

probably another component "gun management" or so

when facing problems with resources destroying themselves in lua (perhaps temporary objects), consider using values and not pointers in C++ structures

example: renderable* animation::frame::model -> sprite

decide upon lua integration method

either luabind or own rolled bindings
http://purplepwny.com/blog/binding_lua_to_c_think_twice_before_eating_that_glue.html

create particle effects on bullet hits

blood, smoke which are just bodies on a different framebuffer with blur, wood parts etc

handle buggy script compilation results in console, sometimes duplicate compilations

create id registry to faciliate accessing from scripts and managing game state

replace config header entirely with lua functionality

introduce assemblage buckets if problems with performance

resources:
http://bitsquid.blogspot.com/2011/02/some-systems-need-to-manipulate-objects.html
http://gamedev.stackexchange.com/questions/58693/assemblage-buckets-in-entity-systems

introduce camera rotation

introduce dead area in crosshair and player movement

if you want to synchronize input with physics bodies, remember that physics runs in constant intervals

also we don't need to use settransform - movement is simulated realistically and rotation does only affect sprite
rotated sprite should act as sensor for bullets

small camera blinks when smoothing

could be repaired by restraining frame rate or kind of distance-based speed, maybe clamping values

create simple camera delayed chase demo and crosshair bounds

add messaging interface to entity systems

resources:
http://bitsquid.blogspot.com/2009/12/events.html
http://bitsquid.blogspot.com/2011/02/managing-decoupling-part-2-polling.html
http://gamedev.stackexchange.com/questions/1119/entity-communication-message-queue-vs-publish-subscribe-vs-signal-slots

bind script class

make a simple crosshair and moving around screen with collisions

replace damping with applyforce to opposite direction to achieve top speed behaviour

or just make damping more deterministic

create simple, competitive AI

purify entity systems from garbage types

serialize message classes or remember about cleaning up message queues

create high-level input interface

Create input functionality for Augmentations or provide entity system demo with one.

resource: http://www.gamedev.net/blog/355/entry-2250186-designing-a-robust-input-handling-system-for-games/
http://gamedev.stackexchange.com/questions/59582/input-management-techniques-in-large-games?lq=1
http://gamedev.stackexchange.com/questions/48315/game-state-and-input-handling-in-component-based-entity-systems
http://gamedev.stackexchange.com/questions/49119/input-handling-in-component-based-design

create script system and simple scene set up script

split render_info and renderable

renderable should have no member variables

create "simulations" in entity systems that group systems of the same timestep accumulators together

may be necessary for cases where we want to synchronize bullet's death event and receivers impulse from physics

make camera averaging frame rate independent

introduce delta accumulator class

add box2d scalling macro

let it just live inside physics component

solve memory leaks and destructor problems when reloading scripts

create a versatile clone/subscribe_state component

for overriding simple messaging-necessary dependencies like lookats, chases, animation copying

redesign entity systems to add directly from type info

remove virtuals that take type_pack as argument - it's inflexible and we can not even properly construct the components

also add an opportunity to construct components on adding - maybe placement new would solve the issue of construction/destruction

consider adding a virtual destructor to base component class - if its POD, compiler should optimize out vftables

if creating/deleting entities is slow, introduce non-processable components for event-only processing systems

add file modification detection for scripting

joint entities function in lua

create simple animation system dependent on movement speed

create topdown 2d lighting demo

http://www.dannybirch.com/simple-2d-lighting-system/
http://www.redblobgames.com/articles/visibility/

divide binding into modules to speed up compilation times

after prototyping with luabind, take a look at LuaJIT for the sake of lightweightness and performance

synchronization of death of multiple entities will come from a notification component

introduce simple gun system

find a way to elegantly handle resources and flyweights, only if running out of memory or performance

finish simple entity_system demo

Should add more functionality so the demo is more descriptive - probably high-level input, delta management.

when synchronizing physics with input, remember to set previous transform state to current

add modularised GUI to the engine or pick 3rd party to new projects

correct crosshair bug by warping cursor to center

introduce interpolation in delta accumulator

should introduce interpolation if we're going to do networking and heavier physics

resources:
http://gamesfromwithin.com/casey-and-the-clearly-deterministic-contraptions

do future step instead of interpolating with previous state: (thought: could be additional component type "futurephysicsstate" or arrays of two elements and a function touching only one at a time)

take information on how to implement double states here:
http://gamesfromwithin.com/casey-and-the-clearly-deterministic-contraptions

debug camera system with simple sprites