Here is some eye candy to accompany the announcement that the official Press Kit is now online!

If you want to make a nice press kit for your game or game company, I recommend grabbing presskit() from http://dopresskit.com/ and hacking the crap out of it!

I’ve been hard at work detailing a Kickstarter project outline/proposal/vision document and I’m up to ten pages already. The rest of this week, I’ll be focused on completing the document. If all goes as planned, I’ll be back to coding the game next week! Yay!

In preparation for the Lodestar: Stygian Skies Kickstarter fund-raising campaign, I have created a website for the game. On the site, you’ll find a developer wiki for lore and game mechanics, a community forum, some small bits from the vision document, a fledgling gallery, and embedded content from this blog. Sorry, no downloads yet.

In the interim, head over to lodestargame.com and tell me what you think!

The particles now have light. I turned off the unit light in the video so the particle light can be plainly seen.

I decided to fiddle with the camera controls after all. :)

The camera is no longer restricted to 8 directions and can be lifted for a more top-down view. This is controlled with the mouse now, too.

Particles! Again, I know. A little more technical this time…

As you can see from the video, the particle origin is not completely in sync with the ‘real’ unit position. The effects are still snapping to the grid, but the framework is there! Don’t look at the bugs, look at the… Particles!

I used a simple system of assigning each particle an initial location and speed in x,y,z direction, gravity in x,y,z direction, and life. Some other variables are set in there too, like how much life is taken from the particle on each update (delta) and the master speed of the particle. I measure the life of a particle in milliseconds, and delta is milliseconds passed since last update. This is what my poison particle looks like:

public class ParticlePoison extends A_Particle {

  public ParticlePoison() {

    /*
     * Master speed
     */
    speed = 0.02f;
    rotSpeed = 0.01f;

    /*
     * Life
     */
    life -= rand.nextInt(1000);

    /*
     * Gravity
     */
    yg = 0.1f;
    
    /*
     * Initial speed
     */
    yi = 100;
    xi = rand.nextInt(2) - 1;
    zi = rand.nextInt(2) - 1;

    /*
     * Rotation speed
     */
    ys = rand.nextInt(30) - 15;

    /*
     * Size
     */
    float scale = 0.6f * rand.nextFloat() + 0.2f;

    /*
     * Initial position offset
     */
    float x = (rand.nextFloat() - 0.5f) * 5;
    float y = -3;
    float z = (rand.nextFloat() - 0.5f) * 5;

    /*
     * Make the entity
     */
    entity = new Entity(
      new SpatialCube(), 
      new TextureCube(
        Statics.TEXTURE_ATLAS_WHITE, 16, 16, 32, 32, 
          new int[] { 0, 0, 0, 0, 0, 0 }), 
      new Transform(x, y, z, scale));
    
    /*
     * Well, color me a particle...
     */
    entity.particle = true;
    entity.lightColor = new RGBA(
      0, 0.4f * rand.nextFloat() + 0.2f, 0, 1);
  }

  @Override
  public void _update(int delta) {
    
    float t = delta * 0.001f;
    float st = speed * t;
    
    /*
     * Update rotation
     */
    entity.transform.ry += ys * rotSpeed * t;

    /*
     * Update position
     */
    entity.transform.x += xi * st;
    entity.transform.y += yi * st;
    entity.transform.z += zi * st;

    /*
     * Update color
     */
    entity.lightColor.green -= 0.001f;

    /*
     * Update speed
     */
    xi += xg;
    yi += yg;
    zi += zg;

    /*
     * Update life
     */
    life -= delta;

    /*
     * Check life
     */
    if (life < 1) {
      active = false;
    }

  }

Emitters are attached to units on unit creation. Emitters can trigger themselves periodically or be triggered by external calls. Emitters ask the particle manager to add particles. The particle manager iterates through active particles, instructing to update and removing inactive particles. If too many particles are shown, the particle manager starts dropping requests from the emitters until there is room. I may add a priority to each particle that fades with time. Then older particles with less priority could be overwritten. However, that requires the particles to always be sorted by priority. Each type of particle can use its data to update itself in an independent fashion.

My mending particles store two colors, a start color and a finish color. Then, during the update, the mend particle slowly interpolates toward the finish color.

Also, I’m not restricted to using a cube as the entity, or visual representation, for the particle. A single quad can be used, or a pre-loaded VBO, such as a 3d sprite component.

On another topic, I spent too much time fiddling, trying to get some code to look nice on Tumblr. If you want to put code on Tumblr, I recommend this. However, wrap your code in <pre class=”prettyprint”></pre> only, skip the additional <code></code> nonsense.

Particles! :D

And here is a video of the two areas with the new perspective.

Again, playing with the art style. Also added randomized texture selection and rotation.

For first two shots, I made 16 stone textures that line up on all sides, randomized the rotation and selection.

For the last shot, changed up the blocky texture, with the randomized selection and rotation. Now I think I’m approaching a finalized style (3rd picture). Something in-between the dirty organic and clean blocks. Clean blocks with bits of high-contrast noise.

Feedback welcome :)