请给matlab一个完整的三维A*算法，且障碍物可移动

以下是一个基本的 MATLAB 三维 A* 算法实现，其中障碍物可移动：

function [path, closedList] = Astar3D(map, start, goal)
% map: 3D地图，0表示自由空间，1表示障碍物
% start: 起点坐标，格式为[x,y,z]
% goal: 终点坐标，格式为[x,y,z]
% path: 返回路径，格式为一个nx3的矩阵，每一行表示路径上的一个节点
% closedList: 返回搜索过程中的关闭列表，格式为一个nx4的矩阵，
%            每一行表示一个节点的坐标和它的f值

% 初始化起点和终点节点
startNode = Node(start, 0, 0, 0);
goalNode = Node(goal, 0, 0, 0);
% 初始化开放列表和关闭列表
openList = [startNode];
closedList = [];

while ~isempty(openList)
    % 选取f值最小的节点进行扩展
    currentNode = openList(1);
    currentIndex = 1;
    for i = 1:length(openList)
        if openList(i).f < currentNode.f
            currentNode = openList(i);
            currentIndex = i;
        end
    end
    
    % 如果当前节点是终点，则返回路径
    if isequal(currentNode.position, goalNode.position)
        path = [];
        while ~isequal(currentNode.position, startNode.position)
            path = [currentNode.position; path];
            currentNode = currentNode.parent;
        end
        path = [startNode.position; path];
        return;
    end
    
    % 从开放列表中移除当前节点，并将其加入关闭列表
    openList(currentIndex) = [];
    closedList = [closedList; currentNode];
    
    % 扩展当前节点的邻居节点
    neighbors = getNeighbors(map, currentNode);
    for i = 1:length(neighbors)
        neighbor = neighbors(i);
        
        % 如果邻居节点已经在关闭列表中，则忽略
        if any(isequal(neighbor.position, closedList.position, 'rows'))
            continue;
        end
        
        % 计算邻居节点的g值和f值
        tentativeGCost = currentNode.g + neighbor.cost;
        if ~any(isequal(neighbor.position, openList.position, 'rows'))
            openList = [openList; neighbor];
        elseif tentativeGCost >= neighbor.g
            continue;
        end
        
        neighbor.parent = currentNode;
        neighbor.g = tentativeGCost;
        neighbor.h = heuristic(neighbor.position, goalNode.position);
        neighbor.f = neighbor.g + neighbor.h;
    end
end

% 如果开放列表为空且没有找到路径，则返回空
path = [];
end

function neighbors = getNeighbors(map, node)
% 获取邻居节点
x = node.position(1);
y = node.position(2);
z = node.position(3);

deltas = [-1,0,0; 1,0,0; 0,-1,0; 0,1,0; 0,0,-1; 0,0,1];

neighbors = [];
for i = 1:size(deltas,1)
    dx = deltas(i,1);
    dy = deltas(i,2);
    dz = deltas(i,3);
    if x+dx>0 && x+dx<=size(map,1) && y+dy>0 && y+dy<=size(map,2) && z+dz>0 && z+dz<=size(map,3)
        if map(x+dx, y+dy, z+dz) == 0
            neighbors = [neighbors; Node([x+dx,y+dy,z+dz],0,0,0)];
        end
    end
end

% 计算邻居节点的代价
for i = 1:length(neighbors)
    neighbors(i).cost = norm(neighbors(i).position - node.position);
end
end

function h = heuristic(position, goal)
% 计算启发式估价函数
h = norm(position - goal);
end

classdef Node
% 表示一个节点
properties
    position % 节点的坐标，格式为[x,y,z]
    parent % 父节点
    g % 节点到起点的代价
    h % 节点到终点的启发式估价
    f % 节点的f值
    cost % 节点的代价
end

methods
    function obj = Node(position, g, h, f)
        obj.position = position;
        obj.g = g;
        obj.h = h;
        obj.f = f;
    end
end
end

在这个实现中，我们定义了 `Node` 类来表示搜索过程中的节点，其中包括节点的位置、父节点、g 值、h 值、f 值和代价。我们还定义了 `getNeighbors` 函数来获取当前节点的邻居节点，并计算它们的代价。启发式估价函数使用欧几里得距离。