InWeb adventures

Today i decided to start my new small project.
I will create web-based game - some sort of multiplayer survival game (something like die2nite).

I will use haxe for it.
Will try to make it using:

• ufront
• jive

So, that's it, in short words.

Usage of particle manager

So, here is a little how-to for subject.
First you need ParticleManager instance in your class (smoke for example)

smoke = new ParticlesManager(1000, ParticleState.Update_particle, true);
emitterPosition = new Point(stageWidth + 40, stageHeight / 3);
addChild(smoke);

Then in some loop of your game (EnterFrame?) you have to emit particles

var speed_x:Float = -20 * (Math.random()) - 20;
var speed_y:Float =  14 * (Math.random()) - 7;
var state:ParticleState = new ParticleState(new Point(speed_x, speed_y), 1);
smoke.Create_particle(Assets.getBitmapData("assets/round_20.png"), 
 new Point(emitterPosition.x, emitterPosition.y),
 0xff0000ff, 30, new Point(0.1, 0.1), state, 0, 0.2, 0.04); // look at ParticleManager code for params description

As you can see, you need ParticleState class for particles

package;

import flash.geom.Point;
import particles.Particle;

class ParticleState
{
    public var velocity:Point;
    public var lengthMultiplier:Float = 0.0;
 
 public function new(velocity:Point, lengthMultiplier:Float)
 {
  this.velocity = velocity;
  this.lengthMultiplier = lengthMultiplier;
 }
 
 public static function Update_particle(particle:Particle):Void //here you have to define how particles move
 {
  var vel:Point = particle.state.velocity;
  particle.position.x += vel.x;
  particle.position.y += vel.y;
  particle.bitmap.scaleX += (1 - particle.bitmap.scaleX) * particle.sizeReduction;
  particle.bitmap.scaleY += (1 - particle.bitmap.scaleX) * particle.sizeReduction;
  particle.bitmap.alpha -= particle.fading;
 }
}

Particles manager from gamedev.tutsplus.com

Made simple implementation of Particles manager for my game based on this article.
Here is Source code for it.

ParticlesManager.hx

package mmg.particles;
package particles;

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.geom.Matrix;
import flash.geom.Point;
import flash.geom.Rectangle;
/**
 * ...
 * @author gordev
 */
typedef Action = Particle -> Void;

class CircularParticleArray
{
 private var _start:Int;
 private var _list:Array;
 private var _targetClass:Class;
 private var _args:Array;
 
 public var start(get, set):Int;
  public function get_start():Int { return _start; }
 public function set_start(value:Int) { _start = value % _list.length; return 0; }
 public var capacity(get, never):Int;
 public function get_capacity():Int { return _list.length; }
 public var list(get, never):Array;
 public function get_list():Array { return _list; }
 public var count:Int = 0;

 public function new(targetClass:Class, initialCapacity:Int, args:Array)
 {
  _targetClass = targetClass;
  _list = [];
  _args = args;
  
  for (i in 0...initialCapacity)
        {
   _list.push(Type.createInstance(_targetClass, _args));
  }
 }
 
 public function get(i:Int):T
 {
  return _list[(_start + i) % _list.length];
 }
 
 public function set(i:Int, value:T):Void
 {
  _list[(_start + i) % _list.length] = value;
 }
}

class ParticlesManager extends Sprite
{
 private var update_particle:Action;
 private var particle_list:CircularParticleArray;
 
 public function new(capacity:Int, update_particle:Action, isDisplayList:Bool) 
 {
  super();
  this.update_particle = update_particle;
  particle_list = new CircularParticleArray(Particle, capacity, []);
  if(isDisplayList)
  {
   for(particle in particle_list.list)
   {
    addChild(particle.bitmap);
   }
  }
 }
 
 public function Create_particle(texture:BitmapData, 
  position:Point, 
  color:UInt, 
  duration:Float, 
  scale:Point, 
  state:Dynamic, 
  theta:Float = 0, 
  sizeReduction:Float = 1,
  fading:Float = 1):Void
 {
  var particle:Particle;
  if (particle_list.count == particle_list.capacity)
  {
   // if the list is full, overwrite the oldest particle, and rotate the circular list
   particle = particle_list.get(0);
   particle_list.start++;
  }else{
   particle = particle_list.get(particle_list.count);
   particle_list.count++;
  }
  
  // Create the particle
  particle.texture = texture;
  removeChild(particle.bitmap);
  particle.bitmap = new Bitmap(texture);
  addChild(particle.bitmap);
  
  particle.position = position;
  particle.color = color;
  particle.duration = duration;
  particle.percent_life = 1.0;
  particle.scale = scale;
  particle.bitmap.scaleX = scale.x;
  particle.bitmap.scaleY = scale.y;
  particle.orientation = theta;
  particle.state = state;
  particle.sizeReduction = sizeReduction;
  particle.fading = fading;
 }
 
 public function Update()
 {
  var removal_count:Int = 0;
  var index:Int = 0;
  for (i in 0...particle_list.count)
  {
   var particle:Particle = particle_list.get(i);
   update_particle(particle);
   particle.percent_life -= 1.0 / particle.duration;
   Swap(particle_list, index - removal_count, index);
   if (particle.percent_life < 0) removal_count++;
   index++;
  }
  particle_list.count -= removal_count;
 }
 
 public function Draw(canvas:Bitmap)
 {
  canvas.bitmapData.fillRect(canvas.bitmapData.rect, 0x00000000);
  for (i in 0...particle_list.count)
  {
   var particle:Particle = particle_list.get(i);
   var origin:Point = new Point(particle.texture.width / 2, particle.texture.height / 2);
   var mat:Matrix = new Matrix();
   mat.translate(particle.position.x - origin.x, particle.position.y - origin.y);
   canvas.bitmapData.draw(particle.texture, mat); //and so on
  }
 }
 
 public function Move()
 {
  for (i in 0...particle_list.count)
  {
   var particle:Particle = particle_list.get(i);
   particle.bitmap.x = particle.position.x - particle.bitmap.width  * 0.5;
   particle.bitmap.y = particle.position.y - particle.bitmap.height * 0.5;
  }
 }
 
 public function Swap(list:CircularParticleArray, index1:Int, index2:Int):Void
 {
  var temp:Particle = list.get(index1);
  list.set(index1, list.get(index2));
  list.set(index2, temp);
 }
 
 public function RenderBitmap(canvas:Bitmap):Void
 {
  Update();
  Draw(canvas);
 }
 
 public function RenderDisplayList():Void
 {
  Update();
  Move();
 }
}

Particle.hx

package particles;

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.geom.Point;

/**
 * ...
 * @author gordev
 */
class Particle
{
 public var texture:BitmapData;
 public var bitmap:Bitmap;
 public var position:Point;
 public var origin:Point;
 public var orientation:Float;
 public var scale:Point;
 public var color:UInt;
 public var duration:Float;
 public var percent_life:Float;
 public var state:Dynamic;
 public var fading:Float;
 public var sizeReduction:Float;
 
 public function new()
 {
  bitmap = new Bitmap();
  scale = new Point(1, 1);
  percent_life = 1.0;
 }
}

I will write about usage and step by step description later.

SimpleCache in HaXe

Made SimpleCache class based on Ant.Karlov tutorial using HaXe.
Here is class code:

package mmg;

class SimpleCache<t>
{
    public var instance(get, never):T;

    private var _targetClass:Class<t>;
    private var _currentIndex:Int;
    private var _instances:Array<t>;

    public function new(targetClass:Class<t>, initialCapacity:Int)
    {
        _targetClass = targetClass; // Base class of all of objects
        _currentIndex = initialCapacity - 1; // Index of current free object
        _instances = []; // Array of all instances

        // Fill it up
        for (i in 0...initialCapacity)
        {
            _instances[i] = getNewInstance();
        }
    }

    private function getNewInstance():T
    {
        return Type.createEmptyInstance(_targetClass);
    }

    private function get():T
    {
        if (_currentIndex >= 0)
        {
            // Returning free object from cache
            _currentIndex--;
            return _instances[_currentIndex + 1];
        }
        else
        {
            // If cache is empty we should create one more instance
            return getNewInstance();
        }
    }

    private function put(instance:T):Void
    {
        _currentIndex++;
        // If cache is overfilled
        if (_currentIndex == _instances.length)
        {
            // We should put instance to the back of the instances array
            _instances[_instances.length] = instance;
        }
        else
        {
            // Putting instance to the free cell of array
            _instances[_currentIndex] = instance;
        }
    }
}

Usage example:

// init cache
var cache:SimpleCache<ourobjectclass> = new SimpleCache(OurObjectClass, 50); 
// take on of instances
var tmp:OurObjectClass = cache.instance; 
tmp.doSomething();
// put object back to cache
cache.put(tmp);