基于格子的AOI 实现

最新推荐文章于 2023-08-30 17:02:48 发布
最新推荐文章于 2023-08-30 17:02:48 发布
阅读量707 收藏 1
点赞数 1
分类专栏： 代码测试 文章标签： aoi 九宫格 源码 实现

看了这位大哥基于格子的aoi C++实现 https://www.h5cowboy.com/cpp/aoi-9grid.html 照代码抄了一份。

稍稍修改了下.

1、把 obj 分为 普通moveobj,和 witness。 witness 检测 moveobj aoi 消息。 moveobj之间，witness之间不产生aoi 消息。

2、obj 移动跨格子时，算 leave，enter 集合的方式感觉太麻烦。修改了下，使用矩形框相交的概念，算leave，enter集合。

3、moveobj leave witness 时，不马上 leave，先暂时进入一个 weakness 集合，等 moveobj 再 偏离一个格子后才leave。如果 这时候 moveobj 重新进入witness的九宫格，不再发生enter消息。moveobj 有个 shift标记，被标记的 不参与 前面的leave处理.


顺便写了个程序验证:

moveobj:100

witness:1

grid width:120


引用似乎正常.


运动时 weakness 引用 似乎也正常（红线引用）.

moveobj:5000

witness:2000

grid:120

ms:10-20



moveobj:5000

witness:5000

grid:120

蹦了 ms 1000-2000


moveobj:5000

witness:2000

grid:120

witness 速度调大3倍。



又蹦了 -_-!!!!

去掉 那个 weakness 处理：


ms 0.1-1 抓狂


moveobj:5000

shiftobj:5000

witness:5000

moveobj 速度:3000

witness 速度:3000

grid width:300


ms 1-2

moveobj:5000

shiftobj:5000

witness:5000

moveobj 速度:3000

witness 速度:3000

grid width:120

ms 6-8.

好吧 我还是去掉 那个 weakness 集合吧难过难过难过难过难过难过

aoi方面的源代码和 那位大哥的基本差不多我就贴贴测试代码吧。


源码:

space_test_view.h:

class SpaceTestNode : public grid_space::CoordinateNode
{
public:
  float rotation = 0.0f;
  jdot_vec2f pos;
};

class SpaceTestWitness : public grid_space::CoordinateWitness
{
public:
  float rotation = 0.0f;
  jdot_vec2f pos;
};

class SpaceTestView : public jdot::View
{
  typedef jdot::View Super;
  JDOT_CLASS_BEGIN(SpaceTestView, Super)
    JDOT_B_PROPERTY("tick", UseTick);
    JDOT_B_PROPERTY("shift_count", ShiftNodeCount);
    JDOT_B_PROPERTY("node_count", NodeCount);
    JDOT_B_PROPERTY("witness_count", WitnessCount);
    JDOT_B_PROPERTY("node_vel", NodeVel);
    JDOT_B_PROPERTY("witness_vel", WitnessVel);
    JDOT_B_PROPERTY("grid_extent", GridExtent);
    JDOT_B_PROPERTY("view_count", ViewCount);
    JDOT_B_PROPERTY("weakness", EnableWeakness);
  JDOT_CLASS_END();

public:
  SpaceTestView();

public:
  void OnPaint(jdot::Painter&painter, float delta)override;
  void OnAnimate(float delta)override;

  void UpdateNodes(float delta);
  void UpdateWitnesses(float delta);
  void UpdateSpace(float delta);
  void PaintSpace(jdot::Painter& painter, float delta);

  bool OnNotify(jdot::View*sender, jdot::NtfArgs&args)override;

public:
  JDOT_BINDABLE_VAR_WRAP(float, UseTick) { 0 };
  JDOT_BINDABLE_VAR_WRAP_CHD(int, NodeCount,OnCountChanged) { 10 };
  JDOT_BINDABLE_VAR_WRAP_CHD(int, ShiftNodeCount, OnCountChanged) { 10 };
  JDOT_BINDABLE_VAR_WRAP_CHD(int, WitnessCount, OnCountChanged) { 10 };
  JDOT_BINDABLE_VAR_WRAP(int, NodeVel) { 100 };
  JDOT_BINDABLE_VAR_WRAP(int, WitnessVel) { 100 };
  JDOT_BINDABLE_VAR_WRAP(int, ViewCount) { 3 };
  JDOT_BINDABLE_VAR_WRAP_CHD(int, GridExtent, OnGridExtentChanged) { 60 };
  JDOT_BINDABLE_VAR_WRAP(bool, EnableWeakness) { true };

private:
  bool OnCountChanged(int oldVal, bool from_bind) { __modify(); return true; }
  bool OnGridExtentChanged(int oldVal, bool from_bind);

private:
  void __reset();
  void __clear();
  void __modify();

private:
  jdot::scene::SceneView m_sceneView;//painter for terrain.
  jdot::Painter m_painter;// terrain painter.

private:
  grid_space::CoordinateSpace m_space;

  jdot_vector< jdot_ptr<SpaceTestNode> > m_nodes;
  jdot_vector< jdot_ptr<SpaceTestNode> > m_shiftNodes;
  jdot_vector< jdot_ptr<SpaceTestWitness> > m_witnesses;

};

space_test_view.cpp:

SpaceTestView::SpaceTestView()
{
  m_painter.SetSceneView(&m_sceneView);

  __reset();
}

void SpaceTestView::OnAnimate(float delta)
{
  //++
  auto tnow = std::chrono::high_resolution_clock::now();

  UpdateNodes(delta);
  UpdateWitnesses(delta);
  UpdateSpace(delta);

  auto use = std::chrono::high_resolution_clock::now() - tnow;
  auto count = std::chrono::duration_cast<std::chrono::microseconds>(use).count();

  float fcount = count*0.001f;
  UseTick = fcount;

}

void SpaceTestView::OnPaint(jdot::Painter&painter, float delta)
{
  //++
  PaintSpace(painter, delta);
  //++
  m_sceneView.DrawScene();
}

void SpaceTestView::UpdateNodes(float delta)
{
  for (size_t i = 0; i < m_nodes.size(); ++i) {
    auto*obj = m_nodes.at(i).get();
    float rot = obj->rotation;
    rot += math::rand_minus1_1()*delta*1000.0f;
    obj->rotation = rot;
    float p_rot = math::radians(rot);

    auto pos = obj->pos + jdot_vec2f(cosf(p_rot), sinf(p_rot))*delta*NodeVel.GetValue();

    auto sz = jdot::GetRenderer()->GetWinSize();

    if (pos.x > sz.width) {
      pos.x = 0;
    }
    if (pos.y > sz.height) {
      pos.y = 0;
    }
    if (pos.x < 0) {
      pos.x = sz.width - 1.0f;
    }
    if (pos.y < 0) {
      pos.y = sz.height - 1.0f;
    }
    obj->pos = pos;
    //++
    obj->SetXY(pos.x, pos.y);
  }
}

void SpaceTestView::UpdateWitnesses(float delta)
{
  for (size_t i = 0; i < m_witnesses.size(); ++i) {
    auto*obj = m_witnesses.at(i).get();
    float rot = obj->rotation;
    rot += math::rand_minus1_1()*delta*1000.0f;
    obj->rotation = rot;
    float p_rot = math::radians(rot);

    auto pos = obj->pos + jdot_vec2f(cosf(p_rot), sinf(p_rot))*delta*WitnessVel.GetValue();

    auto sz = jdot::GetRenderer()->GetWinSize();

    if (pos.x > sz.width) {
      pos.x = 0;
    }
    if (pos.y > sz.height) {
      pos.y = 0;
    }
    if (pos.x < 0) {
      pos.x = sz.width - 1.0f;
    }
    if (pos.y < 0) {
      pos.y = sz.height - 1.0f;
    }
    obj->pos = pos;
    //++
    obj->SetXY(pos.x, pos.y);
  }
}

void SpaceTestView::UpdateSpace(float delta)
{
  for (size_t i = 0; i < m_nodes.size(); ++i) {
    m_space.Move(m_nodes.at(i).get());
  }
  for (size_t i = 0; i < m_witnesses.size(); ++i) {
    m_space.Move(m_witnesses.at(i).get());
  }
}

void SpaceTestView::PaintSpace(jdot::Painter& painter, float delta)
{
  auto&grids = m_space.GetGrids();
  int gridExtent = m_space.GetGridExtent();
  auto sz = jdot::GetRenderer()->GetWinSize();

  for (auto&kv : grids) {
    auto grid = kv.second;
    jdot_rectf rc;
    rc.set_xy(grid->GetGX()*gridExtent, grid->GetGY()*gridExtent);
    rc.set_size(jdot_vec2f(gridExtent, gridExtent));

    if (grid->GetWitnessesCount() <= 0) {
      painter.FillRect(nullptr, rc, 0xafE0FFFF);
    }
    else {
      painter.FillRect(nullptr, rc, 0xafB3EE3A);

    }
  }

  for (size_t i = 0; i < m_nodes.size(); ++i) {
    auto obj = m_nodes[i];
    jdot_rectf rc;
    rc.set_xy(obj->GetX(), obj->GetY());
    rc.set_size(jdot_vec2f(4.0f, 4.0f));
    painter.FillRect(nullptr, rc, jdot_color::Wheat);
  }

  for (size_t i = 0; i < m_shiftNodes.size(); ++i) {
    auto obj = m_shiftNodes[i];
    jdot_rectf rc;
    rc.set_xy(obj->GetX(), obj->GetY());
    rc.set_size(jdot_vec2f(4.0f, 4.0f));
    painter.FillRect(nullptr, rc, jdot_color::LightGray);
  }

  for (size_t i = 0; i < m_witnesses.size(); ++i) {
    auto obj = m_witnesses[i];
    jdot_rectf rc;
    rc.set_xy(obj->GetX(), obj->GetY());
    rc.set_size(jdot_vec2f(4.0f, 4.0f));
    painter.FillRect(nullptr, rc, jdot_color::Red);
    //++
    if ((int)i >= ViewCount) {
      continue;
    }

    auto gx = obj->GetX() / m_space.GetGridExtent();
    auto gy = obj->GetY() / m_space.GetGridExtent();
    JDOT_GRID_SPACE_FOR_9_GRID(gx, gy, m_space, {
      for (int i = 0; i < grid->GetNodesCount(); ++i) {
        auto*node = grid->GetNodeAt(i);
        if (node->IsShift()) {
          painter.DrawLine(obj->pos, jdot_vec2f(node->GetX(), node->GetY()), 0xafFFF0F5);
        }
        else {
          painter.DrawLine(obj->pos, jdot_vec2f(node->GetX(), node->GetY()), 0xafFFF68F);
        }
      }
    });

    auto&wns = obj->GetWeaknessNodes();
    for (auto&w : wns) {
      painter.DrawLine(obj->pos, jdot_vec2f(w->GetX(), w->GetY()), jdot_color::LightPink);
    }
  }
  ///+++++
  for (int i = 0; i < sz.width; i += gridExtent) {
    painter.DrawLine(jdot_vec2f(i, 0), jdot_vec2f(i, sz.height), jdot_color::DimGray);
  }
  for (int i = 0; i < sz.height; i += gridExtent) {
    painter.DrawLine(jdot_vec2f(0, i), jdot_vec2f(sz.width, i), jdot_color::DimGray);
  }

}

bool SpaceTestView::OnNotify(jdot::View*sender, jdot::NtfArgs&args)
{
  if (sender->Command == "!space_reset") {
    __reset();
  }
  return false;
}

void SpaceTestView::__reset()
{
  __clear();

  __modify();
}

void SpaceTestView::__clear()
{
  for (auto&n : m_nodes) {
    m_space.Leave(n);
  }
  for (auto&o : m_shiftNodes) {
    m_space.Leave(o);
  }
  for (auto&o : m_witnesses) {
    m_space.Leave(o);
  }
  m_nodes.clear();
  m_shiftNodes.clear();
  m_witnesses.clear();
}

void SpaceTestView::__modify()
{
  auto sz = jdot::GetRenderer()->GetWinSize();
  //++
  while ( (int)m_nodes.size() > NodeCount) {
    m_space.Leave(m_nodes.back());
    m_nodes.pop_back();
  }
  while ((int)m_nodes.size() < NodeCount) {
    auto obj = jdot::make_intrusive<SpaceTestNode>();
    obj->pos.set(math::random(0.0f,sz.x), math::random(0.0f,sz.y));
    obj->SetXY(obj->pos.x, obj->pos.y);
    m_nodes.emplace_back(obj);
    m_space.Join(obj);
  }

  //++
  while ((int)m_shiftNodes.size() > ShiftNodeCount) {
    m_space.Leave(m_shiftNodes.back());
    m_shiftNodes.pop_back();
  }
  while ((int)m_shiftNodes.size() < ShiftNodeCount) {
    auto obj = jdot::make_intrusive<SpaceTestNode>();
    obj->SetShift(true);
    obj->pos.set(math::random(0.0f, sz.x), math::random(0.0f, sz.y));
    obj->SetXY(obj->pos.x, obj->pos.y);
    m_shiftNodes.emplace_back(obj);
    m_space.Join(obj);
  }
  //++
  while ((int)m_witnesses.size() > WitnessCount) {
    m_space.Leave(m_witnesses.back());
    m_witnesses.pop_back();
  }
  while ((int)m_witnesses.size() < WitnessCount) {
    auto obj = jdot::make_intrusive<SpaceTestWitness>();
    obj->pos.set(math::random(0.0f, sz.x), math::random(0.0f, sz.y));
    obj->SetXY(obj->pos.x, obj->pos.y);
    obj->EnableWeakness(EnableWeakness);
    m_witnesses.emplace_back(obj);
    m_space.Join(obj);
  }
}

bool SpaceTestView::OnGridExtentChanged(int oldVal, bool from_bind)
{
  if (from_bind && GridExtent>0) {
    __clear();
    m_space.SetGridExtent(GridExtent);
    __modify();
  }
  return true;
}

ui:

<?xml version="1.0" encoding="utf-8"?>
<root jdot:theme="editor"  xmlns:ui="placeholder" xmlns:jdot="placeholder">
  <SpaceTestView name="*" valign="stretch" halign="stretch">
    <V pass_pick="true">
      <Button text="返回选择界面" command="!change_state" command_args="menu"/>
      <Button text="重新开始" command="!space_reset"/>
      <View w="600">
        <Slider name="#node-count" halign="stretch" valign="center" range="5000" value="@{*.node_count:both}"/>
        <H halign="center" valign="center">
          <Label text="node count:"/>
          <TextField text="@{#node-count.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <View w="600">
        <Slider name="#shift-count" halign="stretch" valign="center" range="5000" value="@{*.shift_count:both}"/>
        <H halign="center" valign="center">
          <Label text="shift count:"/>
          <TextField text="@{#shift-count.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <View w="600">
        <Slider name="#witness-count" halign="stretch" valign="center" range="5000" value="@{*.witness_count:both}"/>
        <H halign="center" valign="center">
          <Label text="witness count:"/>
          <TextField text="@{#witness-count.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <View w="600">
        <Slider name="#witness-vel" halign="stretch" valign="center" range="3000" value="@{*.witness_vel:both}"/>
        <H halign="center" valign="center">
          <Label text="witness vel:"/>
          <TextField text="@{#witness-vel.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <View w="600">
        <Slider name="#node-vel" halign="stretch" valign="center" range="3000" value="@{*.node_vel:both}"/>
        <H halign="center" valign="center">
          <Label text="node vel:"/>
          <TextField text="@{#node-vel.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <View w="600">
        <Slider name="#grid-extent" halign="stretch" valign="center" range="3000" value="@{*.grid_extent:both}"/>
        <H halign="center" valign="center">
          <Label text="grid extent:"/>
          <TextField text="@{#grid-extent.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <View w="600">
        <Slider name="#view_count" halign="stretch" valign="center" range="3000" value="@{*.view_count:both}"/>
        <H halign="center" valign="center">
          <Label text="view count:"/>
          <TextField text="@{#view_count.value:both}" halign="center" valign="center" />
        </H>
      </View>
      <CheckButton text="weakness" checked="@{*.weakness:both}"/>
      <H w="100">
        <Label text="cost time(ms):"/>
        <Label text="@{*.tick}" halign="right"/>
      </H>
    </V>
  </SpaceTestView>
</root>

oYiRuJiWangPlus
关注
专栏目录
游戏服务端开发-AOI-九宫格法解析(附代码)
食鱼酱的博客
04-25 3702
1-啥是AOI AOI全称Area Of Interest，中文就是感兴趣的区域，个人理解就是玩家关注的并且可视的地图区域。 在RPG游戏中，玩家角色移动，攻击，放技能等操作都需要向其他玩家广播，但服务端由于性能原因，会避免往整张地图上的角色进行广播。为了把性能消耗降到最低，同时不影响玩家的游戏体验，就只会向玩家关注并感兴趣的区域，也就是AOI进行广播。 2-AOI-网格法(九宫格) 1# 建立坐...
深入探索AOI算法实现（九宫格篇）
rave..juine
03-21 1822
游戏的AOI算法应该算作游戏的基础核心了，许多逻辑都是因为AOI进出事件驱动的，许多网络同步数据也是因为AOI进出事件产生的。因此，良好的AOI算法和基于AOI算法的优化，是提高游戏性能的关键。 我在实践中所熟知的游戏AOI算法大致有两种，在此做一些总结，顺便梳理一下，打算设计出一套统一的接口封装不同的算法实现（网络上还有些其他算法，因为不熟悉不作记录了）。我所记录的这两种算法也算经典了，一个叫做网格法，一个叫做双链表法。具体细节可参考如下：https://zhuanlan.zhihu.com/p/2015
九宫格AOI项目源码（仅供参考，不喜勿喷）
06-19
AOI(Area Of Interest 感兴趣的领域 ) 我们通常把玩家周围的可视区域，叫做玩家感兴趣的领域即AOI。它的大小其实就是玩家的视野大小。它的作用就是根据AOI来优化数据的操作，比如不在视野范围的其他活跃对象的行为就不需要让玩家知道(反正玩家也看不到)，这样减少了数据的传输。再一个就是通过AOI来判断我们释放一些互动动作的有效范围内都有些什么活跃对象，然后再和这些对象发生交互。
分析游戏开发中 AOI 的实现思路
最新发布
m0_73915763的博客
08-30 525
AOI 全称 Area Of Interest, 在游戏开发中用来做角色视野内对象显示同步和状态同步，基本上只要有公共地图的游戏都会涉及到。本篇介绍一些常用的 AOI 实现方法。
AOI的实现的优化过程
许恒的专栏
01-05 2608
由于正在开发的游戏涉及到10万个移动角色，如果单服10000玩家的话，采用双向循环查找，那就是10亿的量级，太恐怖了，不得不对算法做优化。考虑以下场景：1000*1000的地图10000客户端角色两个角色间的距离是10时，有效。使用语言：java，版本1.6随机生成10000角色的位置信息，然后计算哪些角色的信息需要发给范围内的客户端。原始：使用最简单的双向查找算法，两重For循环， 每找到一个时
基于C++的OpenCV项目实战——零部件的自动光学检测
weixin_40620310的博客
09-14 3479
多窗口展示背景去除连通图的实现轮廓边缘检测并且在实际的C++代码中，还涉及了智能指针等高阶知识；工业质检项目作为视觉领域较为成熟的落地项目，其大部分都是基于深度学习的方式实现了，但如果能掌握一些OpenCV的方法，也可以在项目中起到优化效果的作用；
游戏服务端 - AOI九宫格算法
田螺姑娘的博客
12-19 999
下面简述内容，只针对平面上的简易场景。我们将平面上的场景分为一个个格子（Grid），场景管理所有的Grid。如下（假设场景的长宽均为20，每个格子宽高定义为1）...
灯塔AOI简易实现
dcldz5007的博客
07-26 1231
首先我们来讨论下游戏开发中的几个坐标系，为了方便解释，我截取了灯塔AOI DEMO当NPC数目为0时候的样子（代码地址觉得有帮助的童鞋记得给我代码点个星^_^） 先对这张图简单说明下： 蓝色的坐标轴表示是灯塔AOI坐标系，绿色的坐标轴表示的是游戏坐标系，向左为X轴正方向，向上为Y轴正方向（这个坐标是我自己后面画上去的） 深蓝色的点表示灯塔AOI坐标，左下的表示(0,0)，右上表示(1...
游戏服务器场景管理AOI方案
水上漂的专栏
05-18 2450
 AOI 服务器的实现
如何在游戏客户端和服务器之间精确同步玩家的状态？
bycw888的博客
07-25 1349
如果是3D游戏，俯瞰游戏3D地图，将地图看作一个平面，和2D一样标记区域，哪些是障碍物,哪些是路径，如果你的3D游戏地图中，没有上坡和下坡，那么就和普通的2D游戏没有区别，如果有上坡下坡，就让客户端把地图的。a不在原来的AOI区域，在新的AOI区域内新加的块，那我们就要把这些新加的块里的玩家先同步到你这个客户端，你所在的客户端把新进入视野的玩家创建出来,同时你要把你自己的最新状态，同步给新进来的玩家客户端，新进玩家的客户端，也会把你这个角色创建出来,你看到别人的同时，也要让别人看到你。...
AOI图像处理
10-13
利用VS2010和Opencv开发AOI测试技术，内容包括视频图像识别没处理旋转放大缩小以及其他处理，图像比较，Logo比较。
Labview AOI程序
03-30
使用NI公司的6010数据采集板卡和9940四轴运动控制板卡.程序包含图像采集,处理,分析,判断和伺服电机的运动控制以及I/O点控制.此外,还附加机器参数存档,测量数据记录等功能.
AOI:交叉链接列表的C＃AOI算法
05-09
AOI库介绍 1.使用跳跃表+十字链方式实现的一个AOI库。 2.可做简单的碰撞检测、客户端资源、服务器AOI。 3.测试效率插入、移动、查找均到毫秒一下。 使用例子 var zone = new AoiZone(); var area = new Vector2(3, 3); // 添加50个玩家。 for (var i = 1; i <= 50; i++) zone.Enter(i, i, i); // 刷新key为3的信息。 zone.Refresh(3, area, out var enters); Console.WriteLine("---------------加入玩家范围的玩家列表--------------"); foreach (var aoiKey in enters) { var findEntity = zone[aoiKey]; Console.
【笔记】状态同步笔记
折戟
07-28 1921
状态同步位置和技能(适用于fps和mmorpg类游戏) 客户端A的同步阀值(减少同步量) 客户端A本地会存储一份对其他客户端看到的A的预测状态,当本地真实状态和预测状态偏差超过阀值时，则发起同步，同时更新客户端A本地的预测状态 玩家运动的关键点也会同步，例如起跳坐标点，起跳最高坐标点，落地坐标点，开始跑步的速度方向，停止跑步时的坐标点 插值算法的选择 客户端插值　和 航位推测的选择 航位推测只用于预测位移 客户端插值(线性插值，3次样条插值，曲线的寻路（寻路这个可能会...
说一说地图AOI 服务器实现（九宫格）
The Coding World
10-15 3358
在mmo游戏中，玩家在地图上移动，如果发消息通知地图上其他玩家肯定是不合理的，因为一个地图上有很多人，如果都在移动，那么消息量会很大。为此服务器为了减少发包量，会将地图划分成一个一个的格子，然后通知相邻格子的玩家，而不是全地图的人。通常这种技术叫做AOI。 通常的实现方式： 1、服务器加载场景地图会将场景按照固定大小格子进行划分，并做好编号， 2、通常有三个操作 EnterZone、Lea...
我的服务端之AOI概述
勇于尝试，却要三思后行。
01-21 2622
AOI(Area Of Interest)，中文就是感兴趣区域。通俗一点说，感兴趣区域就是玩家在场景实时看到的区域；也就是AOI会随着英雄的移动改变而改变。 一般在游戏的中，游戏的世界都是由各种场景组成，场景中有着各种各样的Obj(英雄、怪物、NPC和掉落物品等等)。当英雄在移动的时候，玩家需要看到其它在自己视野内玩家的英雄；需要看到在自己视野内的怪物；需要看到打BOSS掉落的物品；……。 有
光板AOI机器软件框架搭建
学习专栏，期待交流与成长
11-24 2550
光板AOI机器的软件框架可分为3个部分：配置界面、AOI算法、显示界面。配置界面
游戏开发中AOI算法总结
ghscarecrow的博客
03-20 7181
定义 在MMO游戏中，在一些多人玩法中，通常出现很多玩家在同一张地图上移动的情况，假如一个玩家发生了移动，释放技能，更换装扮…这时就需要通知其他玩家，而如果通知整张地图上的所有玩家的话，显然是不现实的，这将对客户端跟服务端都造成很大的压力，甚至可能卡死。为了解决这一痛点，就有了AOI算法。 统一的接口设计 AOI需求大概是这样： 1.游戏地图上有一些npc和玩家在移动，每一个这样移动的对象我们叫做AOIEntity，每一个AOIEntity可以挂多个不同半径的AOI，每一个这种半径的AOI单元我们叫做AOI
unity 实现aoi九宫格算法
08-10
Unity中实现AOI（Area of Interest，兴趣区域）九宫格算法的方法如下： 首先，创建一个AOIManager类，用于管理和维护AOI区域和对象。该类需要包含以下几个关键组成部分： 1. AOI格子的定义：定义一个格子的大小，并将整个场景划分为多个格子。可以使用二维数组来表示格子，每个元素存储在该格子中的对象列表。 2. 对象的定义：定义一个对象的结构，包括对象的唯一标识ID和对象的位置信息。 3. 对象的管理：AOIManager类需要负责管理所有对象的位置和状态。当一个对象进入或离开一个格子时，需要更新该对象在AOIManager中的位置信息。 4. AOI九宫格算法的实现：在AOIManager中实现九宫格算法，根据一个对象的位置信息，计算出该对象所在的格子以及该对象周围的格子。 5. 状态更新：当一个对象的位置发生变化时，需要通过九宫格算法计算该对象应该进入或离开的格子，并更新该对象的位置信息。 6. 感知范围：根据九宫格算法计算出的周围格子，可以获取到该对象周围的其他对象。可以根据需要定义对象的感知范围，只获取特定范围内的对象。 总结一下，Unity实现AOI九宫格算法需要创建AOIManager类，实现格子划分和对象管理，以及实现九宫格算法来计算对象所在的格子和对象的感知范围。这种方法可以提高游戏中大量对象的更新效率，减少不必要的计算和通信开销，提升游戏性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值