※現在、「wonderfl build flash online」求人コンテンツ制作に関してのアンケートを実施中です！みなさまのお力添えを頂いて、続々とアンケート結果が集まっていますが、まだまだ募集しております。ご協力のほど、どうぞよろしくお願いいたします！

wonderfl運営事務局
→アンケートページ（※ログインしてからお答えいただけるようになっています。）

 notice: Flash editor updated! Join the development! Thanks to MiniBuilder


embed

noswf download fullscreen
flash swf thumbnail play
reload download fullscreen

FORKED
>sort

Tetris forked from: Tetris [diff(3)]

  1. // forked from flashrod's Tetris
  2. package {
  3.     import flash.display.Sprite;
  4.     import flash.text.TextField;
  5.     import flash.events.Event;
  6.     import flash.events.KeyboardEvent;
  8.     public class Tetris extends Sprite {
  9.         private const W:int = 10;
  10.         private const H:int = 20;
  11.         private const UNIT:int = 10;
  12.         private const COLOR:Array =[0x000000, 0x00FFFF, 0xFFFF00, 0x22FF22, 0xFF2222, 0x4444FF, 0xFF8844, 0xFF22FF];
  13.         private const PAT:Array =[[[1, 1, 1, 1]],
  14.                                   [[0, 2, 0], [2, 2, 2]],
  15.                                   [[3, 3, 0], [0, 3, 3]],
  16.                                   [[0, 4, 4], [4, 4, 0]],
  17.                                   [[5, 5], [5, 0], [5, 0]],
  18.                                   [[6, 6], [0, 6], [0, 6]],
  19.                                   [[7, 7], [7, 7]]];
  20.         private const SPEED:Array = [30, 20, 10, 5];
  22.         private const VK_H:int = 72; // h
  23.         private const VK_J:int = 74; // j
  24.         private const VK_K:int = 75; // k
  25.         private const VK_L:int = 76; // l
  26.         private const VK_SPC:int = 32; // space
  28.         private var field:Array = [];
  29.         private var piece:Array;
  30.         private var next:Array;
  31.         private var text:TextField = new TextField();
  32.         private var keytable:Array = [];
  33.         private var count:int = 0;
  34.         private var step:int = 0;
  35.         private var px:int;
  36.         private var py:int;
  38.         public function Tetris() {
  39.             text.x = W*UNIT;
  40.             text.text="Next:";
  41.             addChild(text);
  42.             var t:TextField = new TextField();
  43.             t.x = W * UNIT;
  44.             t.y = 6 * UNIT;
  45.             t.text = "usage: h,j,k,l,SPACE";
  46.             addChild(t);
  47.             field = new Array(H).map(function():*{
  48.                 return new Array(W).map(function():*{
  49.                     return 0;
  50.                 })
  51.             });
  52.             keytable[VK_H] = function():void {px -= space(px-1, py, piece)};
  53.             keytable[VK_J] = function():void {rotate(true)};
  54.             keytable[VK_K] = function():void {rotate(false)};
  55.             keytable[VK_L] = function():void {px += space(px+1, py, piece)};
  56.             keytable[VK_SPC] = function():void {drop(); pick();};
  57.             stage.addEventListener(KeyboardEvent.KEY_DOWN, function(e:KeyboardEvent):void {
  58.                 if (keytable[e.keyCode]) {
  59.                     keytable[e.keyCode]();
  60.                     repaint();
  61.                 }
  62.             });
  63.             pick();
  64.             pick();
  65.             addEventListener(Event.ENTER_FRAME, function(e:Event):void {
  66.                 if (--step < 0) {
  67.                     step=SPEED[int(count/10)];
  68.                     if (space(px, py+1, piece)) {
  69.                         ++py;
  70.                         repaint();
  71.                     } else {
  72.                         drop();
  73.                         pick();
  74.                     }
  75.                 }
  76.             });
  77.         }
  79.         private function rotate(clock:Boolean):void {
  80.             var r:Array = new Array(piece[0].length).map(function():*{return [];});
  81.             for (var j:int = 0; j<piece.length; ++j)
  82.                 for (var i:int = 0; i < r.length; ++i)
  83.                     if (clock)
  84.                         r[i][piece.length-1-j] = piece[j][i];
  85.                     else
  86.                         r[r.length-1-i][j] = piece[j][i];
  87.             if (space(px, py, r))
  88.                 piece = r;
  89.         }
  91.         private function repaint():void {
  92.             graphics.clear();
  93.             for (var j:int = 0; j < H; ++j)
  94.                 for (var i:int = 0; i < W; ++i) {
  95.                     var g:int = 0;
  96.                     if (py <= j && j < (py+piece.length) && px <= i && i < (px+piece[0].length))
  97.                         g = piece[j-py][i-px];
  98.                     if (g == 0)
  99.                         g = field[j][i];
  100.                     graphics.beginFill(COLOR[g]);
  101.                     graphics.drawRect(i*UNIT, j*UNIT, UNIT, UNIT);
  102.                 }
  103.             for (j = 0; j < next.length; ++j)
  104.                 for (i = 0; i < next[j].length; ++i) {
  105.                     graphics.beginFill(COLOR[next[j][i]]);
  106.                     graphics.drawRect((i+W+1)*UNIT, (j+2)*UNIT, UNIT, UNIT);
  107.                 }
  108.         }
  110.         private function space(x:int, y:int, p:Array):int {
  111.             for (var j:int = 0; j < p.length; ++j) {
  112.                 if (0 > (y+j) || (y+j) >= H)
  113.                     return 0;
  114.                 for (var i:int = 0; i < p[j].length; ++i) {
  115.                     if (0 > (x+i) || (x+i) >= W)
  116.                         return 0;
  117.                     if (p[j][i] && field[y+j][x+i])
  118.                         return 0;
  119.                 }
  120.             }
  121.             return 1;
  122.         }
  124.         private function drop():void {
  125.             for (; space(px, py+1, piece); py++)
  126.                 ;
  127.             for (var j:int = 0; j < piece.length; ++j)
  128.                 for (var i:int = 0; i < piece[j].length; ++i)
  129.                     if (piece[j][i])
  130.                         field[py+j][px+i] = piece[j][i];
  131.             for (j=0; j<H; ++j)
  132.                 if (field[j].indexOf(0) < 0) {
  133.                     field.splice(j, 1);
  134.                     field.unshift([]);
  135.                     for (i=0; i<W; ++i)
  136.                         field[0][i] = 0;
  137.                 }
  139.             count++;
  140.             if (count/10 >= SPEED.length)
  141.                 count = 0;
  142.         }
  144.         private function pick():void {
  145.             piece = next;
  146.             if (piece != null) {
  147.                 px = (W-piece[0].length)/2;
  148.                 py = 0;
  149.                 if (!space(px, py, piece))
  150.                     text.text="GAME OVER";
  151.             }
  152.             next = PAT[int(Math.random()*PAT.length)];
  153.         }
  154.     }
  155. }
noswf

Tetris Tetris、操作系変更、落下時の加速に対応、レベルアップ条件変更 [diff(325)]

  1. // forked from flashrod's Tetris
  2. //
  3. // 1. 移動を矢印キーに変更
  4. // 2. 回転をZ,Xキーに変更
  5. // 3. いきなり落下ではなく、加速するように
  6. // 4. スピードアップは10ライン消すごとに変更
  7. // 5. 50ライン消すとレベル0に戻ります。enjoy!!
  9. package {
  10.    import flash.display.Sprite;
  11.    import flash.text.TextField;
  12.    import flash.events.Event;
  13.    import flash.events.KeyboardEvent;
  15.    [SWF(width = "240", height = "352", backgroundColor = "0xf0f0f0", frameRate = "60")]
  17.    public class Main extends Sprite {
  18.        private const W:int = 10;
  19.        private const H:int = 20;
  20.        private const UNIT:int = 16; // 一つのブロックサイズ
  22.        // カラーテーブル
  23.        private const COLOR:Array =[0x000000, 0x00FFFF, 0xFFFF00,
  24. 0x22FF22, 0xFF2222, 0x4444FF, 0xFF8844, 0xFF22FF];
  26.        // ブロックパターン、インデックスは色を表す、0は抜き
  27.        private const PAT:Array =[[[1, 1, 1, 1]], //棒
  28.                                  [[0, 2, 0], [2, 2, 2]], //凸
  29.                                  [[3, 3, 0], [0, 3, 3]], //逆S
  30.                                  [[0, 4, 4], [4, 4, 0]], //S
  31.                                  [[5, 5], [5, 0], [5, 0]], //逆L
  32.                                  [[6, 6], [0, 6], [0, 6]], //L
  33.                                  [[7, 7], [7, 7]]];//四角
  35.        // 落下速度
  36.        //
  37.        private const SPEED:Array = [60, 30, 20, 10, 5];
  38.        private const DROP_SPEED:int = 2;
  39.        private const LEVEL_UP_LINES:int = 10;
  41.        // キーコード
  42.        private const VK_LEFT:int = 37; // 懼
  43.        private const VK_ROTLEFT:int = 90; // z
  44.        private const VK_ROTRIGHT:int = 88; // x
  45.        private const VK_RIGHT:int = 39; // 懼
  46.        private const VK_DROP:int = 40; // 懼
  48.        // 変数一覧
  49.        private var field:Array = [];
  50.        private var piece:Array;
  51.        private var next:Array;
  52.        private var text:TextField = new TextField();
  53.        private var score_:TextField = new TextField();
  54.        private var keytable:Array = [];
  55.        private var step:int = 0;
  56.        private var px:int;
  57.        private var py:int;
  58.        private var isDrop_:Boolean = false;
  59.        private var speedLevel_:int = 0; //落下速度のレベル
  60.        private var deleteLine_:int = 0; //消去したライン数
  62.        public function Main() {
  63.            // 次のブロック
  64.            text.x = W * UNIT;
  65.            text.y = 0 * UNIT;
  66.            text.text="Next:";
  67.            addChild(text);
  69.            // スコア
  70.            score_.x = W * UNIT;
  71.            score_.y = 6 * UNIT;
  72.            addChild(score_);
  73.            updateScore();
  75.            // 操作説明
  76.            var t:TextField = new TextField();
  77.            t.x = W * UNIT;
  78.            t.y = 11 * UNIT;
  79.            t.text = "usage: ←,→,↓,Z,X";
  80.            addChild(t);
  82.            // フィールド(H * W のサイズで0埋め)
  83.            field = new Array(H).map(function():*{
  84.                return new Array(W).map(function():*{
  85.                    return 0;
  86.                })
  87.            });
  89.            // 最初に二つ落として、最初のブロックとNEXTブロックを設定する
  90.            pick();
  91.            pick();
  93.            // イベント登録
  94.            addEventListener(Event.ENTER_FRAME, onEnterFrame);
  95.            setupKeyDownEvent();
  96.        }
  98.        private function onEnterFrame(e:Event):void {
  99.            if (--step < 0) {
  100.                if (!isDrop_)
  101.                  step=SPEED[speedLevel_];
  102.                else
  103.                  step = DROP_SPEED;
  105.                if (space(px, py+1, piece)) {
  106.                    ++py;
  107.                    repaint();
  108.                } else {
  109.                    drop();
  110.                    pick();
  111.                }
  112.            }
  113.        }
  115.        private function setupKeyDownEvent():void {
  116.            keytable[VK_LEFT] = function():void {px -= space(px-1, py, piece)};
  117.            keytable[VK_ROTLEFT] = function():void {rotate(true)};
  118.            keytable[VK_ROTRIGHT] = function():void {rotate(false)};
  119.            keytable[VK_RIGHT] = function():void {px += space(px+1, py, piece)};
  120.            keytable[VK_DROP] = function():void { if (!isDrop_) {
  121. isDrop_ = true; step = DROP_SPEED; } };
  123.            stage.addEventListener(KeyboardEvent.KEY_DOWN, function
  124. (e:KeyboardEvent):void {
  125.                if (keytable[e.keyCode]) {
  126.                    keytable[e.keyCode]();
  127.                    repaint();
  128.                }
  129.            });
  131.            stage.addEventListener(KeyboardEvent.KEY_UP, function
  132. (e:KeyboardEvent):void {
  133.               if (e.keyCode == VK_DROP) {
  134.                   isDrop_ = false;
  135.               }
  136.            });
  137.        }
  139.        // 回転
  140.        private function rotate(clock:Boolean):void {
  141.            var r:Array = new
  142. Array(piece[0].length).map(function():*{return [];});
  143.            for (var j:int = 0; j<piece.length; ++j)
  144.                for (var i:int = 0; i < r.length; ++i)
  145.                    if (clock)
  146.                        r[i][piece.length-1-j] = piece[j][i];
  147.                    else
  148.                        r[r.length-1-i][j] = piece[j][i];
  149.            if (space(px, py, r))
  150.                piece = r;
  151.        }
  153.        // 再描画
  154.        private function repaint():void {
  155.            // 一度画面をクリア
  156.            graphics.clear();
  158.            // フィールドブロック
  159.            for (var j:int = 0; j < H; ++j)
  160.                for (var i:int = 0; i < W; ++i) {
  161.                    var g:int = 0;
  163.                    // 落下中ピース
  164.                    if (py <= j && j < (py+piece.length) && px <= i &&
  165. i < (px+piece[0].length))
  166.                        g = piece[j-py][i-px];
  167.                    // フィールド配置済みピース
  168.                    if (g == 0)
  169.                        g = field[j][i];
  171.                    // 描画
  172.                    graphics.beginFill(COLOR[g]);
  173.                    graphics.drawRect(i*UNIT, j*UNIT, UNIT, UNIT);
  174.                }
  176.            // ネクストブロック
  177.            for (j = 0; j < next.length; ++j)
  178.                for (i = 0; i < next[j].length; ++i) {
  179.                    graphics.beginFill(COLOR[next[j][i]]);
  180.                    graphics.drawRect((i+W+1)*UNIT, (j+2)*UNIT, UNIT, UNIT);
  181.                }
  182.        }
  184.        // 指定位置にピースが置けるか判定
  185.        //
  186.        // @param x 検査位置x
  187.        // @param y 検査位置y
  188.        // @param p 検査するブロック
  189.        private function space(x:int, y:int, p:Array):int {
  190.            for (var j:int = 0; j < p.length; ++j) {
  191.                if (0 > (y+j) || (y+j) >= H)
  192.                    return 0;
  193.                for (var i:int = 0; i < p[j].length; ++i) {
  194.                    if (0 > (x+i) || (x+i) >= W)
  195.                        return 0;
  196.                    if (p[j][i] && field[y+j][x+i])
  197.                        return 0;
  198.                }
  199.            }
  200.            return 1;
  201.        }
  203.        // ブロックを下まで落とし、フィールドに吸着、ブロック消去判定
  204.        private function drop():void {
  205.            // ブロック位置を下まで落とす
  206.            for (; space(px, py+1, piece); py++)
  207.                ;
  209.            // フィールドに配置
  210.            for (var j:int = 0; j < piece.length; ++j)
  211.                for (var i:int = 0; i < piece[j].length; ++i)
  212.                    if (piece[j][i])
  213.                        field[py+j][px+i] = piece[j][i];
  215.            // ブロック消去
  216.            for (j=0; j<H; ++j)
  217.                if (field[j].indexOf(0) < 0) {
  218.                    // １行消去して
  219.                    field.splice(j, 1);
  221.                    // 先頭に一つ挿入
  222.                    field.unshift([]);
  223.                    for (i=0; i<W; ++i)
  224.                        field[0][i] = 0;
  226.                    // 消去したライン数
  227.                    deleteLine_++;
  228.                }
  230.            // スピードアップ検査、一定回数積んだら速度を元に戻す
  231.            speedLevel_ = deleteLine_ / LEVEL_UP_LINES;
  232.            if (speedLevel_ >= SPEED.length)
  233.                speedLevel_ = 0;
  235.            // スコア更新
  236.            updateScore();
  237.        }
  239.        // 次のブロックを取得
  240.        private function pick():void {
  241.            piece = next;
  242.            if (piece != null) {
  243.                px = (W-piece[0].length)/2;
  244.                py = 0;
  245.                if (!space(px, py, piece))
  246.                    text.text="GAME OVER";
  247.            }
  248.            next = PAT[int(Math.random()*PAT.length)];
  249.        }
  251.        // スコア更新
  252.        private function updateScore():void {
  253.            score_.text = "";
  254.            score_.appendText("Lines : " + deleteLine_.toString() + "\n");
  255.            score_.appendText("\n");
  256.            score_.appendText("Level : " + speedLevel_.toString());
  257.        }
  259.    }
  260. }
noswf

Tetris forked from: Tetris [diff(1)]

  1. // forked from flashrod's Tetris
  2. package {
  3.     import flash.display.Sprite;
  4.     import flash.text.TextField;
  5.     import flash.events.Event;
  6.     import flash.events.KeyboardEvent;
  8.     public class Tetris extends Sprite {
  9.         private const W:int = 10;
  10.         private const H:int = 20;
  11.         private const UNIT:int = 16;
  12.         private const COLOR:Array =[0x000000, 0x00FFFF, 0xFFFF00, 0x22FF22, 0xFF2222, 0x4444FF, 0xFF8844, 0xFF22FF];
  13.         private const PAT:Array =[[[1, 1, 1, 1]],
  14.                                   [[0, 2, 0], [2, 2, 2]],
  15.                                   [[3, 3, 0], [0, 3, 3]],
  16.                                   [[0, 4, 4], [4, 4, 0]],
  17.                                   [[5, 5], [5, 0], [5, 0]],
  18.                                   [[6, 6], [0, 6], [0, 6]],
  19.                                   [[7, 7], [7, 7]]];
  20.         private const SPEED:Array = [30, 20, 10, 5];
  22.         private const VK_H:int = 72; // h
  23.         private const VK_J:int = 74; // j
  24.         private const VK_K:int = 75; // k
  25.         private const VK_L:int = 76; // l
  26.         private const VK_SPC:int = 32; // space
  28.         private var field:Array = [];
  29.         private var piece:Array;
  30.         private var next:Array;
  31.         private var text:TextField = new TextField();
  32.         private var keytable:Array = [];
  33.         private var count:int = 0;
  34.         private var step:int = 0;
  35.         private var px:int;
  36.         private var py:int;
  38.         public function Tetris() {
  39.             text.x = W*UNIT;
  40.             text.text="Next:";
  41.             addChild(text);
  42.             var t:TextField = new TextField();
  43.             t.x = W * UNIT;
  44.             t.y = 8 * UNIT;
  45.             t.text = "usage: h,j,k,l,SPACE";
  46.             addChild(t);
  47.             field = new Array(H).map(function():*{
  48.                 return new Array(W).map(function():*{
  49.                     return 0;
  50.                 })
  51.             });
  52.             keytable[VK_H] = function():void {px -= space(px-1, py, piece)};
  53.             keytable[VK_J] = function():void {rotate(true)};
  54.             keytable[VK_K] = function():void {rotate(false)};
  55.             keytable[VK_L] = function():void {px += space(px+1, py, piece)};
  56.             keytable[VK_SPC] = function():void {drop(); pick();};
  57.             stage.addEventListener(KeyboardEvent.KEY_DOWN, function(e:KeyboardEvent):void {
  58.                 if (keytable[e.keyCode]) {
  59.                     keytable[e.keyCode]();
  60.                     repaint();
  61.                 }
  62.             });
  63.             pick();
  64.             pick();
  65.             addEventListener(Event.ENTER_FRAME, function(e:Event):void {
  66.                 if (--step < 0) {
  67.                     step=SPEED[int(count/10)];
  68.                     if (space(px, py+1, piece)) {
  69.                         ++py;
  70.                         repaint();
  71.                     } else {
  72.                         drop();
  73.                         pick();
  74.                     }
  75.                 }
  76.             });
  77.         }
  79.         private function rotate(clock:Boolean):void {
  80.             var r:Array = new Array(piece[0].length).map(function():*{return [];});
  81.             for (var j:int = 0; j<piece.length; ++j)
  82.                 for (var i:int = 0; i < r.length; ++i)
  83.                     if (clock)
  84.                         r[i][piece.length-1-j] = piece[j][i];
  85.                     else
  86.                         r[r.length-1-i][j] = piece[j][i];
  87.             if (space(px, py, r))
  88.                 piece = r;
  89.         }
  91.         private function repaint():void {
  92.             graphics.clear();
  93.             for (var j:int = 0; j < H; ++j)
  94.                 for (var i:int = 0; i < W; ++i) {
  95.                     var g:int = 0;
  96.                     if (py <= j && j < (py+piece.length) && px <= i && i < (px+piece[0].length))
  97.                         g = piece[j-py][i-px];
  98.                     if (g == 0)
  99.                         g = field[j][i];
  100.                     graphics.beginFill(COLOR[g]);
  101.                     graphics.drawRect(i*UNIT, j*UNIT, UNIT, UNIT);
  102.                 }
  103.             for (j = 0; j < next.length; ++j)
  104.                 for (i = 0; i < next[j].length; ++i) {
  105.                     graphics.beginFill(COLOR[next[j][i]]);
  106.                     graphics.drawRect((i+W+1)*UNIT, (j+2)*UNIT, UNIT, UNIT);
  107.                 }
  108.         }
  110.         private function space(x:int, y:int, p:Array):int {
  111.             for (var j:int = 0; j < p.length; ++j) {
  112.                 if (0 > (y+j) || (y+j) >= H)
  113.                     return 0;
  114.                 for (var i:int = 0; i < p[j].length; ++i) {
  115.                     if (0 > (x+i) || (x+i) >= W)
  116.                         return 0;
  117.                     if (p[j][i] && field[y+j][x+i])
  118.                         return 0;
  119.                 }
  120.             }
  121.             return 1;
  122.         }
  124.         private function drop():void {
  125.             for (; space(px, py+1, piece); py++)
  126.                 ;
  127.             for (var j:int = 0; j < piece.length; ++j)
  128.                 for (var i:int = 0; i < piece[j].length; ++i)
  129.                     if (piece[j][i])
  130.                         field[py+j][px+i] = piece[j][i];
  131.             for (j=0; j<H; ++j)
  132.                 if (field[j].indexOf(0) < 0) {
  133.                     field.splice(j, 1);
  134.                     field.unshift([]);
  135.                     for (i=0; i<W; ++i)
  136.                         field[0][i] = 0;
  137.                 }
  139.             count++;
  140.             if (count/10 >= SPEED.length)
  141.                 count = 0;
  142.         }
  144.         private function pick():void {
  145.             piece = next;
  146.             if (piece != null) {
  147.                 px = (W-piece[0].length)/2;
  148.                 py = 0;
  149.                 if (!space(px, py, piece))
  150.                     text.text="GAME OVER";
  151.             }
  152.             next = PAT[int(Math.random()*PAT.length)];
  153.         }
  154.     }
  155. }
noswf

Tetris Tetris3D [diff(131)]

  1. // forked from flashrod's Tetris
  2. package {
  3.     import flash.display.Sprite;
  4.     import flash.text.TextField;
  5.     import flash.events.Event;
  6.     import flash.events.KeyboardEvent;
  7.     import flash.utils.getTimer;
  9.     import org.papervision3d.materials.*;
  10.     import org.papervision3d.materials.utils.*;
  11.     import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
  12.     import org.papervision3d.lights.PointLight3D;
  13.     import org.papervision3d.objects.*;
  14.     import org.papervision3d.objects.primitives.*
  15.     import org.papervision3d.view.*;
  16.     import org.papervision3d.scenes.Scene3D;
  18.     [SWF(backgroundColor = "0x000000", frameRate = "24")]
  19.     
  20.     public class Tetris extends BasicView {
  21.         private const W:int = 10;
  22.         private const H:int = 20;
  23.         private const UNIT:int = 16;
  24.         private const COLOR:Array =[0x000000, 0x00FFFF, 0xFFFF00, 0x22FF22, 0xFF2222, 0x4444FF, 0xFF8844, 0xFF22FF];
  25.         private const PAT:Array =[
  26.             [[1, 1, 1, 1]],
  27.             [[0, 2, 0], [2, 2, 2]],
  28.             [[3, 3, 0], [0, 3, 3]],
  29.             [[0, 4, 4], [4, 4, 0]],
  30.             [[5, 5], [5, 0], [5, 0]],
  31.             [[6, 6], [0, 6], [0, 6]],
  32.             [[7, 7], [7, 7]]
  33.         ];
  34.         private const SPEED:Array = [30, 20, 10, 5];
  36.         private const VK_H:int = 72; // h
  37.         private const VK_J:int = 74; // j
  38.         private const VK_K:int = 75; // k
  39.         private const VK_L:int = 76; // l
  40.         private const VK_SPC:int = 32; // space
  42.         private var field:Array = [];
  43.         private var piece:Array;
  44.         private var next:Array;
  45.         private var text:TextField = new TextField();
  46.         private var keytable:Array = [];
  47.         private var count:int = 0;
  48.         private var step:int = 0;
  49.         private var px:int;
  50.         private var py:int;
  52.         private var light:PointLight3D;
  54.         public function Tetris() {
  55.             Wonderfl.capture_delay(25);
  57.             light = new PointLight3D(false);
  58.             light.x = 500;
  59.             light.y = -750;
  60.             light.z = 1500;
  62.             text.x = 300;
  63.             text.textColor = 0xFFFFFF;
  64.             text.text="Next:";
  65.             addChild(text);
  66.             var t:TextField = new TextField();
  67.             t.textColor = 0xFFFFFF;
  68.             t.text = "Keys: H, J, K, L, SPACE";
  69.             t.scaleX = t.scaleY = 1.25;
  70.             t.width = 250;
  72.             addChild(t);
  73.             field = new Array(H).map(function():*{
  74.                     return new Array(W).map(function():*{
  75.                             return 0;
  76.                         })
  77.                 });
  78.             keytable[VK_H] = function():void {px -= space(px-1, py, piece)};
  79.             keytable[VK_J] = function():void {rotate(true)};
  80.             keytable[VK_K] = function():void {rotate(false)};
  81.             keytable[VK_L] = function():void {px += space(px+1, py, piece)};
  82.             keytable[VK_SPC] = function():void {drop(); pick();};
  83.             stage.addEventListener(KeyboardEvent.KEY_DOWN, function(e:KeyboardEvent):void {
  84.                     if (keytable[e.keyCode]) {
  85.                         var oldpx:int = px;
  86.                         var oldpy:int = py;
  87.                         keytable[e.keyCode]();
  88.                         repaint();
  89.                     }
  90.                 });
  91.             pick();
  92.             pick();
  93.             addEventListener(Event.ENTER_FRAME, function(e:Event):void {
  94.                     if (--step < 0) {
  95.                         step=SPEED[int(count/10)];
  96.                         if (space(px, py+1, piece)) {
  97.                             ++py;
  98.                             repaint();
  99.                         } else {
  100.                             drop();
  101.                             pick();
  102.                         }
  103.                     }
  104.                     //repaint();
  105.                 });
  106.         }
  108.         private function rotate(clock:Boolean):void {
  109.             var r:Array = new Array(piece[0].length).map(function():*{return [];});
  110.             for (var j:int = 0; j<piece.length; ++j)
  111.             for (var i:int = 0; i < r.length; ++i)
  112.             if (clock)
  113.             r[i][piece.length-1-j] = piece[j][i];
  114.             else
  115.             r[r.length-1-i][j] = piece[j][i];
  116.             if (space(px, py, r))
  117.             piece = r;
  118.         }
  120.         private function repaint():void {
  121.             // TODO:
  122.             // Reuse Scene3D and Cube objects.
  123.             // Don't recreate on every repaint.
  124.             
  125.             scene = new Scene3D;
  127.             for( var x:int = -1; x <= W; x++ ) {
  128.                 scene.addChild( cube( x, -1, 0x444444 ) );
  129.                 scene.addChild( cube( x, H, 0x444444 ) );
  130.             }
  131.             for( var y:int = -1; y <= H; y++ ) {
  132.                 scene.addChild( cube( -1, y, 0x444444 ) );
  133.                 scene.addChild( cube( W, y, 0x444444 ) );
  134.             }
  136.             //graphics.clear();
  137.             for (var j:int = 0; j < H; ++j) 
  138.             for (var i:int = 0; i < W; ++i) {
  139.                 var g:int = 0;
  140.                 if (py <= j && j < (py+piece.length) && px <= i && i < (px+piece[0].length))
  141.                 g = piece[j-py][i-px];
  142.                 if (g == 0)
  143.                 g = field[j][i];
  144.                 //graphics.beginFill(COLOR[g]);
  145.                 //graphics.drawRect(i*UNIT, j*UNIT, UNIT, UNIT);
  147.                 if(g) scene.addChild( cube( i, j, COLOR[g] ) );
  148.             }
  150.             for (j = 0; j < next.length; ++j)
  151.             for (i = 0; i < next[j].length; ++i) {
  152.                 g = next[j][i];
  153.                 //graphics.beginFill(COLOR[ci]);
  154.                 //graphics.drawRect((i+W+1)*UNIT, (j+2)*UNIT, UNIT, UNIT);
  156.                 if(g) scene.addChild( cube( i+W , j-H/2+1, COLOR[g], 3, 3 ) );
  157.             }
  159.             camera.z = 300;
  160.             camera.y = -120;
  161.             renderer.renderScene( scene, camera, viewport );
  162.         }
  164.         private function cube( x:int, y:int, c:uint, w:int = W, h:int = H ):Cube {
  165.             var mlist:MaterialsList = new MaterialsList( { all : new FlatShadeMaterial(light,c) } );            
  166.             var ret:Cube = new Cube( mlist, UNIT, UNIT, UNIT );
  167.             ret.x = -(x - w/2) * UNIT * 1.1;
  168.             ret.y = -(y - h/2) * UNIT * 1.1;
  169.             return ret;
  170.         }
  171.         
  173.         private function space(x:int, y:int, p:Array):int {
  174.             for (var j:int = 0; j < p.length; ++j) {
  175.                 if (0 > (y+j) || (y+j) >= H)
  176.                 return 0;
  177.                 for (var i:int = 0; i < p[j].length; ++i) {
  178.                     if (0 > (x+i) || (x+i) >= W)
  179.                     return 0;
  180.                     if (p[j][i] && field[y+j][x+i])
  181.                     return 0;
  182.                 }
  183.             }
  184.             return 1;
  185.         }
  187.         private function drop():void {
  188.             for (; space(px, py+1, piece); py++)
  189.             ;
  190.             for (var j:int = 0; j < piece.length; ++j)
  191.             for (var i:int = 0; i < piece[j].length; ++i)
  192.             if (piece[j][i])
  193.             field[py+j][px+i] = piece[j][i];
  194.             for (j=0; j<H; ++j)
  195.             if (field[j].indexOf(0) < 0) {
  196.                 field.splice(j, 1);
  197.                 field.unshift([]);
  198.                 for (i=0; i<W; ++i)
  199.                 field[0][i] = 0;
  200.             }
  202.             count++;
  203.             if (count/10 >= SPEED.length)
  204.             count = 0;
  205.         }
  207.         private function pick():void {
  208.             piece = next;
  209.             if (piece != null) {
  210.                 px = (W-piece[0].length)/2;
  211.                 py = 0;
  212.                 if (!space(px, py, piece))
  213.                 text.text="GAME OVER";
  214.             }
  215.             next = PAT[int(Math.random()*PAT.length)];
  216.         }
  217.     }
  218. }
noswf

Tetris forked from: Tetris [diff(146)]

  1. // code name wars
  3. package {
  4.     import flash.display.Sprite;
  5.     import flash.text.TextField;
  6.     import flash.events.Event;
  7.     import flash.events.KeyboardEvent;
  9.     public class wars extends Sprite {
  10.        
  11.         public function wars() {
  12.          
  13.         }
  15.     }
  16. }
noswf
Get Adobe Flash Player