A. 游戲中的A星演算法怎麼寫
首先A星演算法佔內存和CPU簡直要命，之前用AS3寫的代碼90*90格僅6個敵人每次同時尋路都得卡上幾秒，還經常找不到路，反正我目前還沒想到好的優化方法。
B. 跪求 廣度，深度，A星相關演算法解決問題
八皇後是經典的回溯問題。
說一下自己的編程思想：
定義一個8×8的棋盤:int graph[8][8];初始時所有值均為0
檢查當前位置能否放置皇後，假定下標為i, j;
bool check(int i, int j)
{
判斷當前位置所在行和列是否有皇後，若有則返回false, 否則返回true;
}
然後就是搜索了.這里選擇按行進行深度優先搜索。
dfs(int i, int j)
{
if(i >= 8)
{
已經到最後一層，可以輸出結果。graph中所有標志1的地方
即為皇後所在位置。
return;
}
graph[i][j] = 1; // 在此處放置一個皇後
for(int k = 0; k < 8; k++)
if(check(i+1, k)) // 說明找到一個合適的位置
dfs(i+1, k); //向下一層移動
graph[i][j] = 0;// 回溯
}
C. lua語言a星尋路演算法路徑怎麼平滑
在項目中遇到了自動尋路的需求，於是決定開始學習一下A星，對於A星我也沒有深究，只能說是勉強搞定了需求，在這和大家分享一下，相互進步，
A星有個公式 f(x) = g(x) + h(x)
,搞清楚這個公式就好辦了，f(x)就是當前位置到下一個位置的總價值，g(x)表示實際價，這是說這一部分代價是確定的，h(x)表示估價值，就是說我
從下一個位置到到終點的代價是未知的，所以叫估價值，如圖中所示，黑色格子表示當前位置，綠色格子表示下一步可能到達的位置，即上、下、左、右這幾個方
向，紅色格子表示終點，褐色表示障礙物，現在要從黑色格子到達紅色格子，那麼黑色格子的下一步肯定是綠色格子當中的一個，黑色格子到綠色格子之間是相挨著
的，所以我們可以很明確的知道它的實際代價為1（移動一步的代價）即g(x)，綠色格子到紅色格子之間隔著很長的距離，中間還有障礙物，所以這個代價是未
知的，即h(x)，所以總的代價就為f(x) = g(x) +
h(x)，我們看到周圍有4個綠色的格子，到底走那一步比較好呢，所以我們要把這4個格子的f(x)值都求出來，然後進行排序，選擇f(x)值最小的，即
總代價最少的那個格子，以此方法繼續下去，直到到達終點 或者 地圖上沒有綠色格子了
下面來看一下這個工具類，g(x)和h(x)要選的比較合適，一般就是採用的曼哈頓演算法，即兩點在x方向和y方向的距離之和，
-- Filename: PathUtil.lua
-- Author: bzx
-- Date: 2014-07-01
-- Purpose: 尋路
mole("PathUtil", package.seeall)
local _map_data -- 地圖數據
local _open_list -- 開放節點
local _open_map -- 開放節點，為了提高性能而加
local _close_map -- 關閉節點
local _deleget -- 代理
local _dest_point -- 目標點
local _start_point -- 起點
local _path -- 路徑
-- 尋找路徑
--[[
deleget = {
g = function(point1, point2)
-- add your code
-- 返回點point1到點point2的實際代價
end
h = function(point1, point2)
-- add your code
-- 返回點point1到點point2的估算代價
end
getValue = function(j, i)
-- 返回地圖中第i行，第j列的數據 1為障礙物，0為非障礙物
end
width -- 地圖寬度
height -- 地圖高度
}
--]]
function findPath(deleget, start_point, dest_point)
_deleget = deleget
_dest_point = dest_point
_start_point = start_point
init()
while not table.isEmpty(_open_list) do
local cur_point = _open_list[1]
table.remove(_open_list, 1)
_open_map[cur_point.key] = nil
if isEqual(cur_point, dest_point) then
return makePath(cur_point)
else
_close_map[cur_point.key] = cur_point
local next_points = getNextPoints(cur_point)
for i = 1, #next_points do
local next_point = next_points[i]
if _open_map[next_point.key] == nil and _close_map[next_point.key] == nil and isObstacle(next_point) == false then
_open_map[next_point.key] = next_point
table.insert(_open_list, next_point)
end
end
table.sort(_open_list, compareF)
end
end
return nil
end
function init()
_open_list = {}
_open_map = {}
_close_map = {}
_path = {}
_map_data = {}
for i = 1, _deleget.height do
_map_data[i] = {}
for j = 1, _deleget.width do
local value = _deleget.getValue(j, i)
_map_data[i][j] = value
end
end
_open_map[getKey(_start_point)] = _start_point
table.insert(_open_list, _start_point)
end
function createPoint(x, y)
local point = {
["x"] = x,
["y"] = y,
["last"] = nil,
["g_value"] = 0,
["h_value"] = 0,
["f_value"] = 0
}
point["key"] = getKey(point)
return point
end
-- 得到下一個可以移動的點
-- @param point 當前所在點
function getNextPoints(point)
local next_points = {}
for i = 1, #_deleget.directions do
local offset = _deleget.directions[i]
local next_point = createPoint(point.x + offset[1], point.y + offset[2])
next_point["last"] = point
if next_point.x >= 1 and next_point.x <= _deleget.width and next_point.y >= 1 and next_point.y <= _deleget.height then
next_point["g_value"] = _deleget.g(point, next_point)
next_point["h_value"] = _deleget.h(point, _dest_point)--math.abs(next_points.x - _dest_point.x) + math.abs(next_points.y - _dest_point.y)
next_point["f_value"] = next_point.g_value + next_point.h_value
table.insert(next_points, next_point)
end
end
return next_points
end
-- 得到路徑
-- @param end_point 目標點
function makePath(end_point)
_path = {}
local point = end_point
while point.last ~= nil do
table.insert(_path, createPoint(point.x, point.y))
point = point.last
end
local start_point = point
table.insert(_path, start_point)
return _path
end
-- 兩個點的代價比較器
function compareF(point1, point2)
return point1.f_value < point2.f_value
end
-- 是否是障礙物
function isObstacle(point)
local value = _map_data[point.y][point.x]
if value == 1 then
return true
end
return false
end
-- 兩個點是否是同一個點
function isEqual(point1, point2)
return point1.key == point2.key
end
-- 根據點得到點的key
function getKey(point)
local key = string.format("%d,%d", point.x, point.y)
return key
end
下面是工具類PathUtil的用法
local deleget = {}
deleget.g = function(point1, point2)
return math.abs(point1.x - point2.x) + math.abs(point1.y - point2.y)
end
deleget.h = deleget.g
deleget.getValue = function(j, i)
local index = FindTreasureUtil.getIndex(j, i)
local map_info = _map_info.map[index]
if map_info.display == 0 and map_info.eid ~= 1 then
return 0
end
return 1
end
deleget.directions = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}} -- 左，上，下，右
deleget.width = _cols
deleget.height = _rows
local dest_row, dest_col = FindTreasureUtil.getMapPosition(tag)
local dest_point = PathUtil.createPoint(dest_col, dest_row)
local start_row, start_col = FindTreasureUtil.getMapPosition(_player_index)
local start_point = PathUtil.createPoint(start_col, start_row)
_path = PathUtil.findPath(deleget, start_point, dest_point)
_path就是我們找到的路徑，起點為最後一個元素，終點為第一個元素
D. 如何實現A星尋路演算法 Cocos2d-x 3.0 beta2
操作步驟如下：一win764位系統搭建android開發環境需要的軟體1.cocos2d-x3.3beta02.VisualStudio2012/2013安裝完占硬碟空間近10G，VisualStudio2012/2013是需要注冊碼。4.AndroidSDK（其中包括Eclipse）5.AndroidNDK6.Ant7.Python2.7.8不要下載3.x以上版本二軟體安裝安裝軟體時不要安裝在C盤。1.VisualStudio2012/2013VisualStudio2012/2013安裝方法像安裝其他軟體一樣，一路下一步就可以，但是注意安裝前IE瀏覽器版本必須是IE10以上版本。2.Python2.7.8安裝方法同上，但是不要安裝在C盤。3.JAVAJDKJAVAJDK默認安裝，這個可以安裝在C盤。4.cocos2d-x3.3beta0 AndroidSDK AndroidNDK Ant這些軟體都是解壓包，不需要安裝，解壓就可以。三cocos2d-x3.3beta0環境調試1.打開cocos2d-x3.3beta0所在的文件[attachment=78978]按Shift+滑鼠右鍵，點在此次打開命令窗口。現在可以看見畫黃線的是軟體變數名稱，紅線是變數路徑。正常的是4個變數名稱4條變數路徑，如果不是就需要手動添加，方法如下：1.右鍵計算機（XP叫我的電腦，win7叫計算機）------2.屬性------3.高級系統設置------4.環境變數------5.新建6.在變數名中添加缺少的變數名，在變數值中添加路徑。如：變數名NDK_ROOT 變數值D:\android-ndk-r10b軟體名稱 變數名cocos2d-x3.3beta0 COCOS_CONSOLE_ROOTAndroidSDK ANDROID_SDK_ROOTAndroidNDK NDK_ROOTAnt ANT_ROOT再次.打開cocos2d-x3.3beta0所在的文件，按Shift+滑鼠右鍵，點在此次打開命令窗口。如果看到4個變數名稱4條變數路徑就說明變數調試正確。四創建項目1.打開cocos2d-x3.3beta0所在的文件，按Shift+滑鼠右鍵，點在此次打開命令窗口。2.鍵入setup.py回車3.鍵入cocosnew項目名稱-p包名-l語言cpp-d項目路徑如：cocosnewtest-ptiaoshi-lcpp-d/test/android/cheshi會在存放cocos2d-x3.3beta0的盤符里出現一個名稱為tset的文件，打開文件-----proj.win32-----TSET.sin在VisualStudio2013中點 調試------開始執行不調試
E. JAVA的A星演算法問題
class AllShunXu { static String str = "12345"; static char[] a = str.toCharArray(); static int n = 5; static void swap(int arg1, int arg2){ char temp; temp = a[arg1]; a[arg1] = a[arg2]; a[arg2] = temp; } static void sort(int index){ int i; if (index == n){ for (i = 0; i < n; i++){ System.out.print(a[i]); } System.out.println(""); return; } for (i = index; i < n; i++){ swap(index,i); sort(index + 1); swap(index,i); } } public static void main(String args[]){ for(int s =0;s<n;s++){ sort(s); } }}
F. 如何基於Cocos2d-x v3.x實現A星尋路演算法
實現A星演算法
根據演算法，第一步是添加當前坐標到open列表。還需要三個輔助方法：
- 一個方法用來插入一個ShortestPathStep對象到適當的位置（有序的F值）
- 一個方法用來計算從一個方塊到相鄰方塊的移動數值
- 一個方法是根據"曼哈頓距離"演算法，計算方塊的H值
打開CatSprite.cpp文件，添加如下方法：
void CatSprite::insertInOpenSteps(CatSprite::ShortestPathStep *step)
{
int stepFScore = step->getFScore();
ssize_t count = _spOpenSteps.size();
ssize_t i = 0;
for (; i < count; ++i)
{
if (stepFScore <= _spOpenSteps.at(i)->getFScore())
{
break;
}
}
_spOpenSteps.insert(i, step);
}
int CatSprite::computeHScoreFromCoordToCoord(const Point &fromCoord, const Point &toCoord)
{
// 這里使用曼哈頓方法，計算從當前步驟到達目標步驟，在水平和垂直方向總的步數
// 忽略了可能在路上的各種障礙
return abs(toCoord.x - fromCoord.x) + abs(toCoord.y - fromCoord.y);
}
int CatSprite::(const ShortestPathStep *fromStep, const ShortestPathStep *toStep)
{
// 因為不能斜著走，而且由於地形就是可行走和不可行走的成本都是一樣的
// 如果能夠對角移動，或者有沼澤、山丘等等，那麼它必須是不同的
return 1;
}
接下來，需要一個方法去獲取給定方塊的所有相鄰可行走方塊。因為在這個游戲中，HelloWorld管理著地圖，所以在那裡添加方法。打開HelloWorldScene.cpp文件，添加如下方法：
PointArray *HelloWorld::(const Point &tileCoord) const
{
PointArray *tmp = PointArray::create(4);
// 上
Point p(tileCoord.x, tileCoord.y - 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
// 左
p.setPoint(tileCoord.x - 1, tileCoord.y);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
// 下
p.setPoint(tileCoord.x, tileCoord.y + 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
// 右
p.setPoint(tileCoord.x + 1, tileCoord.y);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
return tmp;
}
可以繼續CatSprite.cpp中的moveToward方法了，在moveToward方法的後面，添加如下代碼：
bool pathFound = false;
_spOpenSteps.clear();
_spClosedSteps.clear();
// 首先，添加貓的方塊坐標到open列表
this->insertInOpenSteps(ShortestPathStep::createWithPosition(fromTileCoord));
do
{
// 得到最小的F值步驟
// 因為是有序列表，第一個步驟總是最小的F值
ShortestPathStep *currentStep = _spOpenSteps.at(0);
// 添加當前步驟到closed列表
_spClosedSteps.pushBack(currentStep);
// 將它從open列表裡面移除
// 需要注意的是，如果想要先從open列表裡面移除，應小心對象的內存
_spOpenSteps.erase(0);
// 如果當前步驟是目標方塊坐標，那麼就完成了
if (currentStep->getPosition() == toTileCoord)
{
pathFound = true;
ShortestPathStep *tmpStep = currentStep;
CCLOG("PATH FOUND :");
do
{
CCLOG("%s", tmpStep->getDescription().c_str());
tmpStep = tmpStep->getParent(); // 倒退
} while (tmpStep); // 直到沒有上一步
_spOpenSteps.clear();
_spClosedSteps.clear();
break;
}
// 得到當前步驟的相鄰方塊坐標
PointArray *adjSteps = _layer->(currentStep->getPosition());
for (ssize_t i = 0; i < adjSteps->count(); ++i)
{
ShortestPathStep *step = ShortestPathStep::createWithPosition(adjSteps->getControlPointAtIndex(i));
// 檢查步驟是不是已經在closed列表
if (this->getStepIndex(_spClosedSteps, step) != -1)
{
continue;
}
// 計算從當前步驟到此步驟的成本
int moveCost = this->(currentStep, step);
// 檢查此步驟是否已經在open列表
ssize_t index = this->getStepIndex(_spOpenSteps, step);
// 不在open列表，添加它
if (index == -1)
{
// 設置當前步驟作為上一步操作
step->setParent(currentStep);
// G值等同於上一步的G值 + 從上一步到這里的成本
step->setGScore(currentStep->getGScore() + moveCost);
// H值即是從此步驟到目標方塊坐標的移動量估算值
step->setHScore(this->computeHScoreFromCoordToCoord(step->getPosition(), toTileCoord));
// 按序添加到open列表
this->insertInOpenSteps(step);
}
else
{
// 獲取舊的步驟，其值已經計算過
step = _spOpenSteps.at(index);
// 檢查G值是否低於當前步驟到此步驟的值
if ((currentStep->getGScore() + moveCost) < step->getGScore())
{
// G值等同於上一步的G值 + 從上一步到這里的成本
step->setGScore(currentStep->getGScore() + moveCost);
// 因為G值改變了，F值也會跟著改變
// 所以為了保持open列表有序，需要將此步驟移除，再重新按序插入
// 在移除之前，需要先保持引用
step->retain();
// 現在可以放心移除，不用擔心被釋放
_spOpenSteps.erase(index);
// 重新按序插入
this->insertInOpenSteps(step);
// 現在可以釋放它了，因為open列表應該持有它
step->release();
}
}
}
} while (_spOpenSteps.size() > 0);
if (!pathFound)
{
SimpleAudioEngine::getInstance()->playEffect("hitWall.wav");
}
添加以下方法：
ssize_t CatSprite::getStepIndex(const cocos2d::Vector<CatSprite::ShortestPathStep *> &steps, const CatSprite::ShortestPathStep *step)
{
for (ssize_t i = 0; i < steps.size(); ++i)
{
if (steps.at(i)->isEqual(step))
{
return i;
}
}
return -1;
}
G. 按鍵精靈a星演算法尋路怎麼製作地圖
你可以查找有關a星演算法走路，一步步去學，別人也不知道你說的是什麼地圖，怎麼判斷
H. 如何在使用Cocos2D中實現A星（A*）尋路演算法
實現A星演算法
根據演算法，第一步是添加當前坐標到open列表。還需要三個輔助方法：
- 一個方法用來插入一個ShortestPathStep對象到適當的位置（有序的F值）
- 一個方法用來計算從一個方塊到相鄰方塊的移動數值
- 一個方法是根據"曼哈頓距離"演算法，計算方塊的H值。
ssize_t CatSprite::getStepIndex(const cocos2d::Vector<CatSprite::ShortestPathStep *> &steps, const CatSprite::ShortestPathStep *step)
{
for (ssize_t i = 0; i < steps.size(); ++i)
{
if (steps.at(i)->isEqual(step))
{
return i;
}
}
return -1;
}
I. 如何基於cocos2dx3.x實現A星尋路演算法
實現A星演算法 根據演算法，第一步是添加當前坐標到open列表。還需要三個輔助方法： - 一個方法用來插入一個ShortestPathStep對象到適當的位置（有序的F值） - 一個方法用來計算從一個方塊到相鄰方塊的移動數值 - 一個方法是根據"曼哈頓距離"演算法
J. A星尋路演算法和Unity自帶的尋路相比有什麼優勢
並沒一種尋路適合所有場合，選擇都是基於需求而定的。
1. A* 演算法與貪婪演算法不一樣，貪婪演算法適合動態規劃，尋找局部最優解，不保證最優解。
A*是靜態網格中求解最短路最有效的方法。也是耗時的演算法，不宜尋路頻繁的場合。一般來說適合需求精確的場合。
與啟發式的搜索一樣，能夠根據改變網格密度、網格耗散來進行調整精確度。
使用的地方：
a. 策略游戲的策略搜索
b. 方塊格子游戲中的格子尋路
2. Unity 自帶的導航網格系統
Unity 內置了NavMesh導航網格系統，一般來說導航網格演算法大多是「拐角點演算法」。
效率是比較高的，但是不保證最優解演算法。
使用的地方：
a.游戲場景的怪物尋路
b.動態規避障礙