Community for the Sphere game engine

New? Contact Us to register an account!

static duk_ret_t
js_Surface_cloneSection(duk_context* ctx)
{
	int      height;
	image_t* image;
	image_t* new_image;
	int      width;
	int      x;
	int      y;

	duk_push_this(ctx);
	image = duk_require_class_obj(ctx, -1, "ssSurface");
	x = duk_to_int(ctx, 0);
	y = duk_to_int(ctx, 1);
	width = duk_to_int(ctx, 2);
	height = duk_to_int(ctx, 3);

	if ((new_image = image_new(width, height)) == NULL)
		duk_error_blame(ctx, -1, DUK_ERR_ERROR, "unable to create surface");
	al_set_target_bitmap(image_bitmap(new_image));
	al_clear_to_color(al_map_rgba_f(0,0,0,0));//the fix
	al_draw_bitmap_region(image_bitmap(image), x, y, width, height, 0, 0, 0x0);
	al_set_target_backbuffer(screen_display(g_screen));
	duk_push_class_obj(ctx, "ssSurface", new_image);
	return 1;
}

spriteset.images[0] = someOtherImage;

spriteset.images.push(someNewImage);  // suppose this becomes the 10th image (i.e. slot 9)
spriteset.directions[0].frames[0].index = 9;

function make_sprite(name)
{
  var input  = LoadSurface("input/"+name+".png");
  
  //make the spritesets
  var output = CreateSpriteset(64, 64, 178, 21, 6);
  var a_output = CreateSpriteset(192, 192, 24, 4, 6);
  
  var t_x    = 0;
  var y      = 0;
  var x      = 0;
  var i      = 0;

  for (var y = 0; y < 21; ++y)
  {
    if(y < 4)
    {
      t_x = 7;
    }
    else if (y < 8)
    {
      t_x = 8;
    }
    else if (y < 12)
    {
      t_x = 9;
    }
    else if (y < 16)
    {
      t_x = 6;
    }
    else if (y < 20)
    {
      t_x = 13;
    }
    else
    {
      t_x = 6;
    }
    for(x = 0; x < t_x; ++x, ++i)
    {
      output.images[i]=(input.cloneSection(x*64,y*64,64,64).createImage());
      output.directions[y].frames[x].index = i;
    }
    output.directions[y].frames.length = x;
  }
  for(y = 0, i = 0; y < 4; ++ y)
  {
    for (x = 0; x < 6; ++ x, ++ i)
    {
      a_output.images[i] = input.cloneSection(x*192,1344+y*192,192,192).createImage();
      a_output.directions[y].frames[x].index = i;
    }
  }
  
  //name the directions - based on format of sheet
  output.directions[0].name   = "spell_n";
  output.directions[1].name   = "spell_w";
  output.directions[2].name   = "spell_s";
  output.directions[3].name   = "spell_e";
  output.directions[4].name   = "thrust_n";
  output.directions[5].name   = "thrust_w";
  output.directions[6].name   = "thrust_s";
  output.directions[7].name   = "thrust_e";
  output.directions[8].name   = "North";
  output.directions[9].name   = "West";
  output.directions[10].name  = "South";
  output.directions[11].name  = "East";
  output.directions[12].name  = "slash_n";
  output.directions[13].name  = "slash_w";
  output.directions[14].name  = "slash_s";
  output.directions[15].name  = "slash_e";
  output.directions[16].name  = "shoot_n";
  output.directions[17].name  = "shoot_w";
  output.directions[18].name  = "shoot_s";
  output.directions[19].name  = "shoot_e";
  output.directions[20].name  = "death";
  //attack animation directions
  a_output.directions[0].name = "North";
  a_output.directions[1].name = "West";
  a_output.directions[2].name = "South";
  a_output.directions[3].name = "East";
  
  output.save(name+".rss");
  a_output.save(name+"_a.rss");
}

var to_make = GetFileList("images/input");
for(var i = 0; i < to_make.length;++i)
{
  if(to_make[i][0]!=".")
  {
    make_sprite(to_make[i].slice(0,to_make[i].length-4));
  }
}

• Galileo exists because modern graphics hardware performs better when you tell it everything you want drawn at once.  Using the classic primitives involves a draw request for each primitive, which adds up quickly.  Essentially it's the difference between saying "Oh hey, I need you to draw this" for every primitive vs. giving the GPU a list and say "Hey, draw all of this stuff for me".  The latter is much faster because there's minimal overhead.  One practical application is in map engines (and this what FJ's map engine in TurboSphere was set up to do): You construct an entire map as a single Shape, and then just do map.draw() each frame.


• The Dispatch API is designed to set asynchronous tasks to run, independent of the normal flow of your program.  For example, the term module uses it to run itself, so that you can pull up a debug console from any place in your game--without having to remember to call its update function yourself.  As long as you're drawing frames, the Dispatch API jobs will fire on time.  See https://github.com/fatcerberus/minisphere/blob/master/assets/system/modules/term.js#L47-L51


• One of the goals I have in mind for the new map engine is to maximize the number of extension points.  The problem with the Sphere 1.x engine is that it's often not flexible enough.  It's certainly more open to extension than, say, any of the RPG Makers, but it does still get in the way sometimes, as you point out.  I want to make mine a lot more extensible so that it can be used in more scenarios.