Press any key to generate a new floating island. It’s fast enough that you can keep the key down and it’ll draw 30 islands per second. Fuck yeah bitmap data.

1. with

Sometimes, we need to write some very repetitive code to set the properties of an object, like a TextField or a Sprite. Instead of this:

graphics.beginFill(0x00ccff);
graphics.drawCircle(0, 0, 12);
graphics.endFill();

 … you could write this:

with (graphics)
{
	beginFill(0x00ccff);
	drawRect(0, 0, 12);
	endFill();
}

While I’m not avoiding a bajillion lines of code in this particular example, it should be enough to illustrate my point and get you thinking about all the possibilities of such a keyword!

2. Event Listeners

Sure, you may not be able to pass arguments when an Event is triggered, but don’t forget that Events themselves have various properties, including a “type“. This can be useful to avoid writing a function for every event.

// event handlers
function handler(event:MouseEvent):void
{
	if(event.type == "mouseDown")
		trace("Down");
	else
		trace("Up");
}

movieClip.addEventListener(MouseEvent.MOUSE_DOWN, handler);
movieClip.addEventListener(MouseEvent.MOUSE_UP, handler);

Bonus trick: if you have a lot of EventListeners, you could put them all in an Array/Vector and remove them all easily when the time comes. Yay efficient garbage collection!

3. Setting properties

Ever wanted to set more than one property at once, instead of each of them individually? Lookie here:

// this function sets multiple properties of an Object
function setProps(item:*, props:Object):void
{
	for (each var s:String in props)
		item[key] = props[key];
}

// for instance, to set the properties of a Sprite:
var s:Sprite = new Sprite();
setProps(s, {x:100, y:50, scaleX:2, scaleY:2, rotation:45});

Happy coding

This thing is stressful as hell.

Having worked with Spencer in the past, the whole thing went even more smoothly than I thought it would – we didn’t encounter any major issues. The game is up on Kongregate, so you should have a look! And make sure to login, if you want your score saved

Play it here!

Click the movie to set focus on it, click outside to stop firing, or look at the full-screen version right here.

Happy Independence Day, American friends

The basic idea behind creating those lightning bolts is to start with a single line, or more accurately a segment. If you spent your geometry classes playing Snake on your graphing calculators (unlike me, of course), here’s a short reminder: a segment is a part of a line bounded by two points. It’s that simple. So first, you create the segment:

Then, the trick is to get the middle point of that segment and to offset it perpendicularly a short amount, like so:

And then, you guessed it: keep going until you get enough subdivisions to suit your needs.

Now on to the code side. First, i recommend creating a Segment class, which i outlined below:

public class Segment
{
	private var start_point:Point;
	private var end_point:Point;

	public function Segment(start:Point, end:Point)
	{
		start_point = start;
		end_point = end;
	}
	public function getStart():Point { return start_point; }
	public function getEnd():Point { return end_point; }
	public function getMiddle():Point
	{
		var middle:Point = new Point();
		middle.x = (start_point.x + end_point.x) / 2;
		middle.y = (start_point.y + end_point.y) / 2;
		return middle;
	}
}

Then , create a vector of Segments to store all your lightning bolts, and create the main bolt (in the example above, it goes from the top of the movie to the position of the mouse).

var bolts:Vector.<Segment> = new Vector.<Segment>();
bolts.push(new Segment(start_point, end_point));

Then, you create two segments out of the first one, while offsetting the middle a little:

bolts.push(new Segment(bolts[0].getStart(), bolts[0].getMiddle()));

// offset the end of the previous bolt
bolts[1].setEnd(offsetTangeant(getAngle(bolts[0].getStart(), bolts[0].getEnd()), bolts[1].getEnd(), (Math.random() - 0.5) * 10);

// create the second part of the bolt
bolts.push(new Segment(bolts[1].getEnd(), bolts[0].getEnd());

My offsetting function looks like this:

// offset a point orthogonally to the tangent
private function offsetTangeant(tan_angle:Number, point:Point, offset:Number):Point
{
	point.x += Math.cos(tan_angle + Math.PI / 2) * offset;
	point.y += Math.sin(tan_angle + Math.PI / 2) * offset;

	return point;
}
// get the angle between two points (radians)
private function getAngle(p1:Point, p2:Point):Number
{
	return Math.atan2(p2.y - p1.y, p2.x - p1.x);
}

And keep going until you have enough bolts! I find that 4-6 iterations is usually enough. After you have populated the “bolts” Vector, all you have to do is draw a line between all those segments, and voila.

Stay tuned for part 2, where we will see how to add branches to that main lightning bolt!

First use this function to send a query to the PHP script:

private function sendQuery():void
{
	var variables:URLVariables = new URLVariables();
		variables.username = "Bruce Willis";

	var request:URLRequest = new URLRequest("http://yoursite.com/the_script.php");
		request.method = URLRequestMethod.POST;
		request.data = variables;

	var loader:URLLoader = new URLLoader();
		loader.dataFormat = URLLoaderDataFormat.TEXT;
		loader.addEventListener(Event.COMPLETE, querySent);

	try
	{
		loader.load(request);
	}
	catch (error:Error)
	{
		trace("Upload failed.");
	}
}

URLVariables are what you send to the PHP script. I am sending a String here, but you can send Numbers, pictures, etc.

Next, we create the URLRequest, which we will send through a URLLoader. Set the URLRequestMethod to “POST” (i will explain why later) and give the request whatever data it should send (our previously created variables).

Then, create the URLLoader (you can send the request to the constructor, or leave it blank and load it like i did below). I like to set the DataFormat to “TEXT”, but this is not always necessary. Add an EventListener to that loader, so that you can execute a function when the request was completed. And finally, load the request! I use a “try / catch” statement in case there is an issue, and trace out whatever error message you want.

Then comes the function that is called when the loader is complete:

private function querySent(e:Event):void
{
	if (!e.target.data)
		trace("No data back");

	else
		trace("The most awesome actor is: " + e.target.data);
}

 This one is simple: when the loader is complete, it first checks to see if any data came back from the request (line 3). If so, it traces the data you sent (in this case, “Bruce Willis”).

Here is the PHP script, called “the_script.php” and saved on your website.

<?php
/**
* @author: Maxime Preaux
*/

// get the variable from AS3
$name = $_POST["username"];

if (!$name)
{
	echo("no data sent from Flash");
}
else
{
	echo($name);
}

?>

First, a PHP script starts with “<?php” and ends by closing that tag: “?>”.

Then, I declare the variable like so: “$name”. It’s that simple. Then, I assign the value of $_POST["username"] to that variable. In PHP, you can either use “GET” or “POST” to send data to a script. The “GET” method actually writes the data in the browser bar, whereas the “POST” method keeps it hidden. In our case, either method would work.

Make sure that ["username"] matches the variable sent from AS3 (see line 4. of the first AS3 script).

After that, we check to see if $name has a value. If it got the data from AS3 correctly, it should! Otherwise, it will send “no data sent from Flash” back to your program. But if all works correctly, it will send the value of username back to you using the “echo()” function.

And that’s it! You now know how to send and get data from AS3 and PHP!

If you have any questions or better ways to do this, please post in the comments below

Brotherhood was a bit of a let-down on the solo side: at various points throughout the campaign I had no clue what was going on in the storyline, because I was busy doing side missions and increasing my income, and I had to play the game twice to understand the plot. The multiplayer, though, was incredible. Totally mind-blowing. But I’d like to focus on the solo experience rather than the multiplayer.

AC:Revelations is freaking beautiful. The graphics of Istanbul and its inhabitants are breathtaking. Gone are the days when there were a limited number of skins the NPCs could have; now I don’t even recall seeing twice the same person. You can swim, you can jump higher and farther, you can grab weapons from enemies and cave their face in with maces and warhammers, you can craft bombs of your own choosing, you can send your assassins abroad to level them up, and call upon them when in need. There are so many tiny details, side-stories and character biographies that game feels historically accurate and Ezio seems to belong to this believable world.

But Revelations could and should have learned from the series’ past mistakes, like AC2 did. The first thing that bothers me is the combat system. All you ever have to do is parry, and sometimes shoot from your handcannon to kill those Janissaries. Sure, you can kick, grab, headbut, through sand in the enemies’ faces, but nothing is as effective as parrying a blow and slicing the enemy’s throat. This has not changed since the very first game, and in my opinion makes Ezio/Desmond/Altair feel very week. I have been playing a lot of Arkham City recently, and that got me thinking that if AC drew some ideas from the Free Flow combat system, the game would be twice better immediately.

Next up: the HUD and the way information is presented to us, the players. The fact that we know the game is a simulation of Desmond’s ancestors’ memories gives Ubisoft the freedom to give us in-game information through white-over-black text. This does not bother me, and I think it is a clever piece of game design that gives them a lot of options and freedom without sacrificing immersion. But when I see that the game talks to me about NPCs and “resume the game” and similar pieces of (sometimes useless) information, it immediately takes me out of the experience. Why would you talk about NPCs? I don’t want to be reminded I’m playing a game when I’m fully immersed in the story and the incredible details of the city!

Third thing that bothers me (and a lot of my friends) is the freaking Tower Defense mini-game Ubisoft put in. Like, seriously, what the hell? Don’t take me wrong, I LOVE TD, I still have Warcraft 3 installed just so I play TD on Battle.net. But the way they implemented TD in AC:R is just lame. First, the camera sucks, and it’s really hard to get a good notion of what is going on. Second, where the hell do you get all those assassins with all this cool gear, when you can only call upon say ten of them to go on missions and all? To win this mini-game, all you have to do is spam assassins all over the rooftops and then spam some more. No depth, no fun. It really feels like an unfinished experience that Ubisoft threw in just to say “hey look, we can do that!”.

Fourth, and that’s not new from AC:R but from Brotherhood, is the “memory-completion percentage” bullshit. Basically, if you don’t complete the missions EXACTLY like the game tells you to, you’ll only get 50% completion. What I think they tried to do with that is make you feel like you had to complete the memories exactly like your ancestor did, and I guess this is an okay argument. But what is so thrilling about this series is that you have a shit-ton of options to deal with each situations: you can rush in recklessly and take out all opposition with your sword and dagger, you can kill each guard silently and finally get your target when it is isolated and alone (so gratifying!), and all the things that go in-between (poison darts, calling assassins, using mercenaries/thieves, hiding on benches/haystacks, etc.) So why would Ubisoft give us all those amazing options and then tell us that we only use one?! It’s like giving a kid Legos and telling him he is only allowed to build one thing!

All in all, Revelations is a great game, and the amount of work involved in it is just phenomenal. I am not trying to hate on the studios and the people that made this game happen, I just someone at Ubisoft will read this and take my humble opinion into consideration when working on AC3. Ubisoft learned from their mistakes and the progress made between the first and the second game in the series blew my mind at the time, and I don’t think any game has ever evolved that fast.

So Ubisoft, please make AC3 as great as AC2 was in comparison to AC, and I will love you eternally.

First, ask yourself: is your project fast enough? Do you really need to make it faster? Computers keep getting faster, and while books teach you that using a float instead of a double will make a world of difference, it is not really the case unless you go through countless iterations of a loop.

Final advice before we get to the juicy part: do not optimize until you are close to being done and everything works correctly, or it will be a pain to make changes later. That being said, here is what I know about AS3 optimization.

1. Use uints and numbers only when you have to! With the current version of the player, integers are almost twice as fast as unsigned ints. Numbers are just slightly slower than uints.

2. Stacked operators are slow!

if (a && b && c) // slower

// faster
if (a)
{
	if (b)
	{
		if (c)
		{
		}
	}
}

3. “for each” is really convenient… and hundred of times slower than “for”

// slow...
for each (var s:String in array)

// fast!
for (var i:int = 0; i < array.length; i++)

4. Declare variables before loops! For instance, if you use a “for” loop to go through a large array or vector, you should avoid accessing that array’s “length” property more than once, like below. Also, avoid declaring variables within a loop.

var max:int = array.length
var i:int;
for (i = 0; i < max; i++)
{
	// do stuff
}

5. Point.distance() is slower than computing the Euclidian distance between two points (see below). Also, using Math.pow() is slower that multiplying a number by itself.

d = Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));

But trivial matters aside, this semester is indeed promising, as I have begun to work on a new game! I can’t release many details as of now, but know that it features “a system that procedurally generates and modifies the game level at runtime to better match players’ varying skill levels and playstyles.”

Sounds smart, eh? It is a really abstract system that may well turn HAL9000 on us!

Keep checking back for updates…