Path-finding is really an interesting topic and luckily there is loads of information available on the Internet. Implementing the algorithm, however,  is a different thing. Don’t get me wrong. The algorithm itself is pretty easy to digest. Making it fast and efficient is a bit harder. That would involve advanced data structures,  some pre calculations and probably more. Anyway, here’s what I managed to put together. It uses Vector class so FP10 is needed.

Notes about the settings

Map mode:
In this mode you can modify the tiles. White tile equals to “walkable“. Click on a tile to toggle its state.

Path mode:
In this mode you can select the starting and ending points of the path.

Use Manhattan method:
Manhattan method is a fast (thus more inaccurate) method for calculating the distance  between two points. It is the total number of squares moved horizontally and vertically to reach the target square from the current square, ignoring diagonal movement and any obstacles that may be in the way. If this option is unchecked Euclidean Method will be used instead. It is slower but better.

Use diagonal paths:
Using diagonal paths increases the calculation time but results in “more realistic paths”.

Allow cutting corners:
This is probably not acceptable in most cases.  If diagonal paths are disabled this setting will have no effect.

SOURCE FILES: astar

Useful links:

• A* Path-finding for Beginners
  If you are new to Astar this is the place to start with.

• Amit’s A* Pages
  More advanced and in depth information on A*

Don’t ask me about the name / post title .

Here is demo I made at Talvi Digital a few weeks ago. I got the idea from Audis microsite.

I guess there a few ways you can do this but here’s my solution. I did this demo by reading the models geometry (vertices) into an array. Then I mapped the points to the corresponding positions in 3D space and added the “avoid mouse” behavior. You can do pretty impressive effects with this technique.

Here a variation of the Wild Driver game demo. I guess the top-down view works much better but this is quite fun too.
Take a test drive.

Here is my variation of the well known Artillery Game. This is only a single player implementation so it’s pertty lame. But give it a try let me know what you think about it.

SOURCE: Artillery Source Files

Pedal to the metal. No cops in this town.
APE Engine is responsible for the physics.

Long story short. Here is a Shooter Demo we made at Talvi Digital at the end of this week. Boy was that fun . If only I had the time to make a real game. Well, I keep on dreaming.

I made this small app a while ago. I figured this could be useful for someone so I decided to post it here with the source. It is relatively simple so I guess no in depth explanation is needed here. However, if you are new to Zend framework I recommend watching this tutorial from Lee Brimelow.

You can also download the ZendAMF bootstrap file and other related files needed to get the application work properly. I included Sven Wageners amazing  domain.class.php script in the download. That is the place where the actual search happens.

» LIVE DEMO | » VIEW FLEX SOURCE | » DOWNLOAD AMF SOURCE

Zend Framework / Zend AMF downloads:

• The latest Zend Framework (The whole set)
• The latest ZendAMF (Only the parts needed to get remoting working)

Here is a simple feed reader app I made with Flex. It accepts RSS2.0 and Atom1.0. I included some error checking and validation to make sure that the URL or feed is valid but it could sure be better. Much better .

I used Adobes as3syndicationlib to parse the feed data so if you need more information about it go check this article. “View Source” is enabled so you can download the files and study the application. Anyway check out the demo (Feed Rider).

I found this post a few days ago and desided to try something similar. My experiment is far more simplier compared to Exey Panteleevs demo but the result is pretty goot anyway.

Click the plane to switch between water and flag.
Water/Flag demo page

And here is the source: (WaterPlaneDemo.as)

package
{
import flash.display.Sprite;
import flash.events.Event;
 
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.view.BasicView;
import org.papervision3d.materials.BitmapFileMaterial;
import org.papervision3d.events.InteractiveScene3DEvent;
 
public class WaterPlaneDemo extends Sprite
{
 
private var v:BasicView = new BasicView(800, 600, false, true);
private var plane:Plane;
private var bitmap:BitmapFileMaterial;
private var bitmap2:BitmapFileMaterial;
 
private var planeSegs:int = 12;
 
private var vertexArray:Array;
private var directionArray:Array = new Array();
private var speedArray:Array = new Array();
 
public function WaterPlaneDemo()
{
initPV3D();
addEventListener(Event.ENTER_FRAME, render3D);
}
 
private function initPV3D():void
{
 
addChild(v.viewport);
 
bitmap = new BitmapFileMaterial("water.jpg");
bitmap2 = new BitmapFileMaterial("flag.jpg");
 
bitmap2.smooth = true;
bitmap.smooth = true;
 
bitmap2.interactive = true;
bitmap.interactive = true;
 
plane = new Plane(bitmap, 1000, 668, planeSegs, planeSegs - 3);
plane.localRotationX = -90;
v.scene.addChild(plane);
 
v.camera.y = 500;
 
plane.addEventListener(InteractiveScene3DEvent.OBJECT_CLICK, changeMaterial);
 
createArrays();
}
 
private function changeMaterial(e:InteractiveScene3DEvent):void
{
if(plane.material == bitmap) plane.material = bitmap2;
else plane.material = bitmap;
}
 
private function createArrays():void
{
var dir = -1;
vertexArray = plane.geometry.vertices;
for (var i = 0 ; i < vertexArray.length ; i++)
{
	directionArray.push(dir);
	speedArray.push(Math.random() * 1.1);
	dir *= -1;
}
}
 
private function doWaterEffect():void
{
for (var i = 0 ; i < vertexArray.length ; i++)
{	
	if (Math.abs(vertexArray[i].z) > 15)
	{
		directionArray[i] *= -1;
	}
	vertexArray[i].z += directionArray[i] * speedArray[i];
}
}
 
private function render3D(e:Event):void
{
 
v.singleRender();doWaterEffect();
 
v.camera.x = v.camera.y = v.camera.z = 0;
v.camera.yaw(-.1);
v.camera.moveBackward(1000);
v.camera.y = 400;
}
 
}
}