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

But fear not, progress has been done. I decided to create a teaser video, this took me two evenings and was a lot of fun. While looking for music on different free sound sites I found Buba Producer on SoundCloud. This guy creates really high quality scores and shares them freely for attribution. I think that is really cool. The only “bad” thing is that the music quality is so much higher than my video.

I also had some trouble with the compression – some walls were removed when uploading to youtube. I don’t want to spend to much time on polishing the video so I will just leave it like that, and improve if I make another one in the future.

Physics

Another problem I ran into was level creation, I noticed that I needed a new game play element in order not to repeat myself. I decided to add balls that the player can push and hide in it’s shadow projection. Now creating levels was easy again.

Pushing the ball to get to the key unseen.

Another idea I’ve is to shape up the level editor and let you guys create levels and put them into the game? This will probably mean more variation.

Play it

Use ARROWS to move. Use MOUSE to throw pebbles. Use ‘R’ to restart level. Be quiet. Stay in the darkness.

You will always find the latest version under the shadowess project page.

I won’t tell you more about my ideas now. The ‘Shadowess’ page will always contain the latest version of the game (I’ll not post it in individual blog posts any longer).

CHECK IT OUT

Update:
- Random directions
- Random turn speeds
- Minor control tweak
- More levels
- A new pickup (pebbles)

Use the MOUSE for the last pickup, use ARROWS to control the bot, press ‘R’ to restart a level.

What I probably should fix:
- Bots must be able to chase player off the path grap (now the just look crazy)
- Fix different hearing distances
- Make the investigate goal less “dumb” (now everyone just runs the shortest path to the sound source)
- Perhaps add some memory to the bots (as soon as player is out of sight the just forget him)

Generating a random direction, three different algorithms

When I was going to implement this I noticed that I didn’t have any central code to create a vector in a random direction. This is something I use frequently so I decided to do a proper implementation.

Randomizing a direction can be done in many ways, but be aware: some intuitive approaches are simply wrong and doesn’t provide a uniform distribution.

Wrong: normalizing random points in a square

The first time I was doing this, I didn’t realize this until a code review. The reviewer asked me if I was aware that my code generated biased directions. It all seemed random in my testing, I replied. I guess my first draft of the code looked a bit like this:

private function createRandomDirBad():Vec2
{
	const u:Number = 2 * Math.random() - 1;
	const v:Number = 2 * Math.random() - 1;
	const l:Number = Math.sqrt(u * u + v * v);
	return new Vec2(u / l, v / l);
}

Can you see why this is skewed? This generates a random point in a square which is normalized to have length one – this means that diagonal directions will be biased because points outside the circle are “pushed” inside. The image below illustrates this bias. (Points are drawn in the circle rather than on the outline to demonstrate this)

Discarding points outside of the circle

I was quickly convinced and changed my code. I fixed it by discarding all randomly generated points outside of the circle (x*x + y*y > 1). This requires more iterations but gives an uniform distribution of points within a circle. See distribution B below.

private function createRandomDirSquare():Vec2
{
	var p:Vec2;
	while (true)
	{
		const u:Number = 2 * Math.random() - 1;
		const v:Number = 2 * Math.random() - 1;
		const s:Number = u * u + v * v;
		if (s > 1 || s < Vec2Const.EpsilonSqr) continue;
		const l:Number = Math.sqrt(s);
		p = new Vec2(u / l, v / l);
		break;
	}
	return p;
}

Here is the distribution within the circle (on the circle surface it's uniform - but not over the area):

Using trigonometry

Another method for random generation of points in a circle is to use trigonometric functions. This perhaps the most straightforward way, we just grab a random angle and create a vector in that direction:

private function createRandomDirTrigonometry():Vec2
{
	const rads:Number = Math.random() * Math.PI * 2;
	return new Vec2(Math.cos(rads), Math.sin(rads));
}

This will put points uniformly along a circle outline.

No square roots, no trigonometry

While looking around, I found a method attributed to Von Neumann. This trick allows us to generate a random direction without any use of square roots or trigonometry which can be useful if those are slow.

public static function createRandomDirKnuth():Vec2
{
	var p:Vec2;
	while (true)
	{
		const u:Number = 2 * Math.random() - 1;
		const v:Number = 2 * Math.random() - 1;
		const l:Number = u * u + v * v;
		if (l > 1 || l < EpsilonSqr) continue;
		p = new Vec2((u * u - v * v) / l, 2 * u * v / l);
		break;
	}
	return p;
}

Final note on performance

The difference from the three methods is very small, today sin and cos are mostly hardware accelerated and as it turns out in my measurements this is the fastest way to do this. So perhaps I would recommend using the one with sin and cos, if not for its performance for its simplicity.