`

[转]使用Away3D引擎的Flash3D推箱子游戏原型 - 最终版本

游戏360Flash资讯J# 
阅读更多
http://bbs.9ria.com/viewthread.php?tid=76326&extra=page%3D1%26amp%3Borderby%3Ddateline%26amp%3Bfilter%3D2592000
资讯类型: 翻译
来源页面: http://www.emanueleferonato.com/2011/02/28/flash-3d-sokoban-prototype-with-away3d-%E2%80%93-final-version/
资讯原标题: Flash 3D Sokoban Prototype with Away3D – final version
资讯原作者: Heorhiy
我的评论:我很惭愧，其实这已经不是新闻了。不过还好，这个时效性不是很强……上帝啊，宽恕我的罪过吧……阿门……
对这篇文你有啥看法，跟贴说说吧！欢迎口水和板砖，哈哈。欢迎大家和我们一同分享更多资讯。



这是Away3D中的脚本，其中包括我在Flare3D版本中展示的同样的功能。

这里有几个问题，如果像我在62行那样使用Z轴排序的话，像246和248行那样更改了箱子顶部材质，一旦越过了目标，并且帧率很低，那就不对了。

不管怎么样，下面这些就是它的代码： 
package {
        //需要导入的Flash内置类
        import flash.display.Sprite;
        import flash.events.Event;
        import flash.events.KeyboardEvent;
        import flash.geom.Vector3D;
        import flash.display.BitmapData;
        //需要导入的Away3D引擎的内置类
        import away3d.containers.*;
        import away3d.primitives.*;
        import away3d.cameras.*;
        import away3d.core.render.*;
        import away3d.materials.*;
        import away3d.lights.DirectionalLight3D;
        import away3d.debug.*;
        public class Main extends Sprite {
                private const CUBESIZE:Number=50;
                //推箱子演示的玩家等级和玩家位置
                private var levels:Array=[[1,1,1,1,0,0,0,0],[1,0,0,1,1,1,1,1],[1,0,2,0,0,3,0,1],[1,0,3,0,0,2,4,1],[1,1,1,0,0,1,1,1],[0,0,1,1,1,1,0,0]];
                private var playerCol:uint;
                private var playerRow:uint;
                private var playerRotation:Number=0;
                private var playerAngle:Number=0;
                private var playerMovement:Number=0;
                private var dRow:int;
                private var dCol:int;
                //Away3D引擎变量
                private var view:View3D;// View3D类表示绘图背景
                private var theCamera:SpringCam;// 自定义一个摄像机来管理第一和第三人物摄像机
                private var player:Sphere;// 玩家控制物体
                private var cameraTarget:Sphere;
                private var movingCrate:Cube;// 箱子物体
                // 位图对象
                private var crateBitmap:BitmapData=new BitmapData(256,256);
                private var crateTopBitmap:BitmapData=new BitmapData(256,256);
                private var floorBitmap:BitmapData=new BitmapData(256,256);
                private var wallBitmap:BitmapData=new BitmapData(256,256);
                private var goalBitmap:BitmapData=new BitmapData(256,256);
                private var crateTopGoalBitmap:BitmapData=new BitmapData(256,256);
                private var backBitmap:BitmapData=new BitmapData(512,512);
                private var playerBitmap:BitmapData=new BitmapData(512,512);
                // 一些材质对象
                private var floorMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(floorBitmap);
                private var wallMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(wallBitmap);
                private var goalMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(goalBitmap);
                private var crateMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(crateBitmap);
                private var crateTopMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(crateTopBitmap);
                private var crateTopGoalMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(crateTopGoalBitmap);
                private var backMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(backBitmap);
                private var playerMaterial:WhiteShadingBitmapMaterial=new WhiteShadingBitmapMaterial(playerBitmap);
                function Main() {
                        floorBitmap.draw(new floorPic(256,256));
                        wallBitmap.draw(new wallPic(256,256));
                        crateBitmap.draw(new cratePic(256,256));
                        crateTopBitmap.draw(new crateTopPic(256,256));
                        crateTopGoalBitmap.draw(new crateTopGoalPic(256,256));
                        goalBitmap.draw(new goalPic(256,256));
                        backBitmap.draw(new backPic(512,512));
                        playerBitmap.draw(new playerPic(512,512));
                        // 场景设置
                        view=new View3D({x:320,y:240});
                        //view.renderer = Renderer.CORRECT_Z_ORDER;
                        var stats:AwayStats=new AwayStats(view);
                        addChild(view);
                        addChild(stats);
                        theCamera= new SpringCam();
                        view.camera=theCamera;
                        var light:DirectionalLight3D = new DirectionalLight3D();
                        light.direction=new Vector3D(CUBESIZE*10,- CUBESIZE*6,CUBESIZE*4);
                        view.scene.addLight(light);
                        var sky:Skybox=new Skybox(backMaterial,backMaterial,backMaterial,backMaterial,backMaterial,backMaterial);
                        view.scene.addChild(sky);
                        // 等级结构设置
                        var cube=Cube;
                        for (var i:uint=0; i<6; i++) {
                                for (var j:uint=0; j<8; j++) {
                                        switch (levels[i][j]) {
                                                case 0 :
                                                        cube=new Cube({material:floorMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE/2,x:CUBESIZE*i,y:0,z:CUBESIZE*j});
                                                        view.scene.addChild(cube);
                                                        break;
                                                case 1 :
                                                        cube=new Cube({material:floorMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE/2,x:CUBESIZE*i,y:0,z:CUBESIZE*j});
                                                        view.scene.addChild(cube);
                                                        cube=new Cube({material:wallMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE,x:CUBESIZE*i,y:CUBESIZE*3/4,z:CUBESIZE*j});
                                                        view.scene.addChild(cube);
                                                        break;
                                                case 2 :
                                                        cube=new Cube({material:goalMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE/2,x:CUBESIZE*i,y:0,z:CUBESIZE*j});
                                                        view.scene.addChild(cube);
                                                        break;
                                                case 3 :
                                                        cube=new Cube({material:floorMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE/2,x:CUBESIZE*i,y:0,z:CUBESIZE*j});
                                                        view.scene.addChild(cube);
                                                        cube=new Cube({material:crateMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE,x:CUBESIZE*i,y:CUBESIZE*3/4,z:CUBESIZE*j});
                                                        cube.cubeMaterials.bottom=crateTopMaterial;
                                                        cube.name="crate_"+i+"_"+j;
                                                        view.scene.addChild(cube);
                                                        break;
                                                case 4 :
                                                        cube=new Cube({material:floorMaterial,depth:CUBESIZE,width:CUBESIZE,height:CUBESIZE/2,x:CUBESIZE*i,y:0,z:CUBESIZE*j});
                                                        view.scene.addChild(cube);
                                                        player=new Sphere({material:playerMaterial,radius:CUBESIZE/2,segmentsW:16,segmentsH:16,x:CUBESIZE*i,y:CUBESIZE*3/4,z:CUBESIZE*j});
                                                        view.scene.addChild(player);
                                                        cameraTarget=new Sphere({material:playerMaterial,radius:CUBESIZE/5,segmentsW:4,segmentsH:4,x:CUBESIZE*i,y:CUBESIZE*3/4,z:CUBESIZE*j});
                                                        view.scene.addChild(cameraTarget);
                                                        playerCol=j;
                                                        playerRow=i;
                                                        break;
                                        }
                                }
                        }
                        // 事件监听器
                        addEventListener(Event.ENTER_FRAME,onEnterFrm);
                        stage.addEventListener(KeyboardEvent.KEY_DOWN,onKeyDwn);
                }
                private function onKeyDwn(e:KeyboardEvent):void {
                        if (playerRotation==0&&playerMovement==0) {
                                switch (e.keyCode) {
                                        case 37 :
                                                playerRotation=-9;
                                                break;
                                        case 38 :
                                                movingCrate=null;
                                                var playerAngle:Number=Math.round(player.rotationY)%360;
                                                if (playerAngle<0) {
                                                        playerAngle+=360;
                                                }
                                                // 我们需要判断出当前的行列数值
                                                // 并且新的行列数值将取决于玩家的方向
                                                switch (playerAngle) {
                                                        case 0 :
                                                                dRow=0;
                                                                dCol=-1;
                                                                break;
                                                        case 90 :
                                                                dRow=-1;
                                                                dCol=0;
                                                                break;
                                                        case 180 :
                                                                dRow=0;
                                                                dCol=1;
                                                                break;
                                                        case 270 :
                                                                dRow=1;
                                                                dCol=0;
                                                                break;
                                                }
                                                if (levels[playerRow+dRow][playerCol+dCol]==0||levels[playerRow+dRow][playerCol+dCol]==2) {
                                                        // 玩家可以移动了
                                                        playerMovement=- CUBESIZE/10;
                                                } else {
                                                        if (levels[playerRow+dRow][playerCol+dCol]==3||levels[playerRow+dRow][playerCol+dCol]==5) {
                                                                if (levels[playerRow+2*dRow][playerCol+2*dCol]==0||levels[playerRow+2*dRow][playerCol+2*dCol]==2) {
                                                                        // 玩家可以移动并推动箱子
                                                                        movingCrate=view.scene.getChildByName("crate_"+(playerRow+dRow)+"_"+(playerCol+dCol))as Cube;
                                                                        playerMovement=- CUBESIZE/10;
                                                                }
                                                        }
                                                }
                                                break;
                                        case 39 :
                                                playerRotation=9;
                                                break;
                                }
                        }
                }
                private function onEnterFrm(e:Event):void {
                        if (playerRotation) {
                                // 下面的代码是Away3D如何旋转一个物体
                                player.rotationY+=playerRotation;
                                cameraTarget.rotationY+=playerRotation;
                                var reachedAngle:Number=Math.round(player.rotationY);
                                if (reachedAngle%90==0) {
                                        playerRotation=0;
                                }
                        }
                        if (playerMovement) {
                                playerAngle=Math.round(player.rotationY)%360;
                                if (playerAngle<0) {
                                        playerAngle+=360;
                                }
                                // 下面的代码是Away3D如何移动一个物体
                                cameraTarget.moveForward(playerMovement);
                                switch (playerAngle) {
                                        case 0 :
                                                player.z+=playerMovement;
                                                if (Math.round(player.rotationZ)%360==0) {
                                                        player.rotationX+=18;
                                                } else {
                                                        player.rotationX-=18;
                                                }
                                                break;
                                        case 90 :
                                                player.x+=playerMovement;
                                                player.rotationZ+=18;
                                                break;
                                        case 180 :
                                                player.z-=playerMovement;
                                                if (Math.round(player.rotationZ)%360==0) {
                                                        player.rotationX+=18;
                                                } else {
                                                        player.rotationX-=18;
                                                }
                                                break;
                                        case 270 :
                                                player.x-=playerMovement;
                                                player.rotationZ-=18;
                                                break;
                                }
                                if (movingCrate) {
                                        if (playerAngle<0) {
                                                playerAngle+=360;
                                        }
                                        switch (playerAngle) {
                                                case 0 :
                                                        movingCrate.moveForward(playerMovement);
                                                        break;
                                                case 90 :
                                                        movingCrate.moveRight(playerMovement);
                                                        break;
                                                case 180 :
                                                        movingCrate.moveBackward(playerMovement);
                                                        break;
                                                case 270 :
                                                        movingCrate.moveLeft(playerMovement);
                                                        break;
                                        }
                                }
                                // 我们需要通过这种方式来判断玩家控制的物体是否到达目的地
                                if (Math.round(player.rotationY)%180==0) {
                                        if (Math.round(player.z)%CUBESIZE==0) {
                                                playerMovement=0;
                                        }
                                } else {
                                        if (Math.round(player.x)%CUBESIZE==0) {
                                                playerMovement=0;
                                        }
                                }
                                if (playerMovement==0) {
                                        levels[playerRow+dRow][playerCol+dCol]+=4;
                                        levels[playerRow][playerCol]-=4;
                                        if (movingCrate) {
                                                levels[playerRow+2*dRow][playerCol+2*dCol]+=3;
                                                if (levels[playerRow+2*dRow][playerCol+2*dCol]==5) {
                                                        movingCrate.cubeMaterials.bottom=crateTopGoalMaterial;
                                                } else {
                                                        movingCrate.cubeMaterials.bottom=crateTopMaterial;
                                                }
                                                levels[playerRow+dRow][playerCol+dCol]-=3;
                                                movingCrate.name="crate_"+(playerRow+2*dRow)+"_"+(playerCol+2*dCol);
                                                movingCrate=null;
                                        }
                                        playerRow+=dRow;
                                        playerCol+=dCol;
                                }
                        }
                        // 摄像机管理
                        theCamera.target=cameraTarget;
                        theCamera.positionOffset=new Vector3D(0,CUBESIZE*8,CUBESIZE*6);
                        theCamera.lookOffset=new Vector3D(0,0,-2*CUBESIZE);
                        theCamera.damping=10;
                        theCamera.view;
                        view.render();

                }
        }
}

分享到：
| [转]连连看核心算法详解
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    flash 3D引擎away3d源码

    flash 3D引擎　away3d源码 flash 3D引擎　away3d源码 flash 3D引擎　away3d源码 flash 3D引擎　away3d源码 flash 3D引擎　away3d源码 flash 3D引擎　away3d源码

    away3d引擎Flash

    Away3D 引擎利用了硬件加速的Stage3D API，这是一个在Flash Player 11及以后版本中引入的特性，它极大地提升了Flash中的3D图形处理能力。通过这个API，Away3D可以创建出流畅、细腻的3D图像，包括光照、纹理映射、...

    最新 Away3D 引擎

    Away3D 是一款基于Flash平台的高性能三维图形引擎，它允许开发者在网页上创建复杂的3D应用程序，包括游戏、交互式展示以及虚拟现实环境。这款引擎以其高效、易用和功能强大而备受赞誉，尤其在Flash Player 10及更高...

    AS3.0 Away3D引擎-4.14-gold最新版

    Away3D引擎是一款基于ActionScript 3.0的开源3D图形库，专门用于在Adobe Flash Player和Adobe AIR环境中创建高质量的3D图形和应用程序。它的最新版本是4.14-gold，这个版本带来了诸多改进和新特性，旨在提供更高效、...

    Away3D Flash 3D引擎

    Away3D是一款强大的开源Flash 3D引擎，它为开发者提供了在Adobe Flash Player环境中构建复杂的3D应用程序的能力。自发布以来，Away3D因其高效、稳定和易用性而受到广泛的赞誉，尤其对于那些希望在网页上实现互动3D...

    flex中使用away3d引擎播放的帧动画示例

    而Away3D则是Flash平台上的一个高性能3D渲染引擎，支持硬件加速，能够处理复杂的3D场景和动画。 帧动画是序列图像的连续展示，常用于创建动态效果。在3D环境中，帧动画可以用来控制模型的运动、纹理变化等。在Away...

    away3d开发引擎包

    3. ** Away3D-Core** - "away3d-core-fp11-4.1.6"是Away3D的核心库，针对Flash Player 11及更高版本优化。这个库包含了基本的3D对象和类，如Scene3D、Camera3D、DisplayObject3D，以及各种几何体和渲染管道。 4. **...

    Away3D 一款能够应用于Flash或Flex平台中的强大的实时三维引擎

    Away3D 是一款强大的实时三维引擎，专为Flash或Flex平台设计。它的主要目标是提供一个高效的3D渲染环境，让开发者能够创建出互动性强、视觉效果丰富的3D应用程序。Away3D 支持ActionScript 3.0，这意味着它可以无缝...

    Away3D中文学习资料集锦打包下载

    Away3D中文学习资料集锦打包下载 Away3D中文学习资料集锦打包下载 Away3D中文学习资料集锦...学习笔记1 - 戏说Flash 三维引擎 学习笔记2-三维世界的四个基本构件 学习笔记3--3D世界的坐标系 学习笔记4-View3D（视口）

    3d版推箱子sokoaway3

    而“3D推箱子SokoAway3”则是在传统二维基础上的创新升级，利用先进的Away3D引擎，将游戏带入了立体空间，为玩家提供了更为丰富和真实的视觉体验。 Away3D是基于ActionScript 3.0的3D图形库，它允许开发者在Flash...

    away3d-away3d-examples

    Away3D是基于Adobe Flash Platform的开源3D引擎，它为Web开发人员提供了一种高效、强大的方式来创建交互式三维图形应用。"away3d-away3d-examples"项目，正如其名，是一个包含各种示例和实例的集合，旨在帮助开发者...

    away3d核心运行库fp9版本

    Away3D是一个高度优化的，基于ActionScript 3的开源3D引擎，专为Adobe Flash Player平台设计。本次我们关注的是其针对Flash Player 9（简称FP9）的核心运行库——away3D-core-fp9-master。这个版本为Flash CS3用户...

    Away3D 源代码

    Away3D是一款强大的开源Flash 3D引擎，用于在Adobe Flash平台上创建高质量的3D图形和交互式应用程序。它的最新版本4.1 Alpha是开发者们手中的一个强大工具，旨在为Web上的3D体验提供高性能和易用性。下面将详细介绍...

    away3d 4.1.0 swc

    Away3D是一个广泛使用的开源框架，专为Adobe Flash Platform设计，用于创建高质量的3D图形应用程序。在标题提到的"away3d 4.1.0 swc"中，SWC文件是一种库包格式，常用于Flex和ActionScript项目，它包含编译后的类和...

    基于away3d引擎的汽车换肤demo

    在“基于away3d引擎的汽车换肤demo”中，我们能够看到Away3D引擎在3D场景构建、模型渲染以及交互设计上的卓越表现，仿佛置身于一款类似“极品飞车”的游戏中，选择心爱的座驾，感受视觉盛宴。 首先，我们来深入探讨...

    Away3D 基础教程

    《Away3D基础教程》是一本专注于Flash 3D开发的资源集合，旨在帮助开发者掌握Away3D这一强大的开源框架。Away3D是基于ActionScript 3.0的，为Flash Player和Adobe AIR平台提供了高性能的3D图形渲染能力。在Flash 3D...

    Flash_away3d_2.4.0 / 3.4.0(引擎)

    《Away3D：Flash平台的3D引擎探索》 Away3D是一款强大的开源3D图形引擎，专为Adobe Flash平台设计。它允许开发者在Flash Player或Adobe AIR环境中创建丰富的交互式3D应用，包括游戏、可视化工具和网页增强。这款...

    away3d_2_2_0.zip_3D 开源_3D引擎_away3d_2_0_0_away3d_2_0_0.zip_away3d

    《Away3D：一款强大的Flash 3D引擎》 Away3D，作为一款开源的Flash 3D引擎，自发布以来便受到了广大开发者和设计师的热烈欢迎。它以其高效、灵活和功能强大著称，为Flash平台带来了丰富的三维图形渲染能力，让网页...

    Away3D汽车展示

    Away3D作为一款强大的Flash平台上的开源3D引擎，为开发者提供了构建互动3D应用程序的强大工具。本文将深入探讨“Away3D汽车展示”项目，分析其核心技术和实现细节。 首先，我们来看一下项目的基础——Away3D 4.06...

Magicbox
Global site tag (gtag.js) - Google Analytics