Fisix

Fisix engine is a verlet based physics engine. This engine is aimed towards use in games and other relatively cpu intensive real-time applications.

Free
1 Comment

motor2

motor2 is a rigid-body, iterative, impulse-based 2D physics engine for AS3 based on Box2D.

MIT
Comments Off on motor2

APE

APE (Actionscript Physics Engine) is a free AS3 open source 2D physics engine for use in Flash and Flex. Some of the features:

  • CircleParticles: fixed or non-fixed; variable mass, elasticity, and surface friction;
  • RectangleParticles: rotatable; fixed or non-fixed; variable mass, elasticity, and surface friction;
  • WheelParticles: traction and angular velocity; fixed or non-fixed, variable mass, elasticity, and surface friction;
  • SpringConstraints: stiffness; collidable or non-collidible ,collidable constraints have variable width and scale;
  • Grouping: composite class may contain Particles, and Constraints; group class may contain Particles, Constraints, and Composites;
  • Collision: multisampling; static collision tests;
MIT
Comments Off on APE

FOAM

FOAM is a 2D rigid body physics engine written in AS3. It is meant as an architectural and mathematical reference for developers interested in physics simulation in the area of game development or otherwise. It trades efficiency for modularity and extensibility.

MIT
Comments Off on FOAM

WOW-Engine

WOW-Engine is a free AS3 open source physics engine written by Seraf ( Jérôme Birembaut ) capable to handle positions in a 3D environment.

MIT
Comments Off on WOW-Engine

A* (Astar)

A* (Astar) is an AS3 implementation of A* path finding algorithm. It’s primary goal is stability. It should be able to find the path on a 1000×1000 map as well as on a 10×10 map.

MIT
Comments Off on A* (Astar)

Bold Pixel Engine

Bold Pixel Engine is a collection of classes organized in several packages, from algorithms to a fully functional blit engine and a powerful toolkit. Some of the features:

  • Collision Detection algorithm;
  • Path Finding algorithm for tiled maps;
  • Blit Engine;
  • Keycode Array;
  • Math classes such as Random and Geometry;
  • 2D Arrays;
  • States;
  • Clock control;
  • Toolkit which includes management for: music, scenes, input, saves, loops and sound effects.
MIT
Comments Off on Bold Pixel Engine

GTween

GTween is a small but extremely robust library for programmatic tweening, animation, and transitions, built by Grant Skinner of gskinner.com. It is currently comprised of 3 key classes:

  • GTween. A robust tweening engine, packed full of innovative features.
  • GTweenTimeline. A powerful virtual timeline that extends GTween to enable you to sequence tweens and actions.
  • GTweener. A static interface to GTween.

It also comes with a variety of plug-ins and easing classes.

MIT
Comments Off on GTween

Papervision3D

Papervision3D is an open source 3D engine for the Flash platform.

MIT
Comments Off on Papervision3D

CASA Lib

CASA Lib is a flexible  library designed to streamline common chores and act as a solid, reliable foundation for your projects. It provides a core set of classes, interfaces, and utilities to get you coding faster and more reliably without getting in the way.

BSD
Comments Off on CASA Lib

FIVe3D

FIVe3D (Flash Interactive Vector-based 3D) is an open source code for the conception of interactive vector-based 3D animations.

MIT
Comments Off on FIVe3D

Box2DFlashAS3

Box2DFlashAS3 (or Box2DFlash) is a free 2D physics engine ported from Box2D C++ physics engine. It is mainly designed around rigid bodies and joints, but supports a host of other features, like raycasting, or continuous collision detection.

Sample

package
{
	import flash.display.Sprite;
	import flash.events.Event;
	// Bring In Box2D
	import Box2D.Dynamics.*
	import Box2D.Collision.*
	import Box2D.Collision.Shapes.*
	import Box2D.Dynamics.Joints.*
	import Box2D.Dynamics.Contacts.*
	import Box2D.Common.Math.*

	/**
	 * ...
	 * @author Zach
	 */
	public class Main extends Sprite
	{
		private var world:b2World;
		private var timestep:Number;
		private var iterations:uint;
		private var pixelsPerMeter:Number = 30;

		public function Main():void
		{

			makeWorld();
			makeWalls();
			makeDebugDraw();

			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);

		}

		private function makeWorld():void
		{
			// Define the gravity vector
			var gravity:b2Vec2 = new b2Vec2(0.0, 10.0);
			// Allow bodies to sleep
			var doSleep:Boolean = true;
			// Construct a world object
			world = new b2World(gravity, doSleep);
			world.SetWarmStarting(true);
			timestep = 1.0 / 30.0;
			iterations = 10;

		}

		private function makeWalls():void
		{
			// Note: I am assuming a stage size of 640x400;
			// These placements will put a row of boxes around an area that size.

			// We reuse the shape and Body Definitions.
			// Box2D creates a different body each time we call world.CreateBody(wallBd);
			var wall:b2PolygonShape= new b2PolygonShape();
			var wallBd:b2BodyDef = new b2BodyDef();
			var wallB:b2Body;

			// Left
			wallBd.position.Set( -95 / pixelsPerMeter, 400 / pixelsPerMeter / 2);
			wall.SetAsBox(100/pixelsPerMeter, 400/pixelsPerMeter/2);
			wallB = world.CreateBody(wallBd); // Box2D handles the creation of a new b2Body for us.
			wallB.CreateFixture2(wall);
			// Right
			wallBd.position.Set((640 + 95) / pixelsPerMeter, 400 / pixelsPerMeter / 2);
			wallB = world.CreateBody(wallBd);
			wallB.CreateFixture2(wall);
			// Top
			wallBd.position.Set(640 / pixelsPerMeter / 2, -95 / pixelsPerMeter);
			wall.SetAsBox(680/pixelsPerMeter/2, 100/pixelsPerMeter);
			wallB = world.CreateBody(wallBd);
			wallB.CreateFixture2(wall);
			// Bottom
			wallBd.position.Set(640 / pixelsPerMeter / 2, (400 + 95) / pixelsPerMeter);
			wallB = world.CreateBody(wallBd);
			wallB.CreateFixture2(wall);

		}

		private function makeDebugDraw():void
		{
			// set debug draw
			var debugDraw:b2DebugDraw = new b2DebugDraw();
			var debugSprite:Sprite = new Sprite();
			addChild(debugSprite);
			debugDraw.SetSprite(debugSprite);
			debugDraw.SetDrawScale(30.0);
			debugDraw.SetFillAlpha(0.3);
			debugDraw.SetLineThickness(1.0);
			debugDraw.SetFlags(b2DebugDraw.e_shapeBit | b2DebugDraw.e_jointBit);
			world.SetDebugDraw(debugDraw);
		}

		private function init(e:Event = null):void
		{
			removeEventListener(Event.ADDED_TO_STAGE, init);
			// entry point
			update()
		}

		private function update(e:Event = null):void
		{
			world.Step(timestep, iterations, iterations);
			world.ClearForces();
			// Render
			world.DrawDebugData();
		}

	}

}
zlib
1 Comment

SWFConsole

SWFConsole is a free developer tool for Flash AS3 projects that gives you output in all environments, not just the IDE. For anyone who needs something like the Flash IDE Output panel (where all the trace commands go) in a web browser.

Comments Off on SWFConsole

FlashPunk

FlashPunk is a free AS3 library designed for developing 2D Flash games. Its goal is to provide you with a fast, clean framework for prototyping and developing games. Some features:

  • Framerate-independent and fixed-framerate timestep support.
  • Fast & manageable rectangle, pixel, and grid collision system.
  • Helper classes for animations, tilemaps, text, backdrops, and more.
  • Debug console for real-time debugging and information tracking.
  • Sound effect support with volume, panning, and fading/crossfading.
  • Powerful motion tweening for linear, curved, and path-based movement.
  • Z-sorted render lists for easy depth management.
  • Simple keyboard and mouse input state checking.
  • Quick & efficent particle effects and emitters.
MIT
1 Comment

Flixel

Flixel is collection of AS3 files that helps organize, automate, and optimize Flash games. Some of the features:

  • Really fast renderer (5000+ sprites on modern PCs);
  • Tilemaps;
  • Particle systems;
  • Global sound system with volume hotkeys, looping, panning, etc;
  • Parallax scrolling (free/multi-directional);
  • Built-in 2D box-based game physics (not Box2D);
  • Fast text rendering;
  • Retro style zoomed rendering options (2x pixels, 3x pixels, etc);
  • Works great with non-pixel art too, with support for rotation, scaling;
  • Composite multiple sprites using blending modes to create sweet lighting effects;
  • Does not require the Flash IDE, works best with free tools like FlashDevelop;
  • Organizational classes like game states;
  • Simple buttons;
  • Utilities for looping music and playing sound FX;
  • Simple special effects like screen flashes and fades;
  • Save game data between sessions using a local shared object.
MIT
5 Comments