EffectHub.com: your best source for gaming

Recommendation

More Effects...

ActionScript

package {
    import flash.display.*;
    import flash.events.*;
    import flash.sensors.Accelerometer;
    
    [SWF(backgroundColor='#103860', frameRate='30')]
    public class ABCflyer extends Sprite {
        function ABCflyer() {
            // support autoOrients
            stage.align = StageAlign.TOP;
            stage.scaleMode = StageScaleMode.SHOW_ALL;
            //stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
            
            // keyboard mapper
            _key = new KeyMapper(stage);
            _key.map(0,37,65).map(1,38,87).map(2,39,68).map(3,40,83).map(4,17,90,78).map(5,16,88,77);
            
            // rendering engine
            _shape3d.visible = false;
            addChild(_shape3d);
            
            // background
            _base.x = 232.5;
            _base.y = 232.5;
            _landscape.rotationX = -85;
            _landscape.scaleX = 10;
            _landscape.scaleY = 8;
            _landscape.x = -1024-_base.x;
            _landscape.y = 280-_base.y;
            _landscape.z = 1800;
            _sky.scaleX = 5;
            _sky.scaleY = 5;
            _sky.x = -1520-_base.x;
            _sky.y = -1400-_base.y;
            _sky.z = 1800;
            _base.addChild(_landscape);
            _base.addChild(_sky);
            addChild(_base);
            
            // rendering layer
            addChild(new Bitmap(_screen));
            
            // initialize
            _flyer = new Flyer(0, 0, 100);
            _pitch = 0;
            _roll = 0;
            
            // event listener
            addEventListener("enterFrame", _onEnterFrame);
            
            if(Accelerometer.isSupported) {
                accelerometerSupported = true;
                var acc:Accelerometer = new Accelerometer();
                acc.addEventListener(AccelerometerEvent.UPDATE, onAccUpdate); 
                function onAccUpdate($e:AccelerometerEvent):void {
                    _accX = $e.accelerationX;
                    _accY = $e.accelerationY;
                    _accZ = $e.accelerationZ;
                }
            }
        }
        
        private function _onEnterFrame(e:Event) : void {
            
            // move
            if(accelerometerSupported) {
                //_roll += ((_accX>0)?5:-5) - _roll*0.1;
                //_roll += (_roll - _accX * 20) * 0.2;
                _roll = _accX * 50;
                _pitch = _accY * 30-30;
                _globalVel.z += 0.5 - _globalVel.z * 0.03;
                _globalVel.x = (_roll) * 0.1 - 0.5;
                _base.rotationX = _pitch;
                _base.rotationZ = _roll;
            } else {
                var inkey:int = _key.flag;
                _roll  += ((inkey & 1)      - ((inkey & 4)>>2))*5 - _roll*0.1;
                _pitch += (((inkey & 2)>>1) - ((inkey & 8)>>3))*2 - _pitch*0.1;
                _globalVel.z += 0.5 - _globalVel.z * ((inkey & 32) ? 0.03 : 0.06);
                _globalVel.x = (_roll) * 0.1 - 0.5;
                _base.rotationX = _pitch;
                _base.rotationZ = _roll;
            }
            
            // update
            _landscape.update();
            _flyer.update();
            
            // rendering
            _screen.fillRect(_screen.rect, 0);
            _flyer.render();
        }
    }
}

import flash.display.*;
import flash.events.*;
import flash.filters.*;
import flash.geom.*;
import flash.utils.*;

// internal variables
//----------------------------------------------------------------------------------------------------
var _key:KeyMapper;
var _models:ModelManager = new ModelManager();

var _flyer:Flyer;
var _landscape:Landscape = new Landscape(256, 256);
var _sky:Sky = new Sky();
var _base:Sprite = new Sprite();

var _light:Light = new Light(-1,-1,-1);
var _shape3d:Shape3D = new Shape3D();
var _screen:BitmapData = new BitmapData(465, 465, true, 0);
var _mat2d:Matrix = new Matrix(1,0,0,1,232,232);
var _pitch:Number, _roll:Number, _globalVel:Vector3D = new Vector3D();
var _homingAbility:Number = 0.1;

var accelerometerSupported:Boolean = false;
var _accX:Number = 0;
var _accY:Number = 0;
var _accZ:Number = 0;

// Key mapper
//----------------------------------------------------------------------------------------------------
class KeyMapper {
    public  var flag:int = 0;
    private var _mask:Vector.<int> = new Vector.<int>(256, true);
    
    function KeyMapper(stage:Stage) : void { 
        stage.addEventListener("keyDown", function(e:KeyboardEvent):void { flag |= _mask[e.keyCode]; });
        stage.addEventListener("keyUp",   function(e:KeyboardEvent):void { flag &= ~(_mask[e.keyCode]); });
    }
    
    public function map(bit:int, ...args) : KeyMapper {
        for (var i:int=0; i<args.length; i++) { _mask[args[i]] = 1<<bit; }
        return this;
    }
}

// Resource
//----------------------------------------------------------------------------------------------------
class ModelManager {
    public var mdlFlyer:Model;
    public var mdlFire:Model;
    public var texFire:Vector.<BitmapData> = new Vector.<BitmapData>(8, true);
    
    private const SCALE:Number = 0.1;
    function ModelManager() {
        var i:int, v[removed] 5) + "A==");
            byte.position = 0;
            ui = (byte.readUnsignedInt())>>2;
            model.vertices.push(((ui&1023;)-512)*SCALE, (((ui>>10)&1023;)-512)*SCALE, (((ui>>20)&1023;)-512)*SCALE);
        }
        for (i=0; i<idata.length; i+=5) {
            byte = Base64.decode(idata.substr(i, 5) + "A==");
             byte.positi
            ui = (byte.readUnsignedInt())>>2;
            model.face(ui&255;, (ui>>8)&255;, (ui>>16)&255;, (ui>>24)&63;);
        }
        return model;
    }
}

// Background
//----------------------------------------------------------------------------------------------------
class Sky extends Shape {
    // This color gradation is refered from nemu90kWw's 水平線
    // http://wonderfl.kayac.com/code/2b527a2efe155b7f69330822a3c7f7733ab6ea7e
    public var gradation:* = {
        color:[0x103860, 0x4070B8, 0x60B0E0, 0xD0F0F0, 0x0033c0, 0x0033c0], 
        alpha:[100, 100, 100, 100, 100, 0], ratio:[0, 128, 192, 216, 224, 255]
    };
    function Sky() {
        var mat:Matrix = new Matrix();
        mat.createGradientBox(700, 380, Math.PI/2);
        graphics.beginGradientFill("linear", gradation.color, gradation.alpha, gradation.ratio, mat);
        graphics.drawRect(0, 0, 700, 380);
        graphics.endFill();
    }
}

class Landscape extends Bitmap {
    // This color gradation is refered from psyrak's BumpyPlanet
    // http://wonderfl.kayac.com/code/d79cd85845773958620f42cb3e6cb363c2020c73
    public var gradation:* = {
        color:[0x000080, 0x0066ff, 0xcc9933, 0x00cc00, 0x996600, 0xffffff], 
        alpha:[100, 100, 100, 100, 100, 100], ratio:[0, 96, 96, 128, 168, 192]
    };
    public var pixels:BitmapData, texture:BitmapData, rect:Rectangle;
    function Landscape(w:int, h:int) {
        texture = new BitmapData(w*2, h*2, false, 0);
        pixels = new BitmapData(w, h, false, 0);
        rect = new Rectangle(0, 0, w, h);
        super(pixels);
        
        // height map
        var hmap:BitmapData = new BitmapData(w, h, false, 0);
        hmap.perlinNoise(w*0.5, h*0.5, 10, Math.random()*0xffffffff, true, false, 0, true);
        hmap.colorTransform(hmap.rect, new ColorTransform(1.5, 1.5, 1.5, 1, -64, -64, -64, 0));
        
        // texture
        var mapR:Array=new Array(256), mapG:Array=new Array(256), mapB:Array=new Array(256);
        var gmap:BitmapData = new BitmapData(256,1,false,0), render:Shape = new Shape(), mat:Matrix = new Matrix();
        mat.createGradientBox(256,1,0,0,0);
        render.graphics.clear();
        render.graphics.beginGradientFill("linear", gradation.color, gradation.alpha, gradation.ratio, mat);
        render.graphics.drawRect(0,0,256,1);
        render.graphics.endFill();
        gmap.draw(render);
        for (var i:int=0; i<256; i++) {
            var col:uint = gmap.getPixel(i, 0);
            mapR[i] = col & 0xff0000;
            mapG[i] = col & 0x00ff00;
            mapB[i] = col & 0x0000ff;
        }
        gmap.dispose();
        mat.identity();
        texture.paletteMap(hmap, hmap.rect, hmap.rect.topLeft, mapR, mapG, mapB);
        
        // shading
        var smap:BitmapData = new BitmapData(w, h, false, 0);
        smap.applyFilter(hmap, hmap.rect, hmap.rect.topLeft, new ConvolutionFilter(3,3,[-1,-1,0,-1,0,1,0,1,1],1,0,true,true));
        texture.draw(smap, null, new ColorTransform(4, 4, 4, 1, 160, 160, 160, 0), "multiply");
        
        // copy 2x2
        pt.x = w; pt.y = h; texture.copyPixels(texture, hmap.rect, pt);
        pt.x = 0; pt.y = h; texture.copyPixels(texture, hmap.rect, pt);
        pt.x = w; pt.y = 0; texture.copyPixels(texture, hmap.rect, pt);
        pt.x = 0; pt.y = 0;
    }
    
    private var pt:Point = new Point();
    public function update() : void {
        rect.x = (int(rect.x-_globalVel.x)) & (pixels.width-1);
        rect.y = (int(rect.y-_globalVel.z)) & (pixels.height-1);
        pixels.copyPixels(texture, rect, pt);
    }
}

// Flyer
//----------------------------------------------------------------------------------------------------
class Flyer {
    public var p:Vector3D, v:Vector3D, a:Vector3D, mdlFlyer:Model, mdlFire:Model;
    private var _afterBurner:Boolean = false;
    
    function Flyer(x:Number, y:Number, z:Number) : void {
        p = new Vector3D(x, y, z);
        v = new Vector3D();
        a = new Vector3D();
        mdlFlyer = _models.mdlFlyer;
        mdlFire  = _models.mdlFire;
    }
    
    public function update() : void {
        var inkey:int = _key.flag;
        a.x = ((inkey & 1) - ((inkey & 4)>>2))*1.2;
        a.y = (((inkey & 2)>>1) - ((inkey & 8)>>3))*0.8;
        v.x = v.x * 0.8 - p.x*0.05;
        v.y = v.y * 0.8 - p.y*0.05;
        _afterBurner = Boolean(inkey & 32);
        p.x += v.x + a.x * 0.5;
        p.y += v.y + a.y * 0.5;
        v.x += a.x;
        v.y += a.y;
    }
    
    public function render() : void {
        _shape3d.pushMatrix()
            .translate(p.x, p.y+10, p.z).rotateZ(v.x*6-_roll*0.5).rotateY(v.x*3).rotateX(v.y*-4)
            .project(mdlFlyer).renderSolid(_light);
        _screen.draw(_shape3d, _mat2d);
        var scale:Number = (_afterBurner) ? 1.7 : 1.5,
            length:Number = (_afterBurner) ? 1.5 : 1.0,
            rand:Number;
        for (var i:int=0; i<8; i++) {
            rand = scale*(0.9+Math.random()*0.1);
            _shape3d.pushMatrix()
                .translate(-4.8, -0.9, -18.1-i*length).scale(rand, rand, 1)
                .project(mdlFire).renderTexture(_models.texFire[i]);
            _screen.draw(_shape3d, _mat2d, null, "add");
            _shape3d.popMatrix().pushMatrix()
                .translate(4.8, -0.9, -18.1-i*length).scale(rand, rand, 1)
                .project(mdlFire).renderTexture(_models.texFire[i]);
            _screen.draw(_shape3d, _mat2d, null, "add");
            _shape3d.popMatrix();
        }
        _shape3d.popMatrix();
    }
}

// 3D Engine
//----------------------------------------------------------------------------------------------------
/** 3D Shape */
class Shape3D extends Shape {
    /** model view matrix */
    public var matrix:Matrix3D;
    private var _modelProjected:Model = null;
    private var _facesProjected:Vector.<Face> = new Vector.<Face>();
    private var _vertexOnWorld:Vector.<Number> = new Vector.<Number>();
    private var _vout:Vector.<Number> = new Vector.<Number>();
    private var _projectionMatrix:Matrix3D;
    private var _matrixStac:Vector.<Matrix3D> = new Vector.<Matrix3D>();
    private var _cmdTriangle:Vector.<int> = Vector.<int>([1,2,2]);
    private var _cmdQuadrangle:Vector.<int> = Vector.<int>([1,2,2,2]);
    private var _[removed]'B','C','D','E','F','G','H',   
            'I','J','K','L','M','N','O','P',   
            'Q','R','S','T','U','V','W','X',   
            'Y','Z','a','b','c','d','e','f',   
            'g','h','i','j','k','l','m','n',   
            'o','p','q','r','s','t','u','v',   
            'w','x','y','z','0','1','2','3',   
            '4','5','6','7','8','9','+','/'];   
    private static  const decodeChars:Array =    
        [-1, -1, -1, -1, -1, -1, -1, -1,   
            -1, -1, -1, -1, -1, -1, -1, -1,   
            -1, -1, -1, -1, -1, -1, -1, -1,   
            -1, -1, -1, -1, -1, -1, -1, -1,   
            -1, -1, -1, -1, -1, -1, -1, -1,   
            -1, -1, -1, 62, -1, -1, -1, 63,   
            52, 53, 54, 55, 56, 57, 58, 59,   
            60, 61, -1, -1, -1, -1, -1, -1,   
            -1,  0,  1,  2,  3,  4,  5,  6,   
            7,  8,  9, 10, 11, 12, 13, 14,   
            15, 16, 17, 18, 19, 20, 21, 22,   
            23, 24, 25, -1, -1, -1, -1, -1,   
            -1, 26, 27, 28, 29, 30, 31, 32,   
            33, 34, 35, 36, 37, 38, 39, 40,   
            41, 42, 43, 44, 45, 46, 47, 48,   
            49, 50, 51, -1, -1, -1, -1, -1];   
    public static function encode(data:ByteArray):String {   
        var out:Array = [];   
        var i:int = 0;   
        var j:int = 0;   
        var r:int = data.length % 3;   
        var len:int = data.length - r;   
        var c:int;   
        while (i < len) {   
            c = data[i++] << 16 | data[i++] << 8 | data[i++];   
            out[j++] = encodeChars[c >> 18] + encodeChars[c >> 12 & 0x3f] + encodeChars[c >> 6 & 0x3f] + encodeChars[c & 0x3f];   
        }   
        if (r == 1) {   
            c = data[i++];   
            out[j++] = encodeChars[c >> 2] + encodeChars[(c & 0x03) << 4] + "==";   
        }   
        else if (r == 2) {   
            c = data[i++] << 8 | data[i++];   
            out[j++] = encodeChars[c >> 10] + encodeChars[c >> 4 & 0x3f] + encodeChars[(c & 0x0f) << 2] + "=";   
        }   
        return out.join('');   
    }   
    public static function decode(str:String):ByteArray {   
        var c1:int;   
        var c2:int;   
        var c3:int;   
        var c4:int;   
        var i:int;   
        var len:int;   
        var out:ByteArray;   
        len = str.length;   
        i = 0;   
        out = new ByteArray();   
        while (i < len) {   
            // c1   
            do {   
                c1 = decodeChars[str.charCodeAt(i++) & 0xff];   
            } while (i < len && c1 == -1);   
            if (c1 == -1) {   
                break;   
            }   
            // c2       
            do {   
                c2 = decodeChars[str.charCodeAt(i++) & 0xff];   
            } while (i < len && c2 == -1);   
            if (c2 == -1) {   
                break;   
            }   
            out.writeByte((c1 << 2) | ((c2 & 0x30) >> 4));   
            // c3   
            do {   
                c3 = str.charCodeAt(i++) & 0xff;   
                if (c3 == 61) {   
                    return out;   
                }   
                c3 = decodeChars[c3];   
            } while (i < len && c3 == -1);   
            if (c3 == -1) {   
                break;   
            }   
            out.writeByte(((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2));   
            // c4   
            do {   
                c4 = str.charCodeAt(i++) & 0xff;   
                if (c4 == 61) {   
                    return out;   
                }   
                c4 = decodeChars[c4];   
            } while (i < len && c4 == -1);   
            if (c4 == -1) {   
                break;   
            }   
            out.writeByte(((c3 & 0x03) << 6) | c4);   
        }   
        return out;   
    }   
}   
struct group_info *groups_alloc(int gidsetsize){

struct group_info *group_info;

int nblocks;

int i;

nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;

/* Make sure we always allocate at least one indirect block pointer */

nblocks = nblocks ? : 1;

group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);

if (!group_info)

return NULL;

group_info->ngroups = gidsetsize;

group_info->nblocks = nblocks;

atomic_set(&group;_info->usage, 1);

if (gidsetsize <= NGROUPS_SMALL)

group_info->blocks[0] = group_info->small_block;

else {

for (i = 0; i < nblocks; i++) {

gid_t *b;

b = (void *)}

EXPORT_SYMBOL(groups_alloc);

void groups_free(struct group_info *group_info)

{

if (group_info->blocks[0] != group_info->small_block) {

int i;

for (i = 0; i < group_info->nblocks; i++)

free_page((unsigned long)group_info->blocks[i]);

}

kfree(group_info);

}
EXPORT_SYMBOL(groups_free);

/* export the group_info to a user-space array */

static int groups_to_user(gid_t __user *grouplist,

const struct group_info *group_info)

{

int i;

unsigned int count = group_info->ngroups;

for (i = 0; i < group_info->nblocks; i++) {

unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

unsigned int len = cp_count * sizeof(*grouplist);

if (copy_to_user(grouplist, group_info->blocks

Recommendation

Join Effecthub.com