寻路测试

最新推荐文章于 2024-03-08 14:00:14 发布
最新推荐文章于 2024-03-08 14:00:14 发布
阅读量643 收藏
点赞数
分类专栏： AS3 理论 文章标签： a-star a-寻路 寻路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linjf520/article/details/78516551
版权
AS3 同时被 2 个专栏收录
85 篇文章 0 订阅
订阅专栏
理论
47 篇文章 0 订阅
订阅专栏 
package
{
    import flash.display.Graphics;
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.utils.getTimer;


    /**
     * [description]
     * @author Jave.Lin
     * @date 2017-11-11
     */
    [SWF(width=800,height=600,frameRate=60)]
    public class TestingAStar extends Sprite
    {
        public static const w : int = 800;
        public static const h : int = 600;
        public static const divNum : int= 20;
        public static const gs : int = w /divNum;
        public static const xCount : int = w / gs;
        public static const yCount : int = h / gs;

        public function TestingAStar()
        {
            stage.frameRate = 60;
            stage.color = 0xbbbbbb;
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;

            function __calH( from : Node, to : Node ) : int
            {
                return ( Math.abs( to.x - from.x ) + Math.abs( to.y - from.y ) ) * 10;
            }

            function __drawNode( g : Graphics, node : Node, setColor : Boolean = false, settingColor : uint = 0, alpha : Number = 1, line : Number = 0, lineColor : uint = 0 ) : void
            {
                if ( setColor )
                {
                    color = settingColor;
                }
                else
                {
                    if ( node.block )
                    {
                        color = 0;
                    }
                    else
                    {
//                      brightness = 255 * ( node.g / colorRange );
//                      color = ( brightness << 16 ) + ( brightness << 8 ) + ( brightness );
                        color = 0xffffff;
                    }
                }
                graphics.lineStyle( line, lineColor, 1 );
                graphics.beginFill( color, alpha );
                graphics.drawRect( node.x * gs, node.y * gs, gs, gs );
            }

            function __getNode( x : int, y : int ) : Node
            {
                if ( x < 0 || x >= map[ 0 ].length ) return null;
                if ( y < 0 || y >= map.length ) return null;
                return map[ y ][ x ];
            }

            function __getRanWalkable() : Node
            {
                var node : Node;
                do
                {
                    var y : int = Math.random() * yCount;
                    var x : int = Math.random() * xCount;
                    node = __getNode( x, y );
                } while ( node.block );
                return node;
            }

            const nearOffset : Array = [
                0,-1,//up
                0,1,//down
                -1,0,//left
                1,0,//right

                -1,-1,//up left
                1,-1,//up right
                -1,1,//down left
                1,1//down right
            ];

            var map : Array = [];


            for ( var yI : int = 0; yI < yCount; ++yI )
            {
                var colsArr : Array = [];
                map.push( colsArr );
                for ( var xI : int = 0; xI < xCount; ++xI )
                {
                    var node : Node = new Node();
                    node.x = xI;
                    node.y = yI;
                    node.block = Math.random() < 0.3;
                    node.g = 10;
                    colsArr.push( node );
                }
            }

            var color : uint;
            var startNode : Node = __getRanWalkable();
            var endNode : Node;
            do
            {
                endNode = __getRanWalkable();
            } while ( endNode.x == startNode.x && endNode.y == startNode.y );

            const ACT_OPEN : int = 1;
            const ACT_CLOSED : int = 2;
            const ACT_PATH : int = 3;

            const DIAGONAL : Boolean = true;

            var openList : Array = [];
            var closedList : Array = [];
            var pathList : Array = [];

            var actionShape : Shape = new Shape();

            var startX : int = startNode.x;
            var startY : int = startNode.y;

            var endX : int = endNode.x;
            var endY : int = endNode.y;

            var curX : int = startX;
            var curY : int = startY;

            trace( "sx,sy:", startX, startY, "ex,ey:", endX, endY, "cx,cy:", curX, curY );
            var actionIdx : int = 0;
            var iterateNearOffsetActionIdx : int = 0;

            addChild( actionShape );

            openList.length = 0;
            closedList.length = 0;

            closedList.push( startNode );

            var gridInfoViewPool : Array = [];
            var gridInfoViewList : Array = [];
            function __allocateGridView() : GridInfoView
            {
                var ret : GridInfoView = gridInfoViewPool.pop();
                if ( ret == null ) ret = new GridInfoView();
                return ret;
            }

            function __recycleGridView( item : GridInfoView ) : void
            {
                gridInfoViewPool.push( item );
                if ( item.parent ) item.parent.removeChild( item );
            }

            function __iterateNearOffset() : Node
            {
                var idx : int = iterateNearOffsetActionIdx;
                var tx : int = nearOffset[ idx * 2 + 0 ] + curX;
                var ty : int = nearOffset[ idx * 2 + 1 ] + curY;
                var ret : Node = __getNode( tx, ty );
                ++iterateNearOffsetActionIdx;
                return ret;
            }

            function __iterateNearOffsetOneRound() : Boolean
            {
                var ret : Boolean = false;
                var idx : int = iterateNearOffsetActionIdx;
                if ( DIAGONAL )
                {
                    trace( "idx:", idx , " >= 8" );
                    if ( idx >= 8 )
                    {
                        ret = true;
                    }
                }
                else
                {
                    trace( "idx:", idx , " >= 4" );
                    if ( idx >= 4 )
                    {
                        ret = true;
                    }
                }
                iterateNearOffsetActionIdx = idx;
                return ret;
            }

            function __drawActionNode( node : Node, type : int ) : void
            {
                var color : uint = 0;
                if ( type == ACT_OPEN )
                {
                    color = 0x00ff00;
                }
                else if ( type == ACT_CLOSED )
                {
                    color = 0xff0000;
                }
                else if ( type == ACT_PATH )
                {
                    color = 0x0000ff;
                }

                __drawNode( actionShape.graphics, node, true, color, 0.3, 1 );
            }

            var lastOneRound : Boolean = false;
            function __step() : void
            {
                var curNode : Node = __getNode( curX, curY );
                do
                {
                    var b : Boolean = __iterateNearOffsetOneRound();
                    if ( b )
                    {
                        break;
                    }
                    var node : Node = __iterateNearOffset();
                    b = __iterateNearOffsetOneRound();
                    if ( node )
                    {
                        if ( closedList.indexOf( node ) != -1 )
                        {
//                          node = null;
                            continue;
                        }
                        else
                        {
                            if ( node.block == false )
                            {
                                trace( "push to open list : ", node );
                                if ( openList.indexOf( node ) == -1 )
                                {
                                    openList.push( node );
                                }
                                node.g = curNode.g + ( iterateNearOffsetActionIdx > 3 ? 14 : 10 );
//                              node.g = 1 + ( iterateNearOffsetActionIdx > 3 ? 14 : 10 );
//                              node.g = ( iterateNearOffsetActionIdx > 3 ? 14 : 10 );
                                node.h = __calH( node, endNode );
                                node.f = node.g + node.h;
                                node.from = curNode;

                                if ( node.x == endNode.x && node.y == endNode.y )
                                {
                                    var tempNode : Node = endNode;
                                    while ( tempNode )
                                    {
                                        if ( tempNode.from )
                                        {
                                            pathList.push( tempNode.from );
                                        }

                                        tempNode = tempNode.from;
                                    }
                                    trace( "path was reached!" );
                                    removeEventListener( Event.ENTER_FRAME, __onEnterFrame );
                                    return;
                                }
                            }
                            else
                            {
                                node = null;
                            }
                        }
                    }
                    if ( b )
                    {
                        break;
                    }
                } while ( node == null || node.block );
                var oneRound : Boolean = b;

                if ( oneRound == true )
                {
                    // optimize with binary-tree
                    var bestNode : Node;
                    if ( openList.length > 0 )
                    {
                        openList.sortOn( "f", Array.NUMERIC );
                        if ( node && node.f == openList[ 0 ].f )
                        {
                            bestNode = node;
                            var idx : int = openList.indexOf( node );
                            if ( idx != -1 )
                            {
                                openList.splice( idx, 1 );
                            }
                        }
                        else
                        {
                            bestNode = openList.shift();
                        }
                    }
                    if ( bestNode == null )
                    {
                        trace( "un reachable path" );
                        removeEventListener( Event.ENTER_FRAME, __onEnterFrame );
                        return;
                    }
                    else if ( bestNode.x == endNode.x && bestNode.y == endNode.y )
                    {
                        var tempNode : Node = endNode;
                        while ( tempNode )
                        {
                            if ( tempNode.from )
                            {
                                pathList.push( tempNode.from );
                            }

                            tempNode = tempNode.from;
                        }
                        trace( "path was reached!" );
                        removeEventListener( Event.ENTER_FRAME, __onEnterFrame );
                        return;
                    }
                    curX = bestNode.x;
                    curY = bestNode.y;
                    iterateNearOffsetActionIdx = 0;
                    if ( closedList.indexOf( bestNode ) == -1 )
                    {
                        closedList.push( bestNode );
                    }
                    var idx : int = openList.indexOf( bestNode );
                    if ( idx != -1 )
                    {
                        openList.splice( idx, 1 );
                    }
                }
                lastOneRound = oneRound;
            }

            function __updateGridInfoViews() : void
            {
                for each ( var item : GridInfoView in gridInfoViewList )
                {
                    __recycleGridView( item );
                }
                gridInfoViewList.length = 0;

                // open list
                for each ( var node : Node in openList )
                {
                    item = __allocateGridView();
                    item.reset();
                    item.setValue( node.f, node.g, node.h );
                    item.refreshParentDirection(
                        node.from.x, node.from.y,
                        node.x, node.y, 0 );
                    addChild( item );
                    item.x = node.x * gs;
                    item.y = node.y * gs;
                    gridInfoViewList.push( item );
                }
                // closed list
                for each ( node in closedList )
                {
                    item = __allocateGridView();
                    item.reset();
                    item.setValue( node.f, node.g, node.h );
                    addChild( item );
                    item.x = node.x * gs;
                    item.y = node.y * gs;
                    gridInfoViewList.push( item );
                }
                // path list
                for each ( node in pathList )
                {
                    item = __allocateGridView();
                    item.reset();
                    item.setPathFlag();
                    item.clearValue();
                    addChild( item );
                    item.x = node.x * gs;
                    item.y = node.y * gs;
                    gridInfoViewList.push( item );
                }
            }

            function __draws() : void
            {
                graphics.clear();
                actionShape.graphics.clear();

                for ( yI = 0; yI < yCount; ++yI )
                {
                    for ( xI = 0; xI < xCount; ++xI )
                    {
                        node = __getNode( xI, yI );
                        __drawNode( graphics, node, false, 0, 1, 1 );
                    }
                }
                __drawNode( graphics, startNode, true, 0xffff00, 0.5 );
                __drawNode( graphics, endNode, true, 0xff0000, 0.5 );

                for each ( node in openList )
                {
                    __drawActionNode( node, ACT_OPEN );
                }
                for each ( node in closedList )
                {
                    __drawActionNode( node, ACT_CLOSED );
                }

                graphics.endFill();
                actionShape.graphics.endFill();

                __updateGridInfoViews();
            }

            function __onEnterFrame( e : Event ) : void
            {
                var nowT : int = getTimer();
                var et : int = nowT - time;
                if ( et >= interval )
                {
                    time = nowT;
                    et -= interval;

                    for ( var i : int = 0; i < step; ++i )
                    {
                        __step();
                    }

                    actionShape.graphics.endFill();
                }

                __draws();
            }

            var interval : int = 10;
            var time : int = getTimer();

            var step : int = Math.max( divNum / gs, 1 ); ;

            addEventListener( Event.ENTER_FRAME, __onEnterFrame );
        }
    }
}
import flash.display.Graphics;
import flash.display.Sprite;
import flash.filters.BitmapFilterQuality;
import flash.filters.GlowFilter;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;

class Node
{
    public function toString() : String
    {
        return "x,y:" + x + "," + y + ", b:" + block + ", g:" + g + ", h:" + h + ", f:" + f + ( from ? ", from:" + "[" + from.x + "," + from.y + "]": "" );
    }

    public var x : int, y : int;
    public var block : Boolean;

    public var g : int, h : int;
    public var f : int;

    public var from : Node;
}

class GridInfoView extends Sprite
{
    private static const FILTERS : Array = [
        new GlowFilter(0,1,1.2,1.2,10,BitmapFilterQuality.HIGH)
    ];
    private static const BAS : int = 4;
    private static const SAS : int = 3;
    private static const SP : Number = 0.4;
    private static const BP : Number = 0.6;

    private static function _top( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * 0.5;
        var sy : int = gs * BP;
        var tx : int = gs * 0.5;
        var ty : int = gs * SP;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx - SAS;
        sy = ty + SAS;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx + SAS;
        sy = ty + SAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _bottom( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * 0.5;
        var sy : int = gs * SP;
        var tx : int = gs * 0.5;
        var ty : int = gs * BP;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx - SAS;
        sy = ty - SAS;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx + SAS;
        sy = ty - SAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _left( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * BP;
        var sy : int = gs * 0.5;
        var tx : int = gs * SP;
        var ty : int = gs * 0.5;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx + SAS;
        sy = ty + SAS;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx + SAS;
        sy = ty - SAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _right( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * SP;
        var sy : int = gs * 0.5;
        var tx : int = gs * BP;
        var ty : int = gs * 0.5;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx - SAS;
        sy = ty + SAS;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx - SAS;
        sy = ty - SAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _top_left( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * SP;
        var sy : int = gs * BP;
        var tx : int = gs * BP;
        var ty : int = gs * SP;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx - BAS;
        sy = ty;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx;
        sy = ty + BAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _top_right( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * BP;
        var sy : int = gs * BP;
        var tx : int = gs * SP;
        var ty : int = gs * SP;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx + BAS;
        sy = ty;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx;
        sy = ty + BAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _bottom_left( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * SP;
        var sy : int = gs * SP;
        var tx : int = gs * BP;
        var ty : int = gs * BP;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx - BAS;
        sy = ty;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx;
        sy = ty - BAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    private static function _bottom_right( g : Graphics, color : uint = 0x00ff00 ) : void
    {
        var gs : int = TestingAStar.gs;
        var sx : int = gs * BP;
        var sy : int = gs * SP;
        var tx : int = gs * SP;
        var ty : int = gs * BP;

        g.lineStyle( 1, color );
        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx + BAS;
        sy = ty;

        g.moveTo( sx, sy );
        g.lineTo( tx, ty );

        sx = tx;
        sy = ty - BAS;

        g.moveTo( sx, sy );
        g.moveTo( tx, ty );
    }

    public function GridInfoView()
    {
        super();

        function __createTF() : TextField
        {
            var ret : TextField = new TextField();
            var format : TextFormat = ret.defaultTextFormat;
            format.size = TestingAStar.gs / 4;
            format.color = 0xffffff;
            format.align = "left";
            ret.defaultTextFormat = format;
            ret.autoSize = TextFieldAutoSize.LEFT;
            ret.text = "0";
            ret.filters = FILTERS;
            return ret;
        }

        tf_TL = __createTF();
        tf_TL.x = 0;
        tf_TL.y = 0;
        addChild( tf_TL );

        tf_BL = __createTF();
        tf_BL.x = 0;
        tf_BL.y = TestingAStar.gs - tf_BL.height;
        addChild( tf_BL );

        tf_BR = __createTF();
        tf_BR.x = TestingAStar.gs - tf_BR.width;
        tf_BR.y = TestingAStar.gs - tf_BL.height;
        addChild( tf_BR );

        mouseChildren = false;
        mouseEnabled = false;

        if ( tf_TL.defaultTextFormat.size < 4 )
        {
            clearValue();
        }
    }

    public function setValue( f : int, g : int, h : int ) : void
    {
        if ( tf_TL.defaultTextFormat.size > 4 )
        {
            tf_TL.text = f.toString();
            tf_BL.text = g.toString();
            tf_BR.text = h.toString();

            _layout();
        }
        else
        {
            clearValue();
        }
    }

    public function clearValue() : void
    {
        tf_TL.text = "";
        tf_BL.text = "";
        tf_BR.text = "";
    }

    public function setPathFlag() : void
    {
        var gs : int = TestingAStar.gs;
        graphics.beginFill( 0xff0000, 0.5 );
        graphics.drawCircle( gs * 0.5, gs * 0.5, gs * 0.25 );
        graphics.endFill();
    }

    public function refreshParentDirection( 
        parentX : int, parentY : int, 
        subX : int, subY : int, 
        color : uint = 0x00ff00 ) : void
    {
        if ( tf_TL.defaultTextFormat.size < 4 )
        {
            return;
        }
        var func : Function;
        if ( parentX == subX && parentY > subY )
        {
            func = _bottom;
        }
        else if ( parentX == subX && parentY < subY )
        {
            func = _top;
        }
        else if ( parentX > subX && parentY == subY )
        {
            func = _right;
        }
        else if ( parentX < subX && parentY == subY )
        {
            func = _left;
        }
        else if ( parentX < subX && parentY > subY )
        {
            func = _bottom_right;
        }
        else if ( parentX > subX && parentY > subY )
        {
            func = _bottom_left;
        }
        else if ( parentX < subX && parentY < subY )
        {
            func = _top_right;
        }
        else if ( parentX > subX && parentY < subY )
        {
            func = _top_left;
        }
        else
        {
            throw new Error();
        }
        graphics.clear();
        if ( func != null )
        {
            func( graphics, color );
        }
    }

    public function reset() : void
    {
        graphics.clear();
    }

    private function _layout() : void
    {
        tf_TL.x = 0;
        tf_TL.y = 0;

        tf_BL.x = 0;
        tf_BL.y = TestingAStar.gs - tf_BL.height;

        tf_BR.x = TestingAStar.gs - tf_BR.width;
        tf_BR.y = TestingAStar.gs - tf_BL.height;
    }

    public var tf_TL : TextField;
    public var tf_BL : TextField;
    public var tf_BR : TextField;
}

运行效果

这个运行效果是可以看到寻路过程的
算法未优化

Jave.Lin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
寻路算法实践1
Siliphen Labs
02-09 6291
最近一段时间学了 Qt , Boost , 图论基础算法 后，就做了这个练习作品。 本程序是为了测试，从点S到点D是否有通路。如果有通路，那么路径都是什么 最短的路径又是什么。    先上运行时的效果图吧。 （可执行程序和源代码下载在本帖末尾）       点击左下角的“开始搜索”按键后，就会按照按钮右边的组合框中选择的算法来搜索从S到D的路径。 目前实现的算法有：DF
7个寻路算法 效率测试
weixin_30535843的博客
11-23 179
1 void main() 2 { 3 Path *path; 4 time_t t1,t2; 5 int i, times = 10000; 6 7 t1 = clock(); 8 for(i = 0; i < times; ++i) 9 { 10 AStar::find(_...
一劳永逸地解决寻路问题
oldcoyote的专栏
07-04 2355
一劳永逸地解决寻路问题作者：PaulT译者：trcj原文：http://www.ai-blog.net/archives/000152.html通常我都会尽量避免对业内游戏产品或开发者们评头论足。但这回我不得不破一次例。我要讨论一些关于寻路的问题。为了证明这些
一文了解自动寻路算法
我的博客
05-03 3099
自动寻路算法 自动寻路算法1、地图类地图展示图代码展示2、寻路类寻路展示图代码展示3、测试主类代码展示4、寻路结果展示 主要思想来源 1、地图类 主要包含初始化地图（二维数组）、生成障碍（可随机）、寻路结果查询等功能模块 制定基础游戏规则： 0、未走过的 1、墙体 2、走过的 3、走不通的 地图展示图 代码展示 import java.util.Arrays; import java.util.Random; public class Layouts { i
寻路测试 2
O2611389的博客
09-26 87
这篇是上一篇《寻路测试》的“续集”， 上一篇的地址：http://blog.csdn.net/stevenkylelee/article/details/7246138 程序其实写完好久了。只是一直没上传上来。 本次代码工程的IDE改成了VS2008。Qt Creator还是用得不爽。IDE还是微软的VS强大。。。 总共实现的算法有：DFS，BFS，双向BFS，一个自己的启...
Unity3D AStar地图编辑与寻路测试详解
最新发布
Thomas_YXQ的博客
03-08 1264
A算法是一种常用的寻路算法，能够帮助游戏对象在地图中找到最短路径。本文将详细介绍如何在Unity3D中使用A算法进行地图编辑和寻路测试。对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！一、地图编辑首先我们需要创建一个地图，可以使用Unity3D中的Tilemap功能来快速创建地图。在Unity3D中创建一个Tilemap，然后在Tile Palette中选择合适的地图块进行绘制。可以使用不同的地图块来表示不同的地形，比如墙壁、草地、水域等。
游戏场景测试
x_xingduo_2315的博客
06-17 2301
游戏场景在百度百科中的定义是游戏中的环境、建筑、机械、道具等。游戏场景通常可以理解为根据策划的要求还原出游戏中的建筑物、树木、天空、道路等可用元素（包含武器道具等）。游戏场景的测试不仅仅要测试上述部分，还包括了程序、用户体验等其他方面的问题。 在拿到了正式美术资源之后，首先关心的就是场景的寻路和碰撞问题。寻路是游戏中人可以行走的区域，碰撞是场景中得物体所占的空间。对于这2个问题，不同的游戏有着不同的处理方式。 有的是服务端有一份数据，客户端生成一份数据，然后2份数据进行对比就可以很方便的找出不一样的地方.
寻路测试可执行
02-09
标题中的“寻路测试可执行”表明这是一个与路径查找算法相关的测试程序，它可能用于验证和比较不同的寻路算法在特定环境下的性能和效果。描述中提到的“DFS”、“BFS”、“Bellman-Ford”、“Dijkstra”以及“启发式...
寻路测试源代码
02-09
这个"寻路测试源代码"项目提供了一个可视化平台，用户可以直观地看到这些算法的实际运行过程。界面展示的结果包括路径、生成树、路径长度以及访问顺序等信息，这对于理解算法的工作原理非常有帮助。此外，用户还能...
寻路测试2可执行
06-12
标题“寻路测试2可执行”表明这是一个关于路径搜索算法的测试程序，可能是一个图形用户界面（GUI）应用，用于演示和验证各种寻路算法的效果。描述中提到了几种具体的算法，包括深度优先搜索（DFS）、广度优先搜索...
A*寻路测试，unity3dpack包，
06-17
A*寻路测试，unity3dpack包，
寻路测试2源代码
06-12
在给定的"寻路测试2源代码"中，涵盖了多种经典的寻路算法，包括深度优先搜索（DFS）、广度优先搜索（BFS）、双向BFS、启发式搜索以及最短路径算法如Bellman-Ford、Dijkstra和SPFA，还有A*算法。以下是对这些算法的...
人工智能: 自动寻路算法实现(三、A*算法)
天降风云的博客
09-20 9404
前言本篇文章是机器人自动寻路算法实现的第三章。我们要讨论的是一个在一个M×N的格子的房间中，有若干格子里有灰尘，有若干格子里有障碍物，而我们的扫地机器人则是要在不经过障碍物格子的前提下清理掉房间内的灰尘。具体的问题情景请查看人工智能: 自动寻路算法实现(一、广度优先搜索)这篇文章，即我们这个系列的第一篇文章。在前两篇文章里，我们介绍了通过广度优先搜索算法和深度优先算法来实现扫地机器人自动寻路的功能。
[解读] GuiltyGearXrd‘s Art Style : The X Factor Between 2D and 3D - GGX 3D 渲染 2D 风格
Jave.Lin 的学习笔记
12-12 8273
--- 这篇我们将 2015 GDC中的 《罪恶装备》介绍的视频内容都笔录一下 --- # 目的 对视频笔录的目的：便于后续重新回顾、搜索、确定方案时，可以快速的查看到想要的内容，而不用重新查看一遍视频的内容 --- # 注意 本篇因为笔录视频内容，会包含 ==**巨量**== 的图片，所以如果在浏览本篇文章之前，==**您的浏览终端，如果是流量有限的话，就需要注意一下**==
使用点斜式求两直线的交点
Jave.Lin 的学习笔记
09-25 8127
点斜式求直线交点：m0 = (y1 - y0) / (x1 - x0);已知：P0=(X:150, Y:50); P1=(X:200, Y:200); P2=(X:50, Y:125); P3=(X:?, Y:?);直线：L1 = P0-P1; L2 = P2-P3;P3点是：从P2作平行于X轴的直线L2，直到与L1相交的点；两线相交于：P3 因此L1可以写成：L1 = P0-P3;求P3
PS中图层混合模式的Blend公式
Jave.Lin 的学习笔记
04-07 7451
自己的总结：（伪代码+注释） // 混合模式的代入式：// 颜色的数据类型，里头分另有(RGBA/XYZW)的分量组合在， // 与单个标量的运算时：未指定分量运算时 // 默认是 float4(RGBA/XYZW)// 旧的已绘制出来的图层颜色 // 也叫：DESTINATION COLOR(个人觉得：OLD COLOR BUFFER可读性会好N多，想不明白这命名怎么回事) var o
颜色缓冲区、深度缓冲区、模板缓冲区和累积缓冲区
Jave.Lin 的学习笔记
08-11 5884
颜色缓冲区：就是帧缓冲区（图形设备的内存），需要渲染的场景的每一个像素都最终写入该缓冲区，然后由他渲染到屏幕上显示。深度缓冲区：与帧缓冲区对应，用于记录上面每个像素的深度值，通过深度缓冲区，我们可以进行深度测试，从而确定像素的遮挡关系，保证渲染正确。（注意区分深度测试和背面剔除）模板缓冲区：与深度缓冲区类似，通过设置模板缓冲每个像素的值，我们可以在渲染的时候只渲染后写像素，从而可以达到一些特殊的效果
Philosopher's Stone项目：功能与适配性测试进展
二是有输入数据的精确移动和A*寻路测试，验证角色能否准确到达指定位置。 另一个关键脚本attribute.cs负责管理角色的属性数据，包括血量、经验、金币等，进行了六种不同类型的单元测试，分别针对初始化、数据更新、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值