I realize that this blog post is not very detailed but rather should give you an idea of how shadow geometries can be generated. I may do a follow up with code in the future.

My goal was to create faster 2d shadows than I had previously done. To do this I use the GPU for the rendering.

Background

First I naturally tried to use Away3d built in shadow casting system. However after adding only a few light sources I got an error message “register overflow”. After reading up on the away3D forums I came to the conclusion that it’s not built for many dynamic lights. Also it’s 3d shadows and 2d shadows would suffice for me.

Secondly I tried to use shaders as described here. This is probably performance effective, as calculations are done on the GPU. However, after fiddling around for an evening or two I felt that my shader skills weren’t sufficient and I didn’t really have time to learn. So I moved on…

Finally I decided to generate light geometries (disc) that had the shadows carved out. This seemed like a good solution for me, since I knew I could to it technically and it was just a matter of writing the code. I was a bit worried that it would be slow to upload new geometries all the time, but it turned out that it was not any problem.

Generating light geometries

The algorithm to generate the light geometries is simple and straight forward. However, to be honest, I had to spend a lot of time to patch up some corner cases. E.g. when triangulating around the 360 degrees I needed to make sure that the first point and last point fit. In fact all problems I had was due to fiddling in polar coordinates (angles). If I was to rewrite it, I would try to stay in vector space.

Here is a broad outline of the algorithm:

Imagine a light source with some scattered boxes around it as seen below. Each wall has two corner points, that acts as “outposts” for the shadow casting of the geometry. From now I will call those extreme points of the wall. This is demonstrated here, the white line in the wall acts as shadow caster line stretching between the two extreme points:

When we have calculated those points, we shoot rays through them to see if the rays hit a wall near wall  (the point is occluded by a wall) or a far wall (projects shadow on another wall) or not at all (shadows ends at light radius). We store this information per point in a list.

Now we sort the new list with points clockwise or anti clockwise w.r.t. the light source. Now we just go through the list and draw triangles, some will follow walls, other will extend all the way to the light endpoint.

This is demonstrated here:

And here with more walls:

Now we just need to apply a light material to the geometry and we are done, also set blend mode to add!

And with 30 walls and 20 lights (many optimization can still be done):
]]> http://www.playchilla.com/dynamic-hard-shadows-in-2d/feed 4 http://www.playchilla.com/experimental-chatbot http://www.playchilla.com/experimental-chatbot#comments Sat, 15 Dec 2012 19:32:33 +0000 Jon http://www.playchilla.com/?p=881 Chat with the bot

Click to chat with the bot. Read on for some technical info.

Background

Last spring I started working on a chat bot. I downloaded a dump of wikitionary and let the bot read it. From that it created a two graphs. One graph with syntactic rules (VERB->PREPOSITION->NOUN etc). The second graph could be searched to find associations between words (finding a path between ‘socialism’ and ‘color’ could generate: ‘socialism’->red’->’color’ etc).

It did show pretty cool behavior sometimes. But it had no idea how to answer to ‘How are you?’.

So the next step would be to add some everyday chat data into the mix. It turned out that it was very hard to find any public chat data that I could use for this. This is probably due to privacy issues. Even though I did find some corporas they were all not clean enough (e.g. IRC rooms with many people). I wanted peer to peer plain chat logs and gigabytes of them.

Then I ran into a chat bot called Cleverbot, and I was amazed how well it worked on every day phrases. So I though, I would try to do something similar to collect chat data for my bot.

Try chatting to Ve here.

Gamification of the chatting

On top of that I quickly wrote a flash client with a simple visualization of the bots ‘brain’. The more particles – the smarted bot. Particles actually doesn’t relate to the number of nodes (phrases) but rather to the strength of relationships in the graph.

What I really would want to do with the client is to gamify it, so that the user gets rewards from chatting to it and leveling it up. Sort of becoming a part of the development of the bot (just as parents feel involved with their kids are learning). Not there yet – this is just a preliminary test to reveal what I need to fix to make the model working.

Server

I had a good idea of how to build such a system, but wasn’t sure how to store the graphs so I entered ‘graph database’ into Goolge and Neo4j showed up, after reading up a bit I decided to give it a try. Using it went as a breeze. Usually when I deal with SQL databases it really gives me a headache. It’s really frustrating to think in rows in column for many problems. Neo4j suited my problem exactly and within hours I had it up and running. Each node is a phrase, and relations are the next phrase in a chat transcript. Relations are strengthen only when humans walk the path. Also there are prediction relations that points more then one node ahead. This will give the another hint of how to branch as a function of the context.

No content filter yet

I’ve not written any content filter yet so it will probably be rude say really ugly things and try to offend you. Don’t take it personally – it’s just those internet trolls thinking they are funny.

Slow?

I’m running it on a free Amazon Micro instance with very limited memory and CPU – so if it’s slow, don’t be surprised.

Try chatting to Ve here.

Last weekend I wrote the new lightning system (hard dynamic 2d shadows for Stage 3D). I will probably write a little post on how i did this when I get time. This weekend I started the port and I was surprised how far it got. Since levels will be larger and richer I decided to start with a random level generator just to have something to play with.

Here is the result so far. Beware of general ugliness, most meshes/colors are placeholders – this is the first port version

Controls
WASD – Move (Up/Down arrows also)
ARROWS – Turn (QE)
SHIFT – Move slowly

Mouse control is not implemented yet. Be patient while loading (1.5MB)

Anyways, I finally pulled my self together to participate. I decided to sleep all I needed and not stress. In total I put 8h + 13h into the making. Today was a bit stressful. But I am happy that I can go to bed soon.

The things I didn’t have time to finish was for the player to upgrade the ai of the unselected cells (now they are just randomly walking around). For the evil cells there are four behaviors RandomWalk, FindFood, FindBooster and FindEnemy. Cells are created with a random combination of those. I didn’t have time to add a AvoidDanger behaviour either. Also, I wanted to add a laser gun for the surprise.

I was inspired by a game called Osmos. And I used the same “material spitting out when moving” effect as they did (since I loved it so much). As of the mechanics I think cell.evolve is different since you split cells and control a whole army against many competing ais. To avoid being mixed up I should probably put it in a different atmosphere and not added the farts.

The theme is ‘Evolution’ and here is my contribution called cell.evolve (2 MB – be patient):

Complete a level by: Divide into 5 (by eating) and terminate all evil cells

- Click on the blue cell to and click where you want to move
- Eat food and boosters (speed + metabolism)
- Avoid ugly stuff (poison, evil cells)
- ESC toggles menu
- SPACE restarts level
- R restarts from level 1

Graphics, SoundFx (generated in as3sfxr), Music (generated in WolframTone) and code by me. (I love being able to tell I’ve made the music even though I just pulled some sliders).

Over and out, also here is the source code.

Anna did this sketch

Here is what I will do:
- spend Easter in Paris with Anna, Philip & Louise
- twisting tracks
- looping tracks
- more weird ambient background stuff
- better lightning
- levels in different difficulty
- random levels
- high score
- an infinite track with where you can see how far people have run (markers along the track)
- hardest part: find a good name for the game
- possible to make own levels with json?

This list should be doable in reasonable time, something for me to do in the evenings and on weekends.

PLAY IT HERE

Here is a little running game I made this week, it’s a one button game. I came across a cool game called Fotonica and thought I would make a similar using the same control (only space). I wanted the character to be a female and get a bit of the feel from Mirrors Edge (so far I only managed to add some female sounds).

The 10 levels are randomly generated and not tweaked at all, some might not be finishable? If you finish a level you will snap to the start again.

Anyways, try it here: (no loader, you may have to wait a while)

Runner has moved to here.

Music by 7OOP3D song called Triggernometry (instrumental version)

If I continue with this game I will probably make the track twist and bend, just like in the olden c64 Stunt Car Racer which I used to play a lot when I was young. But I thought I would start simple just making a forward track where segments differs in height. Also I might bring in some Tiny Wings action, timing landings with downhills to get more speed.

I’m specifically looking for feedback on the bead putting interface/controls as I want it to be as good as possible, also I want it to apply to touch screens which means some extra limitations (I had to scrap the bead piles that was in the first version). I’ve tested the latest prototype on my phone and it works alright. All the menus and icons are mock ups so don’t go mental on them.

To get more feedback I added a “leave feedback” box in the editor, this saves users the trouble of registering on the blog etc.

This is what I did:

I’m calling it ‘Beadly’ for now. I don’t if that is going to be the final name.
]]> http://www.playchilla.com/beadly-prototype-2/feed 0 http://www.playchilla.com/beads http://www.playchilla.com/beads#comments Sun, 26 Feb 2012 18:43:49 +0000 Jon http://www.playchilla.com/?p=701 Yesterday I was at a dinner, when we arrived we had to choose a beermat for our drinks. All beermats where customized for the guests and you had to figure out which one was yours. For me it was really simple (unfortunately I broke it):

The next day I woke up with an urge to implement a digital bead creator. Actually the idea to this came from my my girlfriend Anna and her friend Matilda who did a cool artsy project a year ago. They had the idea of doing something interactively with digital beads. Check out the I bead you project.

Also I have wanted to try out flash GPU support for some time but never gotten around to do it so I decided to strike two flies in one hit (as we say in Sweden). This was very easy and I only ran into one problem: The GPU support didn’t work at all at first. After an hour of browsing and reading forums I decided to try update my device drivers and viola, there where more triangles than I could count. I looked around a bit for a 3D engine to use and finally went with Away3D 4 beta. It was really easy to use. Here is the result (you can’t save your creations or anything so screenshot it if you want to keep).

Latest change list 17/3/2012
- Added mock up menus, new UI, feedback box

I have a cool idea on some expansions of this, not sure if it’s possible to do yet.. more on that later.

This is what Anna did:

As you unlock levels you also unlock new towers and upgrades on previously unlocked towers. I’m not entirely sure how to make all this self explanatory yet. Also, it feels like the game is missing something, it feels kind of stiff. Not sure what exactly. I like the simple graphics and I don’t wont to spend to much time on that, but it might be that enemy movements are too much moving along a rail. I might make that more organic in a future version.

Thanks to everyone who is testing it and leaving feedback!

Try it here and let me know what you think!

Level Format

I managed to remove all xml formats and convert them to json and build the editor in game. This means I can actually edit levels while playing them. It was totally worth the effort. I converted the xml because json is so much simpler and lightweight.

If anyone is interested this is how the level format looks:

{
	"name": "Algorithmic",
	"uid": "r2_algorithmic",
	"mapPos": [0, 0],
	"mapSize": [12, 12],
	"numberOfLives": 10,
	"seed": 5,
	"energy": 120,
	"easyWaves": 10,
	"mediumWaves": 20,
	"hardWaves": 30,
	"waveInterval": {"init": 7, "add": -0.2, "min":3},
	"level": {"init":1, "add": 0.4, "mul": 1.05},
	"waveSizeDef": {"init":5, "add":0.5},
	"waitDef": false,
	"waves":
	[
		{"queue": ["Xor"]},
		{"queue": ["XorSpeed"]},
		{"queue": ["Xor", "XorSpeed"]},
		{
			"wait": true,
			"size": {"init": 1, "add": 0.2},
			"queue": ["XorBoss"]
		}
	],
	"allowedTowers": ["bullet", "slow"],
	"tilesData": "sssssssssssssssspppsssssssssppppssssssspptppsssssssppttppsssssppprpppssssspptrrtppssspptppptppssspprpppprppsppttpppttppspptptpptptpprrpprrrpprpp",
	"overlayData": "00000000000000000x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b00000000000000000000000000000e"
}

On top of this I added an tree based EditView that allows me to edit instantiated level object on the fly. This was boring to do since it involved so much UI program (which I really dislike). On the right in the image below you can see the palette, all the different tiles and overlays (bases, entrances and exits). I think now it’s gonna be fun to create levels.

I will include the level editor when it is usable for and has less bugs.

New level & laser towers

So I built a level in my new editor and added a new tower type: Laser Towers. Those shoots beams through one or more enemies giving mass damage. Place it carefully to hit as many as possible.

Now go and play the new level here! Remember to leave feedback on what sucks and needs to be improved (and what you like).

Feedback is appreciated

This is a first test in order to get some feedback on controls and game play and the general feel of the game. Please comment if you try it out.

Toplist and ads

I also added a top list to make it a little bit more fun. At first I designed an own high score system (on paper) then, in order to save time, I decided to use an already made API. After some hours of reading I wasn’t any wiser on what system to use so I decided just to pick one that looked decent (sometimes it’s more efficient to just try stuff in practice than trying to figure them out in theory). I ended up with mochi media. I wanted to turn off the ads, at least during development but it seems that I had no such option.

As I final note my record has already been broken, a player “fghj” managed to stay alive for 33 waves vs my 27.

PLAY IY HERE

I found this puzzle a lot of fun and decided to create a dedicated game. The objective is to move over all tiles without getting trapped. Select a starting point then choose a direction in which the tiles will be lit all the way until a wall is hit, then select a new direction. You can’t move through yourself so you need to make sure you don’t get trapped.

Last weekend was extra long and that was the time span I sat out to do this within.

Initial development

I started by created a level format, I kept it simple and used a char matrix to describe the board. Then I implemented a simple view on this that drew rectangles in different colors. And on top of this I added the ability to move over tiles. This was all straight forward and playable within a couple of hours.

Level Generation

Once I could actually play some test levels I went ahead and wrote a level generator. This was also pretty straight forward and very brute force. The only thing I had to put some effort in was the difficulty calculations so the levels could be categories into easy, medium and hard. I ended up using the number of choices needed to solve a puzzle going the easiest way (fewest moves). Another thing that I had to do was to remember to throw away duplicates, to do this I mirrored and rotated each solvable to make sure every level was unique. Totally more than 300 levels are used for the game. All in all I probably spent 10 hours on this.

Adding some nice graphics

Once this was done, the boring programming was left. Building some kind of menu, making games save, showing dialogs upon level completion or failure. This took the rest of the time. Anna did some cool buttons and tiles for the game to make it look better. This probably took 20 hours. All the fiddling with mouse overs etc. Phew.

Name: Touch All Puzzle

For now the game is available for free in the Android market. The name is “Touch All Puzzle”. I’m not very happy with the name, but it will do. I will make an IOS and flash version as well.

Whats next

Also I would like to experiment with monetizing it as well. This is something I am really bad at. I’ve written free software for 15 years now but starting to feel that some money would be nice.

I though I would write up how I did this, much for my own sake (haven’t fiddled with this in a long time) and as they say repetition is the mother of all knowledge. You can skip to the bottom part to get the code directly. Also sorry for not using a proper font for math symbols. At least I tried to be consistant, * is the dot product and for scalar multiplication I didn’t use the mul sign (e.g. st).

These are the variables:
v = enemy velocity
p = enemy position in relation to tower (enemyPos-towerPos)
s = bullet speed
t = the time of impact (unknown – what we want to find out)

Now assuming that the enemy will continue in its path we can calculate where to shoot to get a hit.

The first equation we set up is:
|p+vt| = st

This happens when the distance from the tower to the bullet and enemy is the same. You can think of p+vt as a point along a line, starting at the enemy pos (p) and extending in the direction of its velocity (v) as the time (t) grows. The |p+vt| simply means the distance (from the tower) of a point on the line at a given time. st is the distance the bullet have traveled after t time units (remember distance = time * speed).

What we want to do is to find out the time (t) when they are at equal distances. To solve it we need to rearrange the expression a bit. Remember that |v| = sqrt(v*v) (* = dot product), in order to “free” t from its walls |p + v * t| we start by squaring both sides:

|p+vt|^2 = s^2t^2

Freeing t out of the distance operator (|):
|p+vt|^2 = sqrt((p+vt)*(p+vt))^2 =
(p+vt)*(p+vt) =
p*p + 2p*vt + v*vt^2 = s^2*t^2

Now we set it up as a quadratic equation just as we learnt in school.

v*vt^2 – s^2t^2 + 2p*vt + p*p = 0

(v*v – s^2)t^2 + 2p*vt + p*p = 0 (This is the quadratic form ax^2 + bx + c = 0).

Now we only have to solve it, so we plug it into the olden equation:

t1 = (-b + sqrt(d)) / 2a
t2 = (-b – sqrt(d)) / 2a

where d=b^2-4ac

There are two possible solutions to quadratic equations. The factor inside the sqrt is called the discriminant, d, and reveals information about the solutions, a positive d means we have two real solutions, if d is zero there is only one solution and if it’s below zero we have complex solutions this means that we don’t have anyway of hitting the enemy (enemy moving away faster than bullet).

a = v*v – s^2

b = 2*p*v

c = p * p

This is basically what I implemented, than after I got the solutions I returned the lowest positive t via some ugly if statements. I wasn’t really happy with this so I kept looking around and ran into  slembcke’s post ‘leading target‘, in addition to illustrating the equations nicely with graphs he points out that we can use the alternate quadratic formula if we only are interested in the first possible time of impact (works when there is a positive solution).

t = 2c / (-b+sqrt(d))

After unittesting this bad boy I felt pretty comfortable that it was what I was looking for, even though I haven’t proved it for myself. One thing to keep in mind is that this will return 2c/0 (division by zero) if  sqrt(d)=b, this happens when the enemy is moving away at the exact  speed as the bullet, in one of the towers axis (the bullet can’t catch up nor fall behind). I solved this by checking if the t == Infinity, if so I handle it just as if there are no solutions (negative t).

Another small improvement that  James McNeill pointed out is that you can cancel the 2 factor in b. As for this aiming problem we get 2*p*v for our b factor, squaring this in d (b*b) , gives us sqrt(4(pv)^2 – 4ac) => 2 * sqrt((pv)^2 – ac) so now we can cancel the 2 in the top 2c.

The equation we end up with is:

a = v*v – s^2

b = p*v (removed the 2 factor)

c = p * p

d = b*b – ac (removed the 4 factor)

t = c / (sqrt(d) – b)

Here is AS3 source code to calculate how to aim on a moving target:

private function _getToi(targetDir:Vec2Const, targetVel:Vec2Const, bulletSpeed:Number):Number
{
	const a:Number = targetVel.lengthSqr() - bulletSpeed * bulletSpeed;
	const b:Number = targetDir.dot(targetVel);
	const c:Number = targetDir.lengthSqr();
	const d:Number = b * b - a * c;
	if (d <= 0) return -1;
	return c / (Math.sqrt(d) - b);
}

Once you have the time of impact, you check if it’s negative or infinity – if so there is no firing solution. Otherwise you can easily calculate the aim position or direction by interpolating from the enemy position in by it’s velocity scaled by the time:

public function getAimPos(shooterPos:Vec2Const, targetPos:Vec2Const, targetVel:Vec2Const, bulletSpeed:Number):Vec2
{
	const targetDir:Vec2Const = targetPos.sub(shooterPos);
	const toi:Number = _getToi(targetDir, targetVel, bulletSpeed);
	if (toi == -1 || toi == Infinity) return null;
	return targetPos.add(targetVel.scale(toi));
}

As a final note, I assumed that the shooters (towers) are standing still, you can easily modify this by adding a shooterVelocity and pass the relative velocity to the _getToi method.

Some time ago I ported a c implementation of a Naiver-Stokes fluid simulation to AS3 and I thought I should share it. It’s all based on this paper ‘Real Time Fluid Dynamics for Games‘ from by Joe Stam. If you want to understand the details about this I suggest you read it, or look around on the web. But the concept is to  set up a velocity and density field to which you add external velocities and densities. For each update you solve the velocities by iterating over the grid and then move the densities accordingly.

On top of that I added some balls that you can play around with by moving a ball with the mouse, it’s visually not very impressive but it should give an idea of what you can do with it.

It seems like the flash bottleneck is the memory access (all the _v[index] etc), I think using Alchemy for memory access would speed it up a lot, and you could probably do really cool simulations. If you decide to try it, let me know how it works!

Use the method ‘getDensities’ for rendering (just iterate it and plot it). Here is the AS3 code for the fluid solver:

package com.playchilla.algorithm.fluid
{
	public class FluidSolver
	{
		public function FluidSolver(
			width:int,
			height:int,
			solveIterations:int,
			diffusion:Number,
			viscosity:Number)
		{
			_width = width;
			_height = height;
			_solveIterations = solveIterations;
			_diff = diffusion;
			_visc = viscosity;

			_n2 = _width * _height;
			_size = (_width + 2) * (_height + 2);
			_d = _createArr();
			_d0 = _createArr();
			_u = _createArr();
			_v = _createArr();
			_u0 = _createArr();
			_v0 = _createArr();

			_rowAdder = _width + 2;
		}

		public function update(dt:Number):void
		{
			// Add sources from previous to current (last += new)
			_addSource(_u, _u0, dt);
			_addSource(_v, _v0, dt);

			// Diffuse new with old
			_diffuse(1, _u0, _u, _visc, dt);
			_diffuse(2, _v0, _v, _visc, dt);

			// Project velocities onto new velocities
			_project(_u0, _v0, _u, _v);

			// enforce new velocities to uv
			_advect(1, _u, _u0, _u0, _v0, dt);
			_advect(2, _v, _v0, _u0, _v0, dt);

			_project(_u, _v, _u0, _v0);

			// Density step
			_addSource(_d, _d0, dt);
			_diffuse(0, _d0, _d, _diff, dt);
			_advect(0, _d, _d0, _u, _v, dt);

			for (var i:int = 0; i < _size ; i++)
				_d0[i] = _u0[i] = _v0[i] = 0;
		}

		public function getDensities():Vector.<Number> { return _d; }
		public function addDensity(x:int, y:int, amount:Number):void { _d0[_index(x,y)] += amount; }
		public function addVelocity(x:int, y:int, velocityX:Number, velocityY:Number):void
		{
			const index:int = _index(x, y);
			_u0[index] += velocityX;
			_v0[index] += velocityY;
		}
		public function setVelocity(x:int, y:int, velocityX:Number, velocityY:Number):void
		{
			const index:int = _index(x, y);
			_u0[index] = velocityX;
			_v0[index] = velocityY;
		}
		
		public function getWidth():Number { return _width; }
		public function getHeight():Number { return _height; }
		
		private function _addSource(x:Vector.<Number>, s:Vector.<Number>, dt:Number):void
		{
			for (var i:int = 0; i < _size; ++i)
				x[i] += dt * s[i];
		}
		
		private function _diffuse(b:int, x:Vector.<Number>, x0:Vector.<Number>, diff:Number, dt:Number):void
		{
			const a:Number = dt * diff * _n2;
			_linearlySolve(x, x0, a, b, 1 + 4 * a);
		}

		private function _linearlySolve(x:Vector.<Number>, x0:Vector.<Number>, a:Number, b:Number, c:Number):void
		{
			for (var k:int = 0; k < _solveIterations; ++k)
			{
				for (var j:int = 1; j <= _height; ++j)
				{
					var current:int = j * _rowAdder;
					for (var i:int = 1 ; i <= _width; ++i)
					{
						++current;
						x[current] =
							(x0[current] +
							a *
							(x[current-1] +
							 x[current+1] +
							 x[current-_rowAdder] +
							 x[current+_rowAdder])) / c;
					}
				}
				
				_setBnd(b, x);
			}
		}
		
		private function _advect(b:Number, d:Vector.<Number>, d0:Vector.<Number>, u:Vector.<Number>, v:Vector.<Number>, dt:Number):void
		{
			const dt0:Number = dt * _width; // FIX
			for (var j:int = 1; j <= _height; ++j)
			{
				const current:int = j * _rowAdder;
				for (var i:int = 1 ; i <= _width; ++i)
				{
					++current;
					const x:Number = Math.min(Math.max(i - dt0 * u[current], 0.5), _width + 0.5);
					const y:Number = Math.min(Math.max(j - dt0 * v[current], 0.5), _height + 0.5);
					
					const i0:int = int(x);
					const i1:int = i0 + 1;
					const j0:int = int(y);
					const j1:int = j0+1;
					
					const s1:Number = x - i0;
					const s0:Number = 1 - s1;
					const t1:Number = y - j0;
					const t0:Number = 1 - t1;
					
					d[current] = s0 *
						(t0 * d0[_index(i0, j0)] +
						 t1 * d0[_index(i0, j1)]) + s1 *
						(t0 * d0[_index(i1, j0)] +
						 t1 * d0[_index(i1, j1)]);
				}
			}
			_setBnd(b, d);
		}
		
		private function _project(u:Vector.<Number>, v:Vector.<Number>, p:Vector.<Number>, div:Vector.<Number>):void
		{
			for (var j:int = 1; j <= _height; ++j)
			{
				var current:int = j * _rowAdder;
				for (var i:int = 1; i <= _width; ++i)
				{
					++current;
					div[current] = -0.5 *
						(u[current+1] -
						u[current-1] +
						v[current+_rowAdder] -
						v[current-_rowAdder]) / _width; // FIX /_N

					p[current] = 0;
				}
			}

			_setBnd(0, div);
			_setBnd(0, p);
			_linearlySolve(p, div, 1, 0, 4);

			for (j = 1; j <= _height; ++j)
			{
				current = j * _rowAdder;
				for (i = 1 ; i <= _width; ++i)
				{
					++current;
					u[current] -= 0.5 * _width * (p[current+1] - p[current-1]);
					v[current] -= 0.5 * _height * (p[current+_rowAdder] - p[current-_rowAdder]);
				}
			}

			_setBnd(1, u);
			_setBnd(2, v);
		}
		
		private function _setBnd(b:int, x:Vector.<Number>):void
		{
			for (var i:int = 1; i <= _height; ++i)
			{
				x[_index(0, i)] = b==1 ? -x[_index(1, i)] : x[_index(1, i)];
				x[_index(_width+1, i)] = b==1 ? -x[_index(_width, i)] : x[_index(_width, i)];
			}
			
			for (i = 0; i <= _width; ++i)
			{
				x[_index(i, 0)] = b == 2 ? -x[_index(i, 1)] : x[_index(i, 1)];
				x[_index(i,_height + 1)] = b == 2 ? -x[_index(i, _height)] : x[_index(i, _height)];
			}
			
			x[_index(0, 0)] = 0.5 * (x[_index(1,0  )]+x[_index(0  ,1)]);
			x[_index(0, _height + 1)] = 0.5 * (x[_index(1, _height + 1)] + x[_index(0 , _height)]);
			x[_index(_width + 1, 0)] = 0.5 * (x[_index(_width, 0)] + x[_index(_width + 1, 1)]);
			x[_index(_width + 1, _height + 1)] = 0.5 * (x[_index(_width, _height + 1)] + x[_index(_width+1, _height)]);
		}

		private function _index(x:int, y:int):int {	return x + y * _rowAdder; }

		private function _createArr():Vector.<Number>
		{
			const arr:Vector.<Number> = new Vector.<Number>(_size, true);
			for (var i:int = 0; i < _size; ++i)
				arr[i] = 0;
			return arr;
		}
		
		private var _solveIterations:int;
		private var _diff:Number;
		private var _visc:Number;
		private var _width:int;
		private var _height:int;

		private var _n2:int;
		private var _size:int;
		private var _rowAdder:int;

		private var _d:Vector.<Number>; // dens
		private var _d0:Vector.<Number>; // prev dens
		private var _u:Vector.<Number>; // vel x
		private var _u0:Vector.<Number>;
		private var _v:Vector.<Number>; // vel y
		private var _v0:Vector.<Number>;
	}
}

Merry Christmas!

I want to create a sandbox Tower Defense game instead of a linear. Here are two key features I am adding:

1) Physics. Shoot creeps with big canons and knock them off their path, even make them fall of the map.

2) Behaviors. Creeps can posses different behaviors. So far I’ve implemented a behavior to avoid incoming artillery fire, this looks really cool – shooting into a group scatters it as they are fleeing all over. Another behavior is to avoid towers by taking advantage of a weighted graph they can find their way to the goal exposing themselves to as little danger as possible. More to come.

Also I created a little level editor in which I can draw maps using a hexagonal layout. I will not spend so much time on graphics instead focus on the game play. Your objective is to protect your “souls” which the creeps try to steal. I’ve a story line for this in the back of  my head as well, but that’s for the future.

Here is a first screenshot to show you the progress. This level has allows 2 types of towers, a normal canon and a slow tower, creeps enter at the bottom right and exits in the top. I’ve built a windy path for them to follow.

There are many good things that have come out of this side project, I have a pretty robust testbed for AI, goal selection, astar, physics integration etc.

TRY IT HERE

This is all crude, and the graphical theme will probably be refined. I’ve set a kind of dark setting, perhaps on an occupied space ship. I will probably add some little background story to it at some point to make it more interesting.

Well try it and let me know what you think can improve. Any info on levels that are too hard or easy is important.

TRY IT HERE