Merge branch 'release/0.3'

More keyboard events

Merge tag '0.2' into develop

0.2

Merge branch 'release/0.2'

Merge branch 'feature/event_driven_programming' into develop

Customizing quit event behaviour

Write window declarations using a syntax

Change import-bitmap with bitmap

Window scene

Quit game support

Reorganize examples

Hello world example

Images in development

Images in development

Fran example using scenes

Root file for the module

Primitive game loop with some basic scenes

Some maths

Environment for execution without previous installation

Scene type and basic functions

Environment for execution without previous installation

First reactive example

Interface for guile-opengl and particle system example

Trash

Tests for entities and components

* tests/entities.scm: Tests for creating entities

Adding REPL cooperative server to the engine loop

* src/engine.scm: Function start-engine has an optional socket parameter
                  for starting a REPL and accessing from an external
                  thread

Experimenting with syntax

* games/asteroids/asteroids.scm: Experimenting with syntax for games

More declarative way of making games

* src/examples/asteroids.scm: Declarative asteroids game

* src/game.scm: Functions renamed to a more declarative way, erasing
                'make-'

Preparing skeleton for engines, systems, etc

* engines/arcade.scm: First engine for developing arcade games

* examples/asteroids.scm: Asteroids game, with two ways of make a game

* game.scm: New structure that contains the engine and all the entities
            with their initial state

* systems/opengl.scm: First system for displaying entities using opengl
                      libraries

Components with similar headers to functions

* src/system.scm: Support to #:optional and #:key when defining new
                  components with define-component

Entity sets and engine api through systems

* src/system.scm: entities and components in a cons-pair of two hash
                  tables and systems returning entities changes
                  directly

* src/engine.scm: modifying an engine is possible only using systems
                  and each system modify engine entities when runs

* src/examples/entity-componentfunctions.scm,
  src/examples/making-systems.scm,
  src/examples/composing-systems.scm,
  src/examples/engine-conway-game.scm:
        modifications for correct execution with the new state of art

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