MMG articles

InWeb adventures

2015-05-03T21:34:00.002+03:00

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

2013-12-07T21:11:00.000+02:00

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;
 }
}

Reflector walkthrough

2013-08-30T14:45:00.001+03:00

Particles manager from gamedev.tutsplus.com

2013-08-28T16:38:00.002+03:00

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.

Goal based vector field pathfinding in Haxe

2013-07-09T20:08:00.000+03:00

Here is nothing to say. Everything was clearly described here.
Here is jus my code in haxe implementing GBVF pathfinding class.

package com.nailedgames;

import flash.geom.Point;


typedef PathTile = {
    var x:Int;
    var y:Int;
    var step:Int;
}

class GBVF_pathfinding
{
    private var _tile_width:Int;
    private var _tile_height:Int;
    private var _field_width:Int;
    private var _field_height:Int;
    private var _field_wtiles:Int;
    private var _field_htiles:Int;

    private var _distances:Array<Int>;
    private var _vectors:Array<Point>;

    public var vectors(get,null):Array<Point>;

    public function new()
    {

    }

    function get_vectors():Array<Point>
    {
        return _vectors;
    }

    public function Init(tile_width:Int, tile_height:Int, field_width:Int, field_height:Int)
    {
        _tile_width = tile_width;
        _tile_height = tile_height;
        _field_width = field_width;
        _field_height = field_height;
        _field_wtiles = Std.int(field_width/tile_width);
        _field_htiles = Std.int(field_height/tile_height);
        _distances = new Array();
        for(i in 0..._field_htiles)
            for(j in 0..._field_wtiles)
                _distances.push(-1);

    }

    public function Calculate_field(walls_map:Array<Int>, x_block:Int, y_block:Int):Array<Point>
    {
        for(i in 0..._distances.length)
            if(walls_map[i] == 1)
                _distances[i] = -3;
            else
                _distances[i] = -1;
        Mark_tiles([{x:x_block, y:y_block, step:0}]);
        return _vectors;
    }

    private function Mark_tiles(points:Array<Pathtile>):Void
    {
        if(Lambda.empty(points))
            return;
        var neighbours:Array<Pathtile> = new Array<Pathtile>();
        for(point in points)
        {
            _distances[point.x + point.y*_field_wtiles] = point.step;
            if(point.x > 0)
            {
                if(_distances[(point.x-1) + point.y*_field_wtiles] == -1)
                {
                    neighbours.push({x:point.x-1, y:point.y, step:point.step+1});
                    _distances[(point.x-1) + point.y*_field_wtiles] = -2;
                }
            }
            if(point.x < (_field_wtiles-1))
            {
                if(_distances[(point.x+1) + point.y*_field_wtiles] == -1)
                {
                    neighbours.push({x:point.x+1, y:point.y, step:point.step+1});
                    _distances[(point.x+1) + point.y*_field_wtiles] = -2;
                }
            }
            if(point.y > 0)
            {
                if(_distances[point.x + (point.y-1)*_field_wtiles] == -1)
                {
                    neighbours.push({x:point.x, y:point.y-1, step:point.step+1});
                    _distances[point.x + (point.y-1)*_field_wtiles] = -2;
                }
            }
            if(point.y < (_field_htiles-1))
            {
                if(_distances[point.x + (point.y+1)*_field_wtiles] == -1)
                {
                    neighbours.push({x:point.x, y:point.y+1, step:point.step+1});
                    _distances[point.x + (point.y+1)*_field_wtiles] = -2;
                }
            }
        }
        Mark_tiles(neighbours);
        Assign_vectors();
    }

    private function Assign_vectors():Void
    {
        _vectors = new Array<Point>();
        for(y_tile in 0..._field_htiles)
        {
            for(x_tile in 0..._field_wtiles)
            {
                if(_distances[x_tile + y_tile*_field_wtiles] > 0)
                {
                    var left_dist:Int   = _distances[x_tile + y_tile*_field_wtiles]+1;
                    var right_dist:Int  = _distances[x_tile + y_tile*_field_wtiles]+1;
                    var up_dist:Int     = _distances[x_tile + y_tile*_field_wtiles]+1;
                    var down_dist:Int   = _distances[x_tile + y_tile*_field_wtiles]+1;

                    if((x_tile > 0) && (_distances[(x_tile-1) + y_tile*_field_wtiles] >= 0)) 
                        left_dist = _distances[(x_tile-1) + y_tile*_field_wtiles];

                    if((x_tile < (_field_wtiles-1)) && (_distances[(x_tile+1) + y_tile*_field_wtiles] >= 0)) 
                        right_dist = _distances[(x_tile+1) + y_tile*_field_wtiles];

                    if((y_tile > 0) && (_distances[x_tile + (y_tile-1)*_field_wtiles] >= 0))
                        up_dist = _distances[x_tile + (y_tile-1)*_field_wtiles];

                    if((y_tile < (_field_htiles-1)) && (_distances[x_tile + (y_tile+1)*_field_wtiles] >= 0))
                        down_dist = _distances[x_tile + (y_tile+1)*_field_wtiles];

                    _vectors.push(new Point(
                        left_dist - right_dist,
                        up_dist - down_dist));
                }else{
                    _vectors.push(new Point(0,0));
                }
            }
        }

    }
}

Here is usage example:

var tile_width:Int = 40;
var tile_height:Int = 40;
var field_width:Int = 800;
var field_height:Int = 600;
gbvf = new GBVF_pathfinding();
walls_map = [
 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,
 0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,0,0,
 0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,
 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,
 0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,
 ];
gbvf.Init(tile_width, tile_height, field_width, field_height);
var vectors:Array<Point> = gbvf.Calculate_field(walls_map, x_block, y_block);

As a result you will have array of vectors coordinates relative to the center of tiles.

Movement of a player

2013-02-26T09:23:00.000+02:00

Just my way to adjust player view depends on keys pressed.
That are indexes of our angles:

// let's define keys, which will move player (keyCode, state)

private static var keys:Array<Array<Int>> = [[37,0],[39,0],[38,0],[40,0],[69,0],[65,0],[68,0],[87,0],[83,0]];
// define array, where angles will be stored
private var angles:Array<Int>;
// adjust angles to special indexes

private function Init(e:Event):Void // Event.ADDED_TO_STAGE
{
    angles = new Array<Int>();
    angles[1] = 0;
    angles[3] = 45;
    angles[2] = 90;
    angles[6] = 135;
    angles[4] = 180;
    angles[11] = 225;
    angles[7] = 270;
    angles[8] = 315;
}


public function on_key_down(e:KeyboardEvent):Void // KeyboardEvent.KEY_DOWN
{
    for(key in keys)
        if(e.keyCode == key[0] && key[1] == 0)
            key[1] = 1;
}

public function on_key_up(e:KeyboardEvent):Void // KeyboardEvent.KEY_UP
{
    for(key in keys)
        if(e.keyCode == key[0])
            key[1] = 0;
}



public function on_enter_frame(e:Event):Void // Event.ENTER_FRAME
{
    var r_index:Int = 0;
    // up - down
    if(keys[2][1] == 1 || keys[7][1] == 1) {
        r_index += 1;
    }else if(keys[3][1] == 1 || keys[8][1] == 1){
        r_index += 4;
    }
    // left - right
    if(keys[0][1] == 1 || keys[5][1] == 1)
    {
        r_index += 7;
    }else if(keys[1][1] == 1 || keys[6][1] == 1){
        r_index +=2;
    }
    if(r_index != 0)
        this.rotation = angles[r_index];
}

What is pros of that way for me:

- you can define not only array of angles, but array of Bitmaps or Sprites

- you can redefine array of angles (Sprites) on the way without any of code overhead

- cleaner code as for me (just two if - else)

Village (map sketch 2)

2012-12-26T18:46:00.002+02:00

Village (map sketch 1)

2012-12-24T23:01:00.003+02:00

New sketches pack

2012-11-13T19:56:00.001+02:00

SimpleCache in HaXe

2012-08-30T21:06:00.001+03:00

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);

Ufo: regular ship

2012-01-23T14:02:00.001+02:00

Ufo prototypes, part 1.

2012-01-12T11:07:00.000+02:00

Wolf model

2012-01-05T10:09:00.000+02:00

Wolf model.

Неофициальный репозиторий INSTEAD игр (public beta)

2012-01-04T21:18:00.001+02:00

Вот и созрела бета неофициального репозитория INSTEAD игр.
Добавляйтесь, играйте.
Обновления и улучшения обязательно будут.
Для заливки игр вход осуществляется через google аккаунты.

Brewery game intro

2012-01-04T09:41:00.003+02:00

Intro image for my current trash-quest game.

Bear model

2012-01-04T09:29:00.003+02:00

That's bear. Enemy prototype for one of my games.

Port your game for INSTEAD to flash

2011-11-05T15:43:00.000+02:00

In this article i will show you how to port existing game for INSTEAD engine to flash app.
I will port tutorial game (tutorial3), which you can get with INSTEAD sources.

You can read about INSTEAD on its official page or on its Google Code page.

I think it's enough, so let's start.

Few words about project structure

[DIR]InsteadFlash
 [DIR]adds
  [DIR]stead // lua files of INSTEAD engine
   ...
   flash.lua
   ...
   gui_flash.lua
   ...
  [DIR]theme
 [DIR]code
  Fish.xml
  PreloaderDum.as
  [DIR]neoart
   [DIR]flod // FLOD player (.mod player for flash)
    ...
    ModProcessor.as // modified a bit (method play returns SoundTransform, added setter for soundTransform)
    ...
  [DIR]com
   [DIR]fish
    AMainClass.as
    i_Button.as
    [DIR]instead // AS3 version of INSTEAD C code
     FS.as
     Game.as
     Instead.as
     InsteadArgs.as
     InsteadCursor.as
     InsteadEvent.as
     InsteadImage.as
     InsteadLink.as
     InsteadPicture.as
     InsteadScroll.as
     InsteadText.as
     Main.as
     SaveSlot.as
    [DIR]screens // About and Pause screens
     About.as
     Pause.as
  [DIR]games
   [DIR]tutorial3 // code of the game which we will port (not modified lua files)
    main-en.lua
    main-es.lua
    main-it.lua
    main-ru.lua
    main-ua.lua
    main.lua
  [DIR]mmg
   MouseWheel.as // class to grab mouse scroll in flash
   SoundManager.as // modified class for music play (added .mod files support)

Personally we are interested in SoundManager.as, InsteadPicture.as и FS.as (some times need to modify InsteadImage.as and InsteadLink.as).

In folder games we should place our game files, such as images, sounds and lua files.
In file SoundManager.as we should embed sounds and music.
In file InsteadPicture.as we should embed images .
In file FS.as we will load lua files of our game and needed modules of INSTEAD engine.
In file InsteadImage.as and InsteadLink.as we link images, which should be displayed in text area.

Embedding of sound files (part of SoundManager.as source is hidden)

package mmg
{

import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
import flash.events.Event;
import flash.events.TimerEvent;
import flash.utils.Timer;
import flash.utils.ByteArray;
import neoart.flod.*;

dynamic public class SoundManager extends Object
{

    [Embed(source='../../adds/theme/click.mp3')]
    public static const click:Class;

    //if you want to use mp3 file, you should jut embed it
    [Embed(source='../games/tutorial3/ramparts.mp3')]
    public static const ramparts_mp3:Class;

    //if you want to use mod file, you should embed it as ByteArray

    //and create ModProcessor for it
    [Embed(source='../games/tutorial3/ramparts.mod', 
    mimeType = "application/octet-stream")]
    public static const ramparts_mod:Class;
    private static var rampartsProcessor:ModProcessor = new ModProcessor();

    private static var mus:Object;
    static public var vol:Number=0.9;
    static public var volFadeSpeed:Number=0.05;
    static public var musEnable:Boolean=true;
    static public var curMusName:String="";
    private static var curCh:SoundChannel;
    private static var offCh:SoundChannel;
    private static var curVol:Number=0;
    private static var curPos:Number=0;
    private static var offVol:Number=0;
 
    private static var isplayed:Boolean=false;
 
    private static var timerVolFader:Timer= new Timer(10);
 
    private static var t1:SoundTransform = new SoundTransform();
    private static var t2:SoundTransform = new SoundTransform();
 
    static public function init():void 
    {
        timerVolFader.stop();
        mus = new Object();

        //use that part if you are using mod files
        rampartsProcessor.load(new ramparts_mod as ByteArray);

        mus["ramparts.mod"] = rampartsProcessor;

        //use that part if you are using mp3 files
        mus["ramparts.mod"] = new ramparts_mp3();

        mus["click"] = new click();
    }
    ...
    some part of code is hidden
    ...
}
}

All sounds should be pushed to the object mus[] = {}.

Embedding of graphic files (parts of InsteadPicture.as, InsteadImage.as and InsteadLink.as sources are hidden)

package com.fish.instead
{
import flash.display.Sprite;
import flash.display.Bitmap;
import flash.events.Event;

public class InsteadPicture extends Sprite
{
    // graphic files
    [Embed(source='../../../games/tutorial3/instead.png')]
    public static const instead:Class;
    [Embed(source='../../../games/tutorial3/ru.png')]
    public static const ru:Class;
    [Embed(source='../../../games/tutorial3/ua.png')]
    public static const ua:Class;
    [Embed(source='../../../games/tutorial3/es.png')]
    public static const es:Class;
    [Embed(source='../../../games/tutorial3/gb.png')]
    public static const gb:Class;
    [Embed(source='../../../games/tutorial3/it.png')]
    public static const it:Class;
    // graphic files

    public static var gameFiles:Object = new Object();
    public var containerMid:Number = 0;
    private var hiding:Array = new Array;
    private var showing:Array = new Array;
    public var fading:Number = 0;

    public function InsteadPicture()
    {
        gameFiles["instead.png"] = new instead;
        gameFiles["ru.png"] = new ru;
        gameFiles["ua.png"] = new ua;
        gameFiles["es.png"] = new es;
        gameFiles["gb.png"] = new gb;
        gameFiles["it.png"] = new it;

        for each (var value:Bitmap in gameFiles) 
        {
            addChild(value);
            value.visible = false;
            value.alpha = 0;
        }
        this.height = 0;
        addEventListener(Event.ENTER_FRAME, DispatchPictures);
    }
    ...
    part of source code is hidden
    ...
}
}

Embed files as usual and then put it into gameFiles object. As key you should use string, which should same as path to file related to the main.lua (main file of the game)
If some of pics should be displayed in text area, you should also put them into gameFiles objects in InsteadLink.as and InsteadImage.as files.

Code of InsteadImage.as

...
public function InsteadImage(imgStr:String)
{
    gameFiles["ru.png"] = new InsteadPicture.ru;
    gameFiles["ua.png"] = new InsteadPicture.ua;
    gameFiles["es.png"] = new InsteadPicture.es;
    gameFiles["gb.png"] = new InsteadPicture.gb;
    gameFiles["it.png"] = new InsteadPicture.it;
...

Code of InsteadLink.as

...
public function InsteadLink(linkStr:String, isImage:Boolean = false, parent:Sprite = null)
{
    gameFiles["ru.png"] = new InsteadPicture.ru;
    gameFiles["ua.png"] = new InsteadPicture.ua;
    gameFiles["es.png"] = new InsteadPicture.es;
    gameFiles["gb.png"] = new InsteadPicture.gb;
    gameFiles["it.png"] = new InsteadPicture.it;
...

Embedding of game files and stead modules

Code of FS.as

package com.fish.instead
{
import flash.utils.ByteArray;
import flash.display.Bitmap;

public class FS
{
    [Embed(source='../../../../adds/stead/stead.lua', mimeType="application/octet-stream")]
    public static const stead_lua:Class;
    [Embed(source='../../../../adds/stead/gui.lua', mimeType="application/octet-stream")]
    public static const gui_lua:Class;
    [Embed(source='../../../../adds/stead/flash.lua', mimeType="application/octet-stream")]
    public static const flash_lua:Class;
    [Embed(source='../../../../adds/stead/goto.lua', mimeType="application/octet-stream")]
    public static const goto_lua:Class;
    [Embed(source='../../../../adds/stead/format.lua', mimeType="application/octet-stream")]
    public static const format_lua:Class;
    [Embed(source='../../../../adds/stead/vars.lua', mimeType="application/octet-stream")]
    public static const vars_lua:Class;
    [Embed(source='../../../../adds/stead/object.lua', mimeType="application/octet-stream")]
    public static const object_lua:Class;
    [Embed(source='../../../../adds/stead/dash.lua', mimeType="application/octet-stream")]
    public static const dash_lua:Class;
    [Embed(source='../../../../adds/stead/para.lua', mimeType="application/octet-stream")]
    public static const para_lua:Class;
    [Embed(source='../../../../adds/stead/quotes.lua', mimeType="application/octet-stream")]
    public static const quotes_lua:Class;
    [Embed(source='../../../../adds/stead/xact.lua', mimeType="application/octet-stream")]
    public static const xact_lua:Class;
    [Embed(source='../../../../adds/stead/timer.lua', mimeType="application/octet-stream")]
    public static const timer_lua:Class;
    // lua game files
    [Embed(source='../../../games/tutorial3/main.lua', mimeType="application/octet-stream")]
    public static const tutorial_main_lua:Class;
    [Embed(source='../../../games/tutorial3/main-en.lua', mimeType="application/octet-stream")]
    public static const tutorial_main_en_lua:Class;
    [Embed(source='../../../games/tutorial3/main-es.lua', mimeType="application/octet-stream")]
    public static const tutorial_main_es_lua:Class;
    [Embed(source='../../../games/tutorial3/main-it.lua', mimeType="application/octet-stream")]
    public static const tutorial_main_it_lua:Class;
    [Embed(source='../../../games/tutorial3/main-ru.lua', mimeType="application/octet-stream")]
    public static const tutorial_main_ru_lua:Class;
    [Embed(source='../../../games/tutorial3/main-ua.lua', mimeType="application/octet-stream")]
    public static const tutorial_main_ua_lua:Class;

    public static var gameFiles:Object = new Object();
    private static var _filesystemRoot:String;

    public static function filesystemRoot():String
    {
        return _filesystemRoot;
    }

    public static function Init(libInitializer:*):void
    {
        // game files
        libInitializer.supplyFile("builtin://main.lua", new tutorial_main_lua() as ByteArray);
        libInitializer.supplyFile("builtin://main-en.lua", new tutorial_main_en_lua() as ByteArray);
        libInitializer.supplyFile("builtin://main-es.lua", new tutorial_main_es_lua() as ByteArray);
        libInitializer.supplyFile("builtin://main-it.lua", new tutorial_main_it_lua() as ByteArray);
        libInitializer.supplyFile("builtin://main-ru.lua", new tutorial_main_ru_lua() as ByteArray);
        libInitializer.supplyFile("builtin://main-ua.lua", new tutorial_main_ua_lua() as ByteArray);            
        // stead modules
        libInitializer.supplyFile("builtin://goto.lua", new goto_lua() as ByteArray);
        libInitializer.supplyFile("builtin://format.lua", new format_lua() as ByteArray);
        libInitializer.supplyFile("builtin://vars.lua", new vars_lua() as ByteArray);
        libInitializer.supplyFile("builtin://object.lua", new object_lua() as ByteArray);
        libInitializer.supplyFile("builtin://dash.lua", new dash_lua() as ByteArray);
        libInitializer.supplyFile("builtin://para.lua", new para_lua() as ByteArray);
        libInitializer.supplyFile("builtin://quotes.lua", new quotes_lua() as ByteArray);
        libInitializer.supplyFile("builtin://xact.lua", new xact_lua() as ByteArray);
        libInitializer.supplyFile("builtin://timer.lua", new timer_lua() as ByteArray);
        _filesystemRoot = "builtin://";
    }
}
}

Embed needed files as usual, then put it into lua-alchemy vfs. You should make it in Init() libInitializer.supplyFile("builtin://_path_to_file_related_to_root_of_game_", new _name_of_class_of_embedded_file_() as ByteArray). I wrote about it in previous article.

I'd like to thank

Author of INSTEAD Peter Kosyh
Author of MouseWheel class Denis Kolyako
Author of lua-alchemy
Author of Flod
Author of SoundManager Oleg Antypov

Background for one of the areas

2011-10-27T13:58:00.000+03:00

Plant background

Sketches for new game

2011-10-25T16:37:00.000+03:00

Pencil drawing

Vectorized part

INSTEAD(f) v0.0.2

2011-10-03T09:46:00.000+03:00

On September 20 i've released 0.0.2 version of INSTEAD.
So, what changed? here's the list:

My own HTML-like language parser with images support
Pictures fading
Support for menu clicks action

Seems that's all, but it was a long way.
Game on Newgrounds
Game on Kongregate

INSTEAD(f) Postmortem

2011-07-12T10:22:00.000+03:00

A few days ago I released the AS3 port of engine for text-based quests INSTEAD.
So, some of the results, the difficulties encountered and future plans.
The biggest problem was to understand how supply embed files to the lua interpreter.
Much easier than I thought.
First create a class that will initialize the VFS:

package
{
    import flash.utils.ByteArray;
    import flash.display.Bitmap;

    public class FS
    {
        [Embed(source='file.lua', mimeType="application/octet-stream")]
        public static const file_lua:Class;

        private static var _filesystemRoot:String;

        public static function filesystemRoot():String
        {
            return _filesystemRoot;
        }

        public static function Init(libInitializer:*):void
        {
            libInitializer.supplyFile("builtin://file.lua",
                          new file_lua() as ByteArray);
            _filesystemRoot = "builtin://";
        }
    }
}

Then we should initialize VFS and lua interpreter:

FS.Init(LuaAlchemy.libInit);
lua = new LuaAlchemy(FS.filesystemRoot());

The problem that I could not solve is to prevent page scrolling when scroll event occurs in flash.

Also had to add some functions in lua wrapper for AS3. The list will add later.

Future plans:

implement support of INSTEAD modules;
support for pictures in the inventory and main text block;
change TextField to something better with html support.

Now the game is on:
http://www.kongregate.com/games/zaynyatyi/the-returning-of-the-quantum-cat
http://www.newgrounds.com/portal/view/574142

Billys moves. Part 1

2011-06-15T14:32:00.000+03:00

Jumping. Standing. Walking.
Oh... he is so angry.

2011-06-14T11:58:00.000+03:00

Bad Billy and his bad gun :)
New character for my game.
Also animated gif.

bp_1 diary

2011-06-01T16:01:00.000+03:00

I had one big idea in the past.
Decided to proceed with it slowly. Few hours a week.
Here will be full diary of that idea realization, cause that's mmg-groups project.

Thoughts for today:
Four main locations.

Space station.
Caves.
Hydroponics plantations.
Dump.

I haven't decided yet, will it be 3d or 2d. Most likely it will be 2d, cause i'm not such a good modeler.

"Underworld: Defense" Postmortem

2011-06-01T09:45:00.000+03:00

That was my fail. My fail - my experience.
On my portal
On newgrounds
On kongregate
Few words about internals of game.
I've decided to use Box2D for boat physics. In first versions that was 2.0.2 version, then i switched to 2.1a (boristhebrave project).
For the first time i used rater graphic for background and vector graphic for boat, buildings, connections and enemies. Performance was awful.
Then i've switched to raster graphic, but in separate objects. That was better, but not enough.
Last graphic performance tweak - use CopyPixels (and draw) method and CacheAsBitmap on vector layer (connections).