Earl and I just hammered out a weird issue in some code that involved Brownian motion. Check this out, assuming p is a MovieClip on the stage:

addEventListener(Event.ENTER_FRAME, animate);

function animate(e:Event):void {
    p.x += Math.random() * 2 - 1;
    p.y += Math.random() * 2 - 1;
}

Seems simple enough, right? The particle p should move randomly, and produce what is called “Brownian motion.” It should wander, but ultimately stay within a general area, on average.

However, if you let it run long, you’ll find the particle tending to gravitate to 0, 0. If you’re impatient, you can speed up the process like this:

addEventListener(Event.ENTER_FRAME, animate);

function animate(e:Event):void {
    for (var i:int = 0; i < 100; i++) {
        p.x += Math.random() * 2 - 1;
        p.y += Math.random() * 2 - 1;
    }
}

After trying quite a few things, we eventually tried the following:

addEventListener(Event.ENTER_FRAME, animate);

var realX:Number = p.x;
var realY:Number = p.y;

function animate(e:Event):void {
    realX += Math.random() * 2 - 1;
    realY += Math.random() * 2 - 1;
    p.x = realX;
    p.y = realY;
}

Again, you can wrap that up in the loop to speed things up.

Either way, you’ll notice that we get proper motion now. What gives?

Well, the suspicion that lead to us trying that was confirmed when we added a trace:

addEventListener(Event.ENTER_FRAME, animate);

var realX:Number = p.x;
var realY:Number = p.y;

function animate(e:Event):void {
    realX += Math.random() * 2 - 1;
    realY += Math.random() * 2 - 1;
    p.x = realX;
    p.y = realY;

    trace(realX, p.x);
}

You’ll see something like this:

310.60525778401643 310.6
311.387398567982 311.35
312.1899666218087 312.15
311.5306175108999 311.5
311.22865250799805 311.2
311.0907105393708 311.05
310.28716491162777 310.25
309.4788754032925 309.45
309.128194604069 309.1
308.98307433445007 308.95
309.23653392959386 309.2
308.6192215178162 308.6
309.3771039834246 309.35

Check that out! The x property (and the y, too, we checked) is rounded internally to the nearest .05. Actually, it’s not even rounded, it’s floored (my assumption is that it’s just truncating some bits resulting in a floor effect, which would presumably be a faster operation that Math.floor).

So, basically, we’re talking about rounding errors that, when piled up, result in a gradual approach to 0. For example, say you start at 10. You generate your random number, and it’s -1.46. You take x property of 10, subtract 1.46, and you’d expect to end up at 8.54. Instead, you end up 8.5. Confirm it with the following code:

p.x = 10;
p.x += -1.46
trace(p.x);
trace(10 - 1.46)

A similar effect happens with positive numbers…you end up smaller than you think you will. Thus, a gradual approach to 0.

The fix involves tracking a high-precision Number value as the “real” x and y, and adding to that. Then, simply assigning that value to the MovieClip’s x and y still results in rounding, but without any cumulative effects. Anyone else remember the similar problem from ActionScript 2 days with _alpha?

My theory is that since there is a finite precision to Numbers, we’d still see a gradual approach to 0, only it’ll take MUCH longer.

So, I’m not necessarily pointing the finger at Adobe here and saying this is a bug; this is clearly intentional behavior, and 99% of the time you don’t even notice. But when you do have that situation where it matters, you need to know about it.

Hey guys and girls,

my project this semester made me search for a way to get transparency out of a video-file in Actionscript 3. Thanks to nice guys in a flash-forum (forum’s thread) I found a nice solution:

var tmp:BitmapData = new BitmapData(100,100);
tmp.draw( Video(getChildByName("video")) );
var alpha:int = tmp.getPixel32(event.localX,event.localY);

I was using PHP and curl as proxy to get some xml files from Basecamp for my Flex UI to consume and was successful (something like “return $response   = curl_exec($session);“. But after I refactored my little php functions into an object/class and included it in another delegation file, it suddenly stopped working. In Flex, I got the following error for the HTTPService fault event:

faultCode:Client.CouldNotDecode
faultString:’Error #1088: The markup in the document following the root element must be well-formed.’
faultDetail:’null’

In Firefox 3.5, the output XML file looked ok. But both Safari and IE gave error messages: There was an “*” in front of the <?xml ..?> header in Safari source code view; while IE gave the following error:

Invalid at the top level of the document. Error processing resource

After comparing the files before refactoring and the one after, I noticed that the refactored one was encoded in UTF-8 while the old one was in ANSI. After I converted my class file into ANSI, XML output became normal in all three browsers.

BTW, I used Notepad++. Not sure if that was an issue.

Anyhow, lessons learned: Make sure the source files are encoded in ANSI.

Any comments and thoughts are welcome!

I just read this article from the team behind WordPress.

And I just wanted to test it out with a small chunk of code from my recently created Flash platform game.

		private function checkKeysDown (event:KeyboardEvent):void
		{
			if(event.keyCode == 37 || event.keyCode == 65) 			// A or Left Arrow
			{
				leftKeyDown = true;
				rightKeyDown = false;
			}

			if(event.keyCode == 38 || event.keyCode == 87) 			// W or Up Arrow
			{
				upKeyDown = true;
			}

			if(event.keyCode == 39 || event.keyCode == 68) 			// D or Right Arrow
			{
				rightKeyDown = true;
				leftKeyDown = false;
			}

			if(event.keyCode == 72 && !mainJumping) 				// H key
			{
				hKeyDown = true;
				sc4 = attack.play();
			}

			if(event.keyCode == 74 && !mainJumping) 				// J key
			{
				jKeyDown = true;
				sc4 = attack.play();
			}

			if(event.keyCode == 75 && !mainJumping) 				// K key
			{
				kKeyDown = true;
				sc4 = attack.play();
			}
		} // end private function checkKeysDown

Seems like it works wonderfully, I don’t know why I haven’t checked this functionality out before now. But I can see a lot of uses for this seeing as I’ve recently learned a lot of ActionScript 3.0 and will start learning more HTML and CSS in the following courses I have. Expect more posts consisting of code-strings in large amounts!

One awesome thing with this “plugin” is that it supports a lot of different programming languages; meaning that the plugin can color-code different syntaxes with various colors typically found within the language. It’s brilliant.

To insert code like this you simply write:

[*sourcecode language="css"]
your code here
[*/sourcecode]

Without the wildcard (*)

If you don’t define the source code language it will be “text” by default (no syntax highlighting). Here’s a list of the supported languages

• actionscript3
• bash
• coldfusion
• cpp
• csharp
• css
• delphi
• erlang
• diff
• groovy
• javascript
• java
• javafx
• objc
• perl
• php
• text
• powershell
• python
• ruby
• scala
• sql
• vb
• xml

Here’s the support post for the Source Code tagging.

There is no need to block (using braces to wrap) single line statements in a control flow (as-if, do-while, for/while); and you can mix blocks and non block statements together like this:

if(num > 0)
trace(num+” is positive;\n”);
else if(num <0)
{
trace(num+” is negative.”);
trace(num+” don’t be negative;\n”);
}
else if(num == 0)
trace(num+” is neutral;\n”);

This applies to all the control statements although the example here is just of if/else .

With this being said, The Elements of C# Style recommends Always us block statements in control flow constructs. Reason one is that it makes it easy to add additional statements in it; reason two is it’s easier to read than those without blocks.

Talk about figuring out something the hard way, I had to add print functionality to a flash advent calendar and upon testing in a browser began printing pages that would first print what I was expecting but then added a lovely black box at the bottom of the page. I had added a white background box to the page at the beginning but after much beating my head came to realize that it just wasn’t long enough and the printer interpreted the empty space as black, I extended the white box and voila! page prints only the items I want and no more black box. I’d seen a few posts about this with no solution so hopefully this helps someone else out there beating their heads over something silly.

I must say that at the moment I know almost nothing about 3d, and I’m starting with the beginner tutorials. So far I’ve seen three flash 3d engines:

Away3D – a powerful, widely-used and good looking 3d engine, free to use.

http://away3d.com

Papervision3D – a clean, fast, popular 3d flash engine.
http://blog.papervision3d.org/

Alternativa3D – probably the most powerful 3d engine in flash, created by russian programmers, which is still in development. However, it won’t be free.
http://alternativaplatform.com/ru/alternativa3d/

That’s it for now.

Have a nice day everyone!

It may not be obvious until you actually make the mistake and spend half a day trying to find the miscalculation in what you thought was an intuitive use of flash’s built in tools. DisplayObjects have the getBounds method, allowing you to quickly retrieve a Rectangle object containing size and location properties pertaining to that object in relation to any other display object, whether on the stage or not. Passing a reference of a clip into its own getBounds method returns a rectangle complete relative to itself, very handy for quickly retrieving an object’s dimensions.

Be careful, however, because using this method of retrieving an object’s dimensions is very relative. When asked for dimensions relative to itself, a DisplayObject will return unscaled values. So if you’ve rescaled a MovieClip on the stage and plan to quickly pass around its size dimensions, you’ll be better off creating your own Rectangle than relying  on getBounds, especially when there’s a possibility that the object is not its original width or height.

Furthermore, it may be dangerous in a dynamic situation to simply getBounds against the object’s parent, and the object’s root property is only valid if the clip is somewhere on the stage. In these situations it may be best to either go through the extra motions of constructing your own rectangle or only use object.getBounds(object) when you’re positive the object is not scaled.

var square:Sprite = new Sprite();
addChild(square);
square.graphics.beginFill(0x0000FF);
square.graphics.drawRect(0,0,100,100);
square.graphics.endFill();
square.x = stage.stageWidth/2 - square.width/2;
square.y = stage.stageHeight/2 - square.height/2;

var b:Rectangle;
b = square.getBounds(this);
trace(b); // traces (x=225, y=150, w=100, h=100)

b = square.getBounds(square);
trace(b); // traces (x=0, y=0, w=100, h=100)


So do not expect the second trace in this code block to return a rectangle with a width of 200. Being a completely relative call it will return the object’s independent width within its scaled universe. As I mentioned, it makes sense from an oop standpoint, but its easy to hope or expect a scaled return if you’re needing that returned in a situation.