/*
Conway's Game of Life using a convolution filter and a palette map.
 
In the game of life, cells live or die depending on how many live neighbours
they have. In this version, pixels represent cells and the eight pixels around
every pixel are considered to be the cell's neighbours.
 
A convolution filter takes the job of adding up each pixel's number of live
neighbours and setting the pixel's colour to a value that represents that
value. After this, the pixels are palette mapped so the correct pixels are
kept alive. The process is repeated to animate the Game of Life.
 
The four rules controlling the system are:
1. Fewer than two live neighbours and the cell dies (Loneliness)
2. Greater than three live neighbours and the cell dies (Overcrowding)
3. Exactly three live neighbours and the cell comes to life (Creation)
4. Exactly two live neighbours and the cell stays how it is (Stasis)
 
Alistair Macdonald
http://www.stdio.co.uk/blog
*/
 
package {
    
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.filters.ConvolutionFilter;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    
    [SWF(width="400", height="400", frameRate="30", backgroundColor="#000000")]
    public class SimpleConway extends Sprite {
        
        private static const ALIVE_COLOUR:uint = 0xFFFF0000;
        private static const DEAD_COLOUR:uint = 0x00000000;
        private static const DISPLAY_SCALE:Number = 2;
        // Bitmap that is shown in the display list.
        private var displayContainer:Bitmap;
        // Bitmap that is used to hold the state of the pixels.
        private var state:BitmapData;
        // Filter used to determine how many 
        // alive neighbours a pixel has.
        private var countNeighbours:ConvolutionFilter;
        // Palette map array used to apply the rules of creation, destruction
        // and stasis on the state bitmap after countNeighbours has been applied.
        private var applyConwayRules:Array;
        // Pre-instantated objects do avoid object creation 
        // during the main event loop.
        private var point:Point = new Point();
        private var rect:Rectangle = new Rectangle();
 
        public function SimpleConway() {
            var w:int = stage.stageWidth / DISPLAY_SCALE;
            var h:int = stage.stageHeight / DISPLAY_SCALE;
            
            rect.width = w;
            rect.height = h;
            
            state = new BitmapData(w, h, true, DEAD_COLOUR);
            displayContainer = new Bitmap(state);
            displayContainer.scaleX = DISPLAY_SCALE;
            displayContainer.scaleY = DISPLAY_SCALE;
            addChild(displayContainer);
            
            /* Convolution filter which counts the number of alive neighbours a pixel has. Note the value of 0.5 applied to the source pixel. This allows the filter to carry the state of the state of the source pixel through so the stasis rule can be applied. */
            countNeighbours = new ConvolutionFilter(3, 3, [1, 1, 1, 1, 0.5, 1, 1, 1, 1], 8, 0, false);
            // Palette map, used after applying countNeighbours to convert from 
            // the pixels' values to their alive or dead colours.
            applyConwayRules = new Array(256);
            // Set values which must be counted as alive. All other values
            // will be counted as dead.
            // source pixel is alive and has 2 alive neighbours (stasis)
            applyConwayRules[0x4D] = ALIVE_COLOUR;
            // source pixel is alive and has 3 alive neighbours (creation)
            applyConwayRules[0x6E] = ALIVE_COLOUR;
            // source pixel is dead and has 3 alive neighbours (creation)
            applyConwayRules[0x5E] = ALIVE_COLOUR;
            
            stage.addEventListener(MouseEvent.CLICK, onClick);
            stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);
        }
    
        private function onClick(e:MouseEvent):void {
            // Draw the "acorn" shape at the mouse position. When scaled,
            // displayContainer can return sub-pixel mouse positions so
            // the value is rounded.
            var x:int = Math.round(displayContainer.mouseX);
            var y:int = Math.round(displayContainer.mouseY);
            state.lock();
            state.setPixel32(x, y, ALIVE_COLOUR);
            state.setPixel32(x-2, y-1, ALIVE_COLOUR);
            state.setPixel32(x-3, y+1, ALIVE_COLOUR);
            state.setPixel32(x-2, y+1, ALIVE_COLOUR);
            state.setPixel32(x+1, y+1, ALIVE_COLOUR);
            state.setPixel32(x+2, y+1, ALIVE_COLOUR);
            state.setPixel32(x+3, y+1, ALIVE_COLOUR);
            state.unlock();
        }
        
        private function onEnterFrame(e:Event):void {
            state.lock();
            state.applyFilter(state, rect, point, countNeighbours);
            state.paletteMap(state, rect, point, applyConwayRules, applyConwayRules, applyConwayRules, applyConwayRules);
            state.unlock();
        }
    }
}

function truncateText(textField:TextField):void {
    var text:String = textField.text;
    while (textField.maxScrollV > textField.scrollV) {
        text = text.substring(0, text.length - 1);
        textField.text = text + "...";
    }
}

package {
 
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Point;
 
    public class Main extends Sprite {
        
        private var balls:Array;
        private var ballSprite:Sprite;
        private var display:BitmapData;
        private var zeroPoint:Point;
        private var displayMap:Array;
        
        public function Main() {
            addEventListener(Event.ADDED_TO_STAGE, init);
        }
        
        private function onEnterFrame(e:Event):void {
            for each (var ball:Ball in balls) {
                ball.update();
            }
            
            // copy the balls to the display bitmap, applying a palette map
            // to make them look pretty
            display.lock();
            display.fillRect(display.rect, 0xFF000000);
            display.draw(ballSprite);
            display.paletteMap(display, display.rect, zeroPoint, null, null, displayMap, null);
            display.unlock();
        }
        
        private function init(e:Event):void {
            ballSprite = new Sprite();
            display = new BitmapData(stage.stageWidth, stage.stageHeight, true, 0xFF000000);
            addChild(new Bitmap(display));
            zeroPoint = new Point();
            balls = new Array();
            displayMap = new Array(256);
            
            var i:int;
            
            for (i=0; i<9; i++) {
                var x:Number = Math.random() * stage.stageWidth;
                var y:Number = Math.random() * stage.stageHeight;
                var ball:Ball = new Ball(x, y, stage.stageWidth, stage.stageHeight);
                ballSprite.addChild(ball);
                balls.push(ball);
            }
            
            // set up an array to be used in the palette map which will convert
            // the blue-black balls to red and yellow ones
            for (i=0; i<256; i++) {
                if (i < 0x3F) {
                    // this corresponds to pixels whose energy value is too low
                    displayMap[i] = 0;
                }
                else if (i < 0x4F) {
                    // this corresponds to pixels at the edge of the blob areas
                    // and displays the blobs with a yellow-orange-red gradient
                    displayMap[i] = 0xFF000000 | ((i - 0x3F) << 20);
                    var foo:uint = (i - 0x3F) << 20;
                }
                else {
                    // this corresponds to pixels whose energy value is high enough
                    // to be considered part of a blob and colours them yellow
                    displayMap[i] = 0xFFFF0000 | (i << 8);
                }
            }
            
            addEventListener(Event.ENTER_FRAME, onEnterFrame);
        }
    }
}

package {
    
    import flash.display.BlendMode;
    import flash.display.GradientType;
    import flash.display.Sprite;
    import flash.geom.Matrix;
    
    public class Ball extends Sprite {
        
        private var xMax:Number;
        private var yMax:Number;
        private var vx:Number;
        private var vy:Number;
        
        public function Ball(x:Number, y:Number, xMax:Number, yMax:Number) {
            this.x = x;
            this.y = y;
            this.xMax = xMax;
            this.yMax = yMax;
            
            init();
        }
        
        public function update():void {
            // move the ball
            x += vx;
            y += vy;
            
            // check for the ball hitting the bounds of the display
            if (x < 0) {x=0; vx = -vx;}
            else if (x > xMax) {x=xMax; vx = -vx;}
            if (y < 0) {y=0; vy = -vy;}
            else if (y > yMax) {y=yMax; vy = -vy;}
        }
        
        private function init():void {
            // give the ball a random velocity
            vx = Math.random() * 20 - 10;
            vy = Math.random() * 20 - 10;
            
            // draw a gradient circle, blue in the middle and black at the edge
            var matrix:Matrix = new Matrix();
            matrix.createGradientBox(200, 200, 0, -100, -100);
            graphics.beginGradientFill(GradientType.RADIAL, [0xFF, 0x00], [1, 0], [0x00, 0xFF], matrix);
            graphics.drawCircle(0, 0, 100);
            graphics.endFill();
            
            // set the blend mode to ADD so the balls are overlaid properly
            blendMode = BlendMode.ADD;
        }
    }
}

const GRAVITY = new b2Vec2(0, 9.81);
myBody.ApplyForce(GRAVITY, myBody.GetPosition());

const ANTI_GRAVITY = new b2Vec2(0, -9.81);
myBody.ApplyForce(ANTI_GRAVITY, myBody.GetPosition());

<?php wp_head(); ?>