bitbucket.org/espinpro/go-engine

go-engine

This is framework for make all kind of games

ECS using

This framework support entity component system architecture. For make new component, you must make new file and fill it with attributes and methods, then, you are able to make new entity, and just embed you component into this entity.

For example:

type NameComponent struct {
    name string
}

func NewNameComponent(name string) *NameComponent {
    return &NameComponent{
        name: name,
    }
}

func (n *NameComponent) SetName(name string) {
    n.name = name
}

func (n *NameComponent) GetName() string {
    return n.name
}

And using like here:

type Dog struct {
    *NameComponent
}

func NewDog(name string) *Dog{
    return &Dog{
        NameComponent: NewNameComponent(name),
    }
}

After this, you are able to use it like here:

d := NewDog("Jack")
d.SetName("Honey")
name := d.GetName()

System this is something what is able to change entities in time. For example if we want to change something by game ticks. For make new system, you must make new file for this system, add method EntitiesKeys (will return what keys we are going to affect from registry), and Update(ctx context.Context) (will be called each tick), and after that, we must registry this system in game, also, probably you want to make interface for entities what you are going to use. After that, this system will be called in each tick, and update entity.

For example:

type Buildable interface {
	UpdateProgress()
}

type BuildSystem struct {
}

func NewBuildSystem() *BuildSystem {
	return &BuildSystem{}
}

func (b *BuildSystem) EntitiesKeys() []interface{} {
	return []interface{}{options.TypeFleet, options.TypePlanet}
}

func (b *BuildSystem) Name() string {
	return "build_system"
}

func (b *BuildSystem) Update(ctx context.Context) {
	for _, key := range b.EntitiesKeys() {
		g := registry.Default().GetGroup(key).GetGenerator()
		for e := range g {
			b, ok := e.(Buildable)
			if !ok {
				continue
			}
			b.UpdateProgress()
		}
	}
}

Making new server

For make new server you must prepare custom handler. This handler must implement Server interface. Methods: - GetRouters() ([]*Route, []*Route) - return two types of router. First this is full router, for handle this routes, request path must be same with given pattern, second this is global routes. For this routes we check only “contains” part. For example global pattern “/s”, will be called for “/s”, “/s/abc/abc” and so on. - GetSignalsListeners() SignalListener - return signal and it handler - ErrorHandler() func(w http.ResponseWriter, r *http.Request, status int) - default handler for all errors types - SetClose(close func() error) - set close callback. Here we will set default close callback for server. (must be called in Close function manually) - Close() error - close, will be called on shutdown function, or if we receive not caught panic

Also, for use server, we must have special Game instance. Expected to implement single method - InitPlayer.

Registry

This is our custom in memory storage. Support different indexes like Spatial, SkipList, Hash Map. and demoralized by groups.

Version convention

Each release have version: vX.Y.Z or vX.Y.Z-T.N

Where: - X - major changes (broke incompatibility); - Y - minor changes (add new feature with compatibility), safe for migrate from y to highest y; - Z - hot-fix or path (this is very small changes, without new features); - T - can be beta or alpha - N - contains incremental number for beta and alpha releases

For example, next examples is correct:

• v1.0.0-alpha
• v1.0.0-beta
• v1.0.0-beta.1
• v1.0.0-beta.2
• v1.0.0
• v1.0.1