滑块游戏————春节

demo地址  :http://35free.net/kboy/demo.swf

 

源码下载地址:  http://35free.net/kboy/game.rar

 

 

 

 

 

 

拼图大闯关游戏!!

 

在该游戏中 滑块的大小可以通过cellWidth  cellHeight量设置  图片大小为imageWidth imageHeight

 

我这里由于时间仓促,花了三四个小时完成  所以 游戏时间,没有进形设置 以及 通过设置滑块的大小来进行关数设置的这一设置没有进行设置 在设置时只需要通过修改cellWidth 

cellHeight   就可以达到不同关的关数  他们的值越大 所分的块越少 最终 游戏也越简单  下面 我用的是imageWidth = 800;

                imageHeight = 600;

                cellWidth=400

                 cellHeight=150

这几个参数直接设置的游戏 由于时间比较赶,现在过年了,刚吃完团圆饭,所以就没有进行更深人的设置 ,以及代码的优化.

 

主要说说该游戏的思路 ! 首先通过设置 这些滑块的可滑区域!这些可滑区域用point保存  将这些可滑区域点 用数组totalPoint保存   以及当前滑块所用的区域 用数组usePoint保存

以及每一个 滑块都有上下左右四个相邻滑点 通过判断相邻滑点在可滑区域totalPoint中 而不再usePoint数组中!就表示该滑块可滑,滑动后要更新usePoint数组点!

 

家里没找到兔子图片,而我又连不了网 所以 就用了随便一张图片像大家展示  图片是链接进去的 大小为800*600

 

 

 

 

祝大家春节愉快:

 

 

下面是代码:

 

Demo :

 

 

 

package  {

   

    import com.kboy.display.BgTile;

    import com.kboy.display.Flat;

    import com.kboy.display.MessageBox;

    import com.kboy.utils.ImageUtil;

    import flash.display.Bitmap;

    import flash.display.BitmapData;

    import flash.display.DisplayObject;

    import flash.display.Sprite;

    import caurina.transitions.Tweener;

    import flash.events.Event;

    import flash.events.MouseEvent;

    import flash.events.TimerEvent;

    import flash.geom.Point;

    import flash.utils.Timer;

   

   

    public class demo extends Sprite {

       

       

        private var rightImagePosition:Array;

        private var smallImages:Array;

        private var imageWidth:int;

        private var imageHeight:int;

        /*

         * 列数与行数

         * */

        private var column:int;

        private var space:int; //不可滑的个数 默认为2   也就是第0 ,1   scrollColumn=Column 其他的不是

        ///可滑的行与列数  也就是最大的行列数 长度

        private var scrollColumn:int;

        ///private var scrollRow:int;//

       

        private var row:int;

       

       

        private var container:Sprite;

        private var bg:Sprite;

       

        private var imageContainer:Sprite;

       

       

        private var bgTileArray:Array;//背景元素数组;

       

        private var bgTileArrayCopy:Array; bgTileArray的备份

       

        private var cellWidth:int;

        private var cellHeight:int;

       

        private var totalPoint:Vector.<Point>;//可滑动的点的集合

       

        private var usePoint:Vector.<Point>;//当前使用的点的集合

       

       

        private var myImageLen:int;

       

       

        ///完成后的祝福语

        private var messageBox:MessageBox;

       

        private var tipMap:Bitmap;

       

       

        public function demo() {

            // constructor code

           

            init();

        }

       

        private function init():void {

           

           

           

            messageBox = new MessageBox(this.stage);

            trace("width:"+messageBox.width);

            totalPoint = new Vector.<Point>();

            usePoint = new Vector.<Point>();

           

            bgTileArray = [];

       

            container = new Sprite();

            this.addChild(container);

           

            container.y = 150;

           

                bg = new Sprite();

            container.addChild(bg);

           

            imageContainer = new Sprite();

            container.addChild(imageContainer);

           

           

           

           

           

           

           

           

           

         createImage();

       

         

       

           

           

    makeGame();

               

           

           

            }

           

           

           

            private function createImage():void {

                imageWidth = 800;

                imageHeight = 600;

                cellWidth=400

                 cellHeight=150            

                var bmp:BitmapData = new BmpData(imageWidth, imageHeight) as BitmapData;

           

               

            smallImages=ImageUtil.splitImage(bmp, cellWidth, cellHeight);

            column = Math.round(imageWidth / cellWidth);

            row = Math.round(imageHeight / cellHeight);  

            scrollColumn = this.column + 1;

            myImageLen = smallImages.length;

            ///scrollRow = this.row;

           

           

            ///创建提示对象

            tipMap = new Bitmap(bmp);

            tipMap.x = tipBtn.x - tipMap.width - 50;

            tipMap.y = tipBtn.y + tipBtn.height*0.5 + 0;

           

           

           

           

           

           

           

                 

                }

               

           

                   

                   

                   

                   

       

                   

        private function makeGame():void {

           

            createBg(2,cellWidth,cellHeight);

           

            sortImage();///对相片块进行随机排序        

                       

                       

 

               

       

           

           

            }

            private function finish(e:TimerEvent):void {

               

                var timer:Timer = e.currentTarget as Timer;

                var isFinished:Boolean = true;

                for (var i:int = 0; i != myImageLen;++i ) {

                   

                    if ((smallImages[i].x != Flat(smallImages[i]).originX) || (smallImages[i].y != Flat(smallImages[i]).originY)) {

                       

                        isFinished = false;

                        }

                   

                    }

                   

                   

                if (isFinished) {

                   

                   

                    timer.removeEventListener(TimerEvent.TIMER, finish);

                    timer.stop();

                    imageContainer.removeEventListener(MouseEvent.MOUSE_DOWN, onDown);

                    timer = null;

 

                    trace("____完成了");

                   

                    this.addChild(messageBox);

                   

                   

                    }

               

               

                trace("检测中");

               

               

               

                }

           

            private function sortImage():void {

               

               

                var len:int = smallImages.length;

                var display:DisplayObject;

               

                for (var i:int = 0; i < len;++i ) {

                    display = getRandomObject(this.bgTileArrayCopy) as DisplayObject;

                    smallImages[i].x = display.x;

                    smallImages[i].y = display.y;

                    Flat(smallImages[i]).configurePoint();

                imageContainer.addChild(smallImages[i]);

               

                usePoint.push(new Point(display.x,display.y));

                    ///trace(smallImages[i].height);

                   

                   

                    }

                   

                   

                    //事件侦听:

                imageContainer.addEventListener(MouseEvent.MOUSE_DOWN, onDown);

               

                tipBtn.addEventListener(MouseEvent.MOUSE_OVER, onOver);

                tipBtn.addEventListener(MouseEvent.MOUSE_OUT,onOut);

 

                /// imageContainer.addEventListener(MouseEvent.MOUSE_UP,onUp);

               

                            //当全部对其时则执行OK 播放胜利music

       

                    ///this.addEventListener(Event.ENTER_FRAME, finish);

                   

                    var timer:Timer = new Timer(250, 0);

                    timer.addEventListener(TimerEvent.TIMER,finish);

                timer.start();

               

 

               

                }

           

                private function onOver(e:MouseEvent):void {

                   

                    this.addChild(tipMap);

                   

                    其他对象虚化

                    container.alpha = 0.2;

                   

                   

                    }

               

               

                private function onOut(e:MouseEvent):void {

                    if (this.contains(tipMap))

                    this.removeChild(tipMap);

                   

                    container.alpha = 1;

                   

                    }

               

               

                private function onDown(e:MouseEvent):void {

                   

                    var sp:Flat = e.target as Flat;

                   

                                   

                           

                var index:int = pointIndex(usePoint, new Point(sp.x, sp.y));

                if (index == -1) return;

               

               

                var disX:Number = imageContainer.mouseX - sp.x;

                var disY:Number = imageContainer.mouseY - sp.y;

               

            /// trace("moueX",imageContainer.mouseX);

           

            var absX:Number = Math.abs(disX);

            var absY:Number = Math.abs(disY);

           

        /// var isMove:Boolean = false;

           

            ///水平方向

            if (absX >= absY) {

               

               

                //右边

                if (disX >= 0) {

                   

                            trace("右边");

 

                    if (moveRight(sp, index))

                            return;

                       

                   

                   

                    }

                       

                                    trace("左边");

 

                        if (moveLeft(sp, index))   

                        return;

                       

                   

                       

               

               

                }

                竖直方向

       

                   

                    //下面

                    if (disY >= 0) {

                       

                        trace("__下边");

                        if (moveDown(sp, index)) return;

                       

                        }

                   

               

                           

                        trace("__上边")

                        if (moveUp(sp,index))  return;

                           

                       

                   

                ///假如上面的代码没有执行 则执行下面的代码

               

                if (moveLeft(sp,index)) return;

                if (moveRight(sp,index)) return;

                if (moveUp(sp,index)) return;

                if (moveDown(sp,index)) return;

           

               

               

               

                                               

                                               

                                               

                                               

               

                ///trace(sp.x)

                   

                    }          

                    private function onUp(e:MouseEvent):void {

                        var sp:Flat = e.target as Flat;

                        sp.stopDrag();

                       

                       

                        }

           

            //默认空 2  也就是

            private function createBg(space:int=2,cellWidth:Number=100,cellHeight:Number=100):void {

                this.space = space;

                ///进行背景定位

                var tile:BgTile;

               

               

                for (var i:int = 0; i < this.row;++i ) {

                   

                   

                    for (var j:int = 0; j < this.scrollColumn;++j ) {

                       

                       

                        if ((i < space)&&(j==this.scrollColumn-1))  

                            continue;

                           

                       

                        tile = new BgTile(cellWidth,cellHeight);

                        bgTileArray.push(tile);

                        tile.x = j * tile.width + tile.width * 0.5;

                        tile.y = i * tile.height + tile.height * 0.5;

                       

                        bg.addChild(tile);

                       

                        totalPoint.push(new Point(tile.x,tile.y));

                       

                       

                           

                           

                        ///for 1   

                        }

                   

                    /// for 2

                   

                    }

               

               

               

                bgTileArrayCopy = bgTileArray.concat();

               

               

                }

           

           

           

            private  function move(obj:Flat,tx:Number,ty:Number):void {

               

                Tweener.addTween(obj,{time:0.5,x:tx,y:ty,onComplete:complete, onCompleteParams:[obj]});

               

               

                }

                private function complete(obj:Flat):void {

                    obj.configurePoint();

                   

                    }

               

               

               

               

                private function getRandomObject(arr:Array):Object {

                   

                    var len:int = arr.length;

                   

                    var index:int = int(Math.random() * len);

                   

                    var obj:Object = arr[index];

                   

                   

                    ///从数组中移除

                    arr.splice(index, 1);

                   

                    return obj;

                   

                   

                   

                   

                   

                   

                    }

                   

                   

                   

               

                       

                        private function moveLeft(sp:Flat,index:int):Boolean {

                           

                            var isMove:Boolean = false;

                           

                            if ((containPoint(totalPoint, sp.leftPoint) == true) && (containPoint(usePoint, sp.leftPoint) == false)) {

                   

                       

                        刷新usePoint

                        usePoint[index].x = sp.leftPoint.x;

                        usePoint[index].y = sp.leftPoint.y;

                           

                        ///缓动  左滑

                        move(sp, sp.leftPoint.x, sp.leftPoint.y);

                       

                       

                        isMove = true;

                        }

                           

                            return isMove;

                           

                            }

                           

                            private function moveRight(sp:Flat, index:int):Boolean {

                               

                                var isMove:Boolean = false;

                                if ((containPoint(totalPoint, sp.rightPoint) == true) && (containPoint(usePoint, sp.rightPoint) == false)) {

                   

                    /// var index:int = pointIndex(usePoint,new Point(sp.x, sp.y));

                       

                        刷新usePoint

                        usePoint[index].x = sp.rightPoint.x;

                        usePoint[index].y = sp.rightPoint.y;

                           

                        ///缓动  右滑

                        move(sp, sp.rightPoint.x, sp.rightPoint.y);

                       

                        isMove = true;

 

                       

                        }

                           

                        return isMove;

                                }

                               

                               

                                private function moveUp(sp:Flat, index:int):Boolean {

                                   

                                                            var isMove:Boolean=false

 

                                    if ((containPoint(totalPoint, sp.upPoint) == true) && (containPoint(usePoint, sp.upPoint) == false)) {

                   

                        var index:int = pointIndex(usePoint,new Point(sp.x, sp.y));

                       

                        刷新usePoint

                        usePoint[index].x = sp.upPoint.x;

                        usePoint[index].y = sp.upPoint.y;

                           

                        ///缓动  右滑

                        move(sp, sp.upPoint.x, sp.upPoint.y);

                        isMove = true;

 

                       

                        }

                       

                        return isMove;

                                   

                                    }

                           

                                   

                                   

                                    private function moveDown(sp:Flat, index:int):Boolean{

                           

                           

                        var isMove:Boolean=false

                    if ((containPoint(totalPoint, sp.downPoint) == true) && (containPoint(usePoint, sp.downPoint) == false)) {

                   

                        var index:int = pointIndex(usePoint,new Point(sp.x, sp.y));

                       

                        刷新usePoint

                        usePoint[index].x = sp.downPoint.x;

                        usePoint[index].y = sp.downPoint.y;

                           

                        ///缓动  右滑

                        move(sp, sp.downPoint.x, sp.downPoint.y);

                       

                        isMove = true;

                       

                        trace("_____down");

 

 

                        }

                       

                        return isMove;

                       

                       

                       

                        }

                       

                       

                        public function containPoint(arr:Vector.<Point>, pt:Point):Boolean {

                           

                            var len:int = arr.length;

                            var exist:Boolean = false;

                           

                            for (var i:int = 0; i != len;++i ) {

                               

                                if (arr[i].equals(pt)) {

                                    exist = true;

                                    }

                               

                                }

                               

                                return exist;

                           

                           

                           

                            }

                           

                       

               

                            public function pointIndex(arr:Vector.<Point>, pt:Point):int {

                               

                               

                                var len:int = arr.length;

                                var exist:int = -1;

                                        for (var i:int = 0; i != len;++i ) {

                               

                                if (arr[i].equals(pt)) {

                                    exist = i;

                                    }

                               

                                }

                               

                               

                                return exist;

                                }

       

   

                       

                       

                       

                       

       

    }

   

}

 

 

 

 

 

 

 

ImageUtil

 

 

 

 

package com.kboy.utils

{

    import com.kboy.display.Flat;

    import flash.display.Bitmap;

    import flash.display.BitmapData;

    import flash.display.DisplayObject;

    import flash.display.Sprite;

    import flash.geom.Matrix;

    ///import flash.display.IBitmapDrawable;

    /**

     * ...

     * @author dreamnight

     */

   

     /**

      * 静态方法 将指定对象分解成若干小图片 

      */

    public class ImageUtil

    {

       

   

       

       

        public static function splitImage(data:BitmapData,cellWidth:int,cellHeight:int):Array {

           

    var smallImages:Array = [];

    var storePosition:Array = [];

   

           

            //爆破的个数 :  row*column

            var  column:int=Math.round(data.width/cellWidth);//横向的个数

            var row:int=Math.round(data.height/cellHeight);//列个数

            //trace(row);

            //trace(column);

 

            var bitmap:Bitmap;

        /// var oj:Object;

            var matrix:Matrix;

            var cellBitmapData:BitmapData;

            var mc:Flat;

            for (var i:int = 0; i!=row; ++i) {

 

                for (var j:int = 0; j != column; ++j) {

                    cellBitmapData=new BitmapData(cellWidth,cellHeight);

 

                    var tx:Number=- cellWidth*j;

                    var ty:Number=- cellHeight*i;

                    matrix = new Matrix();

                    matrix.translate(tx ,ty );

                    cellBitmapData.draw(data,matrix);

                    //var rect:Rectangle = new Rectangle(i, j, cellWidth, cellHeight);

 

                    //cellcopyPixels

 

 

                    //var bitmap:Bitmap=new Bitmap(cellBitmapData);

                    bitmap=new Bitmap(cellBitmapData);

 

 

                    //对该照片进行复原定位    注意 注册点在中心

                   

                    mc = new Flat(cellWidth,cellHeight);

                    mc.addChild(bitmap);

                    bitmap.x = -bitmap.width * 0.5;

                    bitmap.y = -bitmap.height * 0.5;

                   

                    mc.x=- tx+bitmap.width*0.5

                    mc.y=- ty+bitmap.height * 0.5;

                   

                    //保存初始位置:

                    ///oj= new Object();

                trace(mc.width)

                    mc.originX = mc.x;

                    mc.originY = mc.y;

                    mc.row=i;//所在行

                    mc.column=j;//所在列

                    mc.index = i * row + j;//数组中的索引

                    mc.configurePoint();

                    smallImages.push(mc);//为了内部的交互功能  必须保存为Sprite 或者MovieClip 而不是 位图Bitmap

                   

                    matrix=null;

                   

           

           

           

            }

       

    }

       

    return smallImages;

   

   

   

 

}

 

public static function scale(obj:DisplayObject):void {

   

    obj.scaleX = obj.width / obj.width + 1;

    obj.scaleY = obj.height / obj.height + 1;

    obj.z = 0;

   

    }

   

 

 

 

 

end class

    }

 

}

 

 

 

 

MesageBox:

 

 

package com.kboy.display

{

    import flash.display.Shape;

    import flash.display.Sprite;

    import flash.display.Stage;

   

    /**

     * ...

     * @author dreamnight

     */

    public class MessageBox extends Sprite

    {

       

        private var bg:Shape;

        private var _stage:Stage;

        public function MessageBox(_stage:Stage)

        {

            this._stage = _stage;

            background();

            this.x = _stage.stageWidth * 0.5;

            this.y = _stage.stageHeight * 0.5;

           

        }

       

        public function  createText(str:String):void {

           

           

           

           

            }

       

        private function background(col:uint=0x00ffffff,alpha:Number=.5):void {

           

            bg = new Shape();

           

            bg.graphics.beginFill(col, alpha);

            bg.graphics.drawRect(0, 0, _stage.stageWidth, _stage.stageWidth);

            bg.graphics.endFill();

           

            addChild(bg);

            bg.x = -bg.width * 0.5;

            bg.y = -bg.height * 0.5;

            }

           

           

    }

 

}

 

 

 

 

 

 

Flat

 

 

 

package com.kboy.display

{

    import flash.display.Shape;

    import flash.display.Sprite;

    import flash.geom.Point;

   

    /**

     * ...

     * @author dreamnight

     *

     *

     *

     * 每块照片的滑动类

     *

     */

   

     

     

    public class Flat extends Sprite

    {

       

        /*

         * 左边点

         * */

        public var leftPoint:Point;

       

        /*

         * 右边点

         * */

        public var rightPoint:Point;

       

        /*

         * 上边点

         * */

        public var upPoint:Point;

       

        /*

         * 下边点

         * */

        public  var downPoint:Point

       

       

        /*

         * 初始  坐标

         * */

       

        public var originX:Number;

        public var originY:Number;

       

       

        /*

         * 所属的行和列

         * */

        public var column:int;

        public var row:int;

       

        /*

         * 数组中的索引

         * */

        public var index:int;

       

       

        private var shape:Shape;

        private var myW:Number;

        private var myH:Number;

        public function Flat(_w:Number=100,_h:Number=100)

        {

           

            myW = _w;

            myH = _h;

           

            shape = drawBg();

            addChild(shape);

            leftPoint = new Point();

            rightPoint = new Point();

            upPoint = new Point();

            downPoint = new Point();

           

            /*this.width = _w;

            this.height = _h;*/

           

        }

       

        ///配置周围的点

        public function configurePoint():void {

           

            leftPoint.x = this.x - this.width;

            leftPoint.y = this.y;

           

            rightPoint.x = this.x + this.width;

            rightPoint.y = this.y;

           

            upPoint.x = this.x;

            upPoint.y = this.y - this.height;

           

            downPoint.x = this.x;

            downPoint.y = this.y + this.height;

           

           

           

            }

           

           

           

        private function drawBg(col:uint=0xCC99CC):Shape {

                var sp:Shape = new Shape();

                sp.graphics.beginFill(col);

                sp.graphics.drawRect(0, 0, myW, myH);

                sp.graphics.endFill();

                sp.x = -sp.width * 0.5;

                sp.y = -sp.height * 0.5;

                return  sp;

               

               

               

                }

       

       

       

       

    }

 

}

 

 

 

 

BgTile类:

 

 

 

 

package com.kboy.display  {

   

    ///import flash.display.MovieClip;

    import flash.display.Sprite;

   

    /*

     * 注册点在中心位置 而不是左上角

     *

     * */

   

    public class BgTile extends Sprite {

       

       

        public function BgTile(_w:Number=100,_h:Number=100) {

            // constructor code

        this.width = _w;

        this.height = _h;

       

        }

    }

   

}

 

 

 

 

 

 

 

 

祝大家新年愉快!

 

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值