Conway Game Engine

Improving engine exit

* src/engine.scm: Problem with ^C for aborting engine execution
                  solved.

New way for returning results from systems

* src/system: New type entities-changes that encapsulates entities
              modifications. A system that only does I/O operations
              doesn't must to return an entities-changes object.

* src/examples/composing-systems.scm: Updated example

* src/examples/making-systems.scm: Updated example

Do step duration properly

* src/engine.scm: use step start time and end time for calculating
                  delay and step duration

* src/misc.scm: new function 'current-utime' that gets current time
                in microseconds

Support for engine properties

* src/engine.scm: new functions get-property and set-property! allow
                  interaction with properties stored in entities

Composed systems return as single systems

* src/system.scm: systems created by join or threaded must return a
                  procedure for modify entities an components and must
                  be non-destructive, so alist-copy is used when modifications
                  are calculated

Repairing composing systems example

* src/examples/composing-systems.scm: used the old way of making systems with a lambda; current way is similar to let syntax

Set engine systems while running

* src/engine.scm: new function set-engine-systems! using engine mutex
                  for avoiding concurrency errors

* src/system.scm: new function group-systems, that returns joined
                  systems or an empty system, depending on arguments

Engine Execution

* src/engine.scm: Engine execution with inner properties for looping
                  delay and other future parameters. Mutexes are used
                  to prevent accessing entities and engines in an
                  undesired way.

Improving with-engine

* src/engine.scm: with-engine now saves current engine for recursive
                  calls and uses engine mutex for exclusive access

Engine Access Protocol Interface

* src/engine.scm: functions for accessing and modifying engine
                  entities, using a mutex for preventing changes
                  collission if the engine is running

* src/system.scm: now every function that modify entities returns
                  the result of the modification with the resulting
                  entities and components

Engine definition functions

* src/engine.scm: functions for creating new engines (make-engine,
  define-engine) and for working with entities and components
  inside them (with-engine)

More verbose and powerful system definition

* src/examples/making-systems.scm: Examples redefined

* src/system.scm: System definitions with more than one components grouping
  and without requiring a function directly

Replace define-macro with define-syntax

Functions to access entities and components inside systems

* src/system.scm: get-key
                  get-component

* src/examples/making-systems.scm: access functions testing

Making systems with macros instead functions. Now, we have define-system and make-system.

Better examples

More verbose mode for working with entities and components; assoc
lists no more needed

* src/system.scm: entities/components functions now return a function
                  for changing the entity/component structure

* src/test.scm: functions testing adapted to new scheme

More verbose mode for working with entities and components; assoc
lists no more needed

* src/system.scm: entities/components functions now return a function
                  for changing the entity/component structure

* src/test.scm: functions testing adapted to new scheme

Functions to merge systems, using a linear way or using threads

* src/system.scm: join-systems
                  threaded-systems

* src/test.scm: merge functions testing

It's not obligatory to write type components at declarations; if
component is a Gacela component (a special record), type is detected
automatically.

* src/system.scm: normalize-components - returns a list with pairs
  (type . component)

Making systems; systems return a lambda function for process
modifications at entities and components

* src/system.scm: set-entities

* src/test.scm: system functions testing

Making systems; systems return a lambda function for process
modifications at entities and components

* src/system.scm: set-entity
                  set-entity-components

* src/test.scm: system functions testing

Making systems; systems return a lambda function for process
modifications at entities and components

* src/system.scm: remove-entity

* src/test.scm: system functions testing

Making systems; systems return a lambda function for process
modifications at entities and components

* src/system.scm: export-component
                  new-entity

* src/test.scm: system functions testing

Making systems; preprocessing entities and components data for game
systems

* src/system.scm: find-entities-by-components
                  make-system

Structures for managing entities and components, using mutex for
future synchronization with game loop

* src/gacela.scm: entity
                  get-entity

Component definitions support using Guile records

* src/system.scm: define-component
                  get-component-type

Preparing new version 0.6

Preparing new version 0.6

Adding freeimage

Using guile-figl

Using guile-figl

Using guile-figl

New modules figl

Color management integration with meshes

Drawing circles

New picture mesh using resources cache

Texture primitive.

Primitives definition (for meshes)

Catching errors from main loop and square meshes

Meshes located at video module and new game loop procedure returning game elements

Controllers list for views

Defining views with controllers and meshes

Main loop with recursivity

Defining views

Defining views

Defining views

Defining views

Views and meshes playing together

Basic functions for working with views

Minor changes

We have stable meshes with properties, translate, rotate, turn and more.

Extensions for main loop (meshes, controllers, etc)

Implementing meshes using records

Meshes required parameters can be unspecified

Mesh Primitives Definition

Functions for playing with arguments when apply to procedures.

Changing things.

New procedure-header procedure.

Properties for meshes.

Turn and rotate meshes.

Show, hide and translate for meshes.

Defining meshes as closures.

More meshes

Defining basic meshes.

Now yes, we have views.

Introducing views

Introducing FRP concepts

Bug solved with glmatrix-block export.

New game function with its own thread.

Introducing bricks.

Fullscreen mode.

Adding SDL_GetError.

Removing not needed files.

Solved problem with Guile Autoconf macros.

Improved cache system for resources and more things.

Sprite Sheets support.

Limit to re-exports (a game must load all modules it needs).

Guybrush moves with cursors left and right

Now mobs use let*

New function to get properties of a texture.

Drawing Guybrush

Merge with 314:ebaa79d516f3

Starting a new platform game.

Only one function for mobs.

A new way of instantiating mobs.

Direct access to mob properties.

Addons to mobs.

Storing original font size.

Save font size into font smob.

Adjustments for running games from emacs or shell.

Z-index for mobs when running in 2d-mode

Asteroids using Gacela modules

Running gacela functions inside game loop thread for avoiding GL problems with threads

Collision support

Making collisions support

Mobs running with external main function

External main function for each mob (wich permits redefinition of mobs in run time)

Mobs with main functions.