四叉树碰撞代码

最新推荐文章于 2024-09-27 11:17:47 发布
最新推荐文章于 2024-09-27 11:17:47 发布
阅读量276 收藏
点赞数 3
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1309602336/article/details/142452011
版权

使用raylib

代码来源

https://github.com/seyhajin/flux-samples/blob/master/raylib/quadtree/quadtree.c

原来是视锥碰撞四叉树，经过一周开发变成碰撞检测四叉树可视化

后经过改写

绿色检测

灰色检测




//https://github.com/seyhajin/flux-samples/blob/master/raylib/quadtree/quadtree.c

/*******************************************************************************************
 *
 *   raylib: quadtree (adapted for HTML5 platform)
 *
 *   This example is prepared to compile for PLATFORM_WEB, PLATFORM_DESKTOP and PLATFORM_RPI
 *   As you will notice, code structure is slightly diferent to the other examples...
 *   To compile it for PLATFORM_WEB just uncomment #define PLATFORM_WEB at beginning
 *
 *   This example has been created using raylib 3.7 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
 *   Copyright (c) 2021 Christophe TES (@seyhajin)
 *
 ********************************************************************************************/

#include <stdio.h>
#include <math.h>

#include "raylib.h"
#include "raymath.h"


//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------

//----- Frustum

static Vector2 fl, fr; // left/right planes

//----- Camera

typedef struct camera_s {
	Vector2 pos;
	float fov;
	int num;			// 记录编号，解决自己碰撞自己问题
} camera_t;

camera_t create_camera(float x, float y, float fov) {
	return (camera_t) {
		.pos = (Vector2) {x, y},
		.fov = fov
	};
}

typedef struct target {
	int targeti;
	int targetj;
	int targetwidth;
	int targetheight;
	RenderTexture2D pic;
//	RenderTexture* pic;
	
	target* linknext;				// 这是四叉树里增加敌人，发现要增加好几个敌人时，追加在敌人后面，最简单修改就是增加一行，于是反过来修改敌人数据
	
	int number;						// 记录敌人编号
	int islive;
} target;



//----- Quadtree

typedef enum quad_child_e {
	CHILD_TL, // top-left
	CHILD_BL, // bottom-left
	CHILD_BR, // bottom-right
	CHILD_TR, // top-right
	CHILD_COUNT
} quad_child_t;

typedef struct quadtree_s {
	Vector2 min;
	Vector2 max;
	struct quadtree_s *childs[CHILD_COUNT];
	target* enemy;									// 绑定的数据
} quadtree_t;

quadtree_t *create_quadtree(float xmin, float ymin, float xmax, float ymax, int depth) {
	quadtree_t *qt = (quadtree_t*)MemAlloc(sizeof(quadtree_t));
	qt->min = (Vector2) {
		xmin, ymin
	};
	qt->max = (Vector2) {
		xmax, ymax
	};
	// 追加空记录
	qt->enemy = NULL;
	
	if (depth > 0) {
		float xavg = (xmin + xmax) * 0.5f;
		float yavg = (ymin + ymax) * 0.5f;
		depth--;
		qt->childs[CHILD_TL] = create_quadtree(xmin, ymin, xavg, yavg, depth);
		qt->childs[CHILD_BL] = create_quadtree(xmin, yavg, xavg, ymax, depth);
		qt->childs[CHILD_BR] = create_quadtree(xavg, yavg, xmax, ymax, depth);
		qt->childs[CHILD_TR] = create_quadtree(xavg, ymin, xmax, yavg, depth);
	}
	return qt;
}

void free_quadtree(quadtree_t *qt) {
	for (int i = 0; i < CHILD_COUNT; i++)
		MemFree(qt->childs[i]);
	MemFree(qt);
}

int check(quadtree_t* qt, camera_t cam) {
	if (cam.pos.x > qt->min.x && cam.pos.x < qt->max.x && cam.pos.y > qt->min.y && cam.pos.y < qt->max.y) {
		return 1;
	}
	// 不加return 0 不出格子
	return 0;
}

// 修改为查找数据并记录
void render_quadtree(quadtree_t *qt, camera_t cam, int depth) {
	if (check(qt, cam)) {
		
		if (qt->enemy == NULL) {
			qt->enemy = new target;
			qt->enemy->targetj = cam.pos.x;
			qt->enemy->targeti = cam.pos.y;
			qt->enemy->number = cam.num;
		} else if (qt->enemy->number == -1) {
			qt->enemy->targetj = cam.pos.x;
			qt->enemy->targeti = cam.pos.y;
			qt->enemy->number = cam.num;
		}
		
		
		
//		printf("%d\n", qt->enemy->number);
		if (depth > 1) {
			float xavg = (qt->min.x + qt->max.x) * 0.5f;
			float yavg = (qt->min.y + qt->max.y) * 0.5f;
//			DrawLine(xavg, qt->min.y, xavg, qt->max.y, GRAY);
			DrawLine(xavg, qt->min.y, xavg, qt->max.y, GREEN);
//			DrawLine(qt->min.x, yavg, qt->max.x, yavg, GRAY);
			DrawLine(qt->min.x, yavg, qt->max.x, yavg, GREEN);
			// 记录本层区域有敌人
			
			depth--;
			render_quadtree(qt->childs[CHILD_TL], cam, depth);
			render_quadtree(qt->childs[CHILD_BL], cam, depth);
			render_quadtree(qt->childs[CHILD_BR], cam, depth);
			render_quadtree(qt->childs[CHILD_TR], cam, depth);
		}
	}
}

// 修改为查找数据并记录为已标记为“无” -1 表示没有敌人
// 修改自刚刚实现的查找记录功能数据

void render_quadtreev3_delete(quadtree_t *qt, camera_t cam, int depth) {
	// 注释check 后清空数据未果
	if (check(qt, cam)) {
		if (qt->enemy == NULL) {
			qt->enemy = new target;
		}
		qt->enemy->targetj = -1;
		qt->enemy->targeti = -1;
		qt->enemy->number = -1;
		
		if (depth > 1) {
			float xavg = (qt->min.x + qt->max.x) * 0.5f;
			float yavg = (qt->min.y + qt->max.y) * 0.5f;
			// 记录本层区域有敌人
			depth--;
			// 注释掉render_quadtree 发现报错，原来是没有改旧函数导致直接重新标记 -_-|
			render_quadtreev3_delete(qt->childs[CHILD_TL], cam, depth);
			render_quadtreev3_delete(qt->childs[CHILD_BL], cam, depth);
			render_quadtreev3_delete(qt->childs[CHILD_BR], cam, depth);
			render_quadtreev3_delete(qt->childs[CHILD_TR], cam, depth);
		}
	}
}

// 检测最小一个格子检测
// 追加返回值
//void render_quadtreev4_only_one(quadtree_t *qt, camera_t cam, int depth) {
int render_quadtreev4_only_one(quadtree_t *qt, camera_t cam, int depth) {
	// 原来禁用check可以打印全部记录数据
	// 这是对比12.绑定敌人数据与四叉树 对应名称的代码得知的
	// 不禁用，就是开始检测碰撞
	
	// 追加检测碰撞
	if (check(qt, cam)) {
		if (depth > 1) {
			float xavg = (qt->min.x + qt->max.x) * 0.5f;
			float yavg = (qt->min.y + qt->max.y) * 0.5f;
			DrawLine(xavg, qt->min.y, xavg, qt->max.y, GRAY);
			DrawLine(qt->min.x, yavg, qt->max.x, yavg, GRAY);
			
			// 先检测空
			if (qt->enemy != NULL) {
				if (cam.num != qt->enemy->number && qt->enemy->number != -1) {
					depth--;
					int a = 0;
					a += render_quadtreev4_only_one(qt->childs[CHILD_TL], cam, depth);
					if (a > 0) {
						return 1;
					}
					a += render_quadtreev4_only_one(qt->childs[CHILD_BL], cam, depth);
					if (a > 0) {
						return 1;
					}
					a += render_quadtreev4_only_one(qt->childs[CHILD_BR], cam, depth);
					if (a > 0) {
						return 1;
					}
					a += render_quadtreev4_only_one(qt->childs[CHILD_TR], cam, depth);
					if (a > 0) {
						return 1;
					}
					
				}
				
			}
		} else {
			// 最小格子记录
			// v4_only_one 绘制颜色仅绘制一格
			if (qt->enemy != NULL) {
				
				if (qt->enemy->number != cam.num && qt->enemy->number != -1) {
//					printf("%d\n",qt->enemy->number);
//					if (cam.pos.x > qt->enemy->targetj && cam.pos.x <  qt->enemy->targetj + 30 && cam.pos.y > qt->enemy->targeti && cam.pos.y < qt->enemy->targeti + 30 ) {
//					if (cam.pos.x > qt->enemy->targetj && cam.pos.x <  qt->enemy->targetj + 130 && cam.pos.y > qt->enemy->targeti && cam.pos.y < qt->enemy->targeti + 130 ) {
//					if (cam.pos.x > qt->enemy->targetj-10 && cam.pos.x <  qt->enemy->targetj + 130 && cam.pos.y > qt->enemy->targeti-10 && cam.pos.y < qt->enemy->targeti + 130 ) {
//					if (cam.pos.x >= qt->enemy->targetj && cam.pos.x <  qt->enemy->targetj + 130 && cam.pos.y >= qt->enemy->targeti && cam.pos.y < qt->enemy->targeti + 130 ) {
//					if ( cam.pos.x <  qt->enemy->targetj + 130  && cam.pos.y < qt->enemy->targeti + 130 ) {
//					if ( cam.pos.x <  qt->enemy->targetj + 100  && cam.pos.y < qt->enemy->targeti + 100 ) {
//					if ( cam.pos.x <  qt->enemy->targetj + 10  && cam.pos.y < qt->enemy->targeti + 10 ) {
					
					// 复制粘贴自47.发现实现碰撞检测
//					if (cam.pos.x > qt->enemy->targetj + 1 && cam.pos.x < qt->enemy->targetj + 10 && cam.pos.y + 1 > qt->enemy->targeti && cam.pos.y < qt->enemy->targeti + 10) {
					
					// 自100 进行对照移植
//					if (cam.pos.x > qt->enemy->targetj + 1 && cam.pos.x < qt->enemy->targetj + 10 && cam.pos.y + 1 > qt->enemy->targeti && cam.pos.y < qt->enemy->targeti + 10) {
//					if (cam.pos.x > qt->enemy->targetj && cam.pos.x < qt->enemy->targetj + 10 && cam.pos.y+1 > qt->enemy->targeti && cam.pos.y < qt->enemy->targeti + 10) {
					
					if (qt->enemy->number != cam.num && qt->enemy->number != -1) {
						printf("%d\n", qt->enemy->number);
// 测试之后，反而是黑色比红色准确
//						DrawRectangle(qt->min.x, qt->min.y, qt->max.x - qt->min.x, qt->max.y - qt->min.y, RED);
						DrawRectangle(qt->enemy->targetj, qt->enemy->targeti, 10, 10, BLUE);
						return 1; // 碰撞上了
					}
//					DrawRectangle(qt->enemy->targetj, qt->enemy->targeti, 100, 100,BLUE);
					
				}
			}
		}
	}
	// 没有碰撞就返回0
	return 0;
}

//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
static int screen_width = 1012;
static int screen_height = 1012;

// Quadtree
static int quad_depth = 8; // depth
static int quad_size = 1012; // size
static quadtree_t *root;

// Camera
static float cam_speed = 2; // speed
static float cam_fov = 60.0f; // field of view
static float view_line = 300; // frustum plane
static camera_t camera;


//int enemysum = 100;
int enemysum = 10;
target* enemy;

//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
void UpdateDrawFrame(void);     // Update and Draw one frame

//----------------------------------------------------------------------------------
// Main Enry Point
//----------------------------------------------------------------------------------
int main() {
	// Initialization
	//--------------------------------------------------------------------------------------
	InitWindow(screen_width, screen_height, "raylib: quadtree");
	
	// Create camera & quadtree
	fl = Vector2Zero();
	fr = Vector2Zero();
	camera = create_camera(quad_size / 2, quad_size / 2, cam_fov);
	root = create_quadtree(0, 0, quad_size, quad_size, quad_depth);
	
	
	SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
	//--------------------------------------------------------------------------------------
	
	
	target* enemyv2 = new target[enemysum];
	
	for (int n = 0; n < enemysum; n++) {
		
		enemyv2[n].targetj = rand() % 1000;
		enemyv2[n].targeti = rand() % 1000;
		
		enemyv2[n].targetwidth = rand() % 100;
		enemyv2[n].targetheight = rand() % 200;
		
		enemyv2[n].pic = LoadRenderTexture(enemyv2[n].targetwidth, enemyv2[n].targetheight);
		
		enemyv2[n].islive = 1;
		
		enemyv2[n].number = n;
		printf("%d %d\n", enemyv2[n].targetj, enemyv2[n].targeti);
	}
	
	enemy = enemyv2;
	
	
	for (int n = 0; n < enemysum; n++) {
		BeginTextureMode(enemy[n].pic);
		for (int i = 0; i < enemy[n].targetheight; i++) {
			for (int j = 0; j < enemy[n].targetwidth; j++) {
				DrawPixel(j, i, {n * 20 % 255, n * 20 % 255, n * 20 % 255 % 255, 255});
			}
		}
		EndTextureMode();
	}
	
	// Main game loop
	while (!WindowShouldClose()) {  // Detect window close button or ESC key
		UpdateDrawFrame();
	}
	
	// De-Initialization
	free_quadtree(root);
	//--------------------------------------------------------------------------------------
	CloseWindow();        // Close window and OpenGL context
	//--------------------------------------------------------------------------------------
	
	return 0;
}

//----------------------------------------------------------------------------------
// Module Functions Definition
//----------------------------------------------------------------------------------
void UpdateDrawFrame(void) {
	// Update
	//----------------------------------------------------------------------------------
	// TODO: Update your variables here
	//----------------------------------------------------------------------------------
	//Vector2 mouse_pos = GetMousePosition();
	
	// update camera position
	if (IsKeyDown(KEY_LEFT)) {
		camera.pos.x -= cam_speed;
	} else if (IsKeyDown(KEY_RIGHT)) {
		camera.pos.x += cam_speed;
	}
	if (IsKeyDown(KEY_UP)) {
		camera.pos.y -= cam_speed;
	} else if (IsKeyDown(KEY_DOWN)) {
		camera.pos.y += cam_speed;
	}
	
	// camera angle
	float px = (float)GetMouseX() - camera.pos.x;
	float py = (float)GetMouseY() - camera.pos.y;
	float angle = atan2f(py, px);
	float cam_fov_rad = (camera.fov / 2.0f) * DEG2RAD;
	Vector2 cam_dir = (Vector2) {
		.x = camera.pos.x + (view_line * 0.5f) * cosf(angle),
		.y = camera.pos.y + (view_line * 0.5f) * sinf(angle)
	};
	
	// update frustum left position
	fl.x = camera.pos.x + view_line * cosf(angle - cam_fov_rad);
	fl.y = camera.pos.y + view_line * sinf(angle - cam_fov_rad);
	// update frustum right position
	fr.x = camera.pos.x + view_line * cosf(angle + cam_fov_rad);
	fr.y = camera.pos.y + view_line * sinf(angle + cam_fov_rad);
	
	// Draw
	//----------------------------------------------------------------------------------
	BeginDrawing();
	
	ClearBackground(WHITE);
	
	// 记录旧数据
	static camera_t oldcamera;
	
	// draw quadtree
	
	for (int n = 0; n < enemysum; n++) {
//			不能相同名称的 static, 原来版本仅有一个static camera_t b 所以能跑
//			static camera_t b;
		camera_t b;
		// 测试半天，发现没有加入标号
		b.num = enemy[n].number;
		for (int i = 0; i < enemy[n].targetheight ; i++) {
			b.pos.x = enemy[n].targetj + 0;
			b.pos.y = enemy[n].targeti + i;
			render_quadtree(root, b, quad_depth);
		}
		for (int i = 0; i < enemy[n].targetheight ; i++) {
			b.pos.x = enemy[n].targetj + enemy[n].targetwidth;
			b.pos.y = enemy[n].targeti + i;
			render_quadtree(root, b, quad_depth);
		}
		
		for (int j = 0; j < enemy[n].targetwidth ; j++) {
			b.pos.x = enemy[n].targetj + j;
			b.pos.y = enemy[n].targeti + 0;
			render_quadtree(root, b, quad_depth);
		}
		for (int j = 0; j < enemy[n].targetwidth ; j++) {
			b.pos.x = enemy[n].targetj + j;
			b.pos.y = enemy[n].targeti + enemy[n].targetheight ;
			render_quadtree(root, b, quad_depth);
		}
	}
	
	
	int playerj = camera.pos.x;
	int playeri = camera.pos.y;
	
	// 测试碰撞敌群
	for (int n = 0; n < enemysum; n++) {
		// 一个点
		camera_t b;
		// 自100追加num
		b.num = enemy[n].number;
		
		int a = 0;
		for (int i = 0; i < enemy[n].targetheight ; i ++) {
			b.pos.x = enemy[n].targetj + 0;
			b.pos.y = enemy[n].targeti + i;
			a += render_quadtreev4_only_one(root, b, quad_depth);
			if (a > 0) {
				break;
			}
		}
		for (int i = 0; i < enemy[n].targetheight ; i ++) {
			b.pos.x = enemy[n].targetj + enemy[n].targetwidth - 1;
			b.pos.y = enemy[n].targeti + i;
			a += render_quadtreev4_only_one(root, b, quad_depth);
			if (a > 0) {
				break;
			}
		}
		
		for (int j = 0; j < enemy[n].targetwidth ; j ++) {
			b.pos.x = enemy[n].targetj + j;
			b.pos.y = enemy[n].targeti + 0;
			a += render_quadtreev4_only_one(root, b, quad_depth);
			if (a > 0) {
				break;
			}
		}
		for (int j = 0; j < enemy[n].targetwidth ; j ++) {
			b.pos.x = enemy[n].targetj + j;
			b.pos.y = enemy[n].targeti + enemy[n].targetheight - 1 ;
			a += render_quadtreev4_only_one(root, b, quad_depth);
			if (a > 0) {
				break;
			}
		}
		
		// 随机倒退，减少重叠
		if (a > 0) {
			if (enemy[n].islive == 1) {
				if (enemy[n].targetj < playerj) {
//						enemy[n].targetj += -1 - rand() % 30;
					enemy[n].targetj += -1 - rand() % 10;
				} else if (enemy[n].targetj > playerj) {
//						enemy[n].targetj -= -1 - rand() % 30;
					enemy[n].targetj -= -1 - rand() % 10;
				}
				
				if (enemy[n].targeti > playeri) {
//						enemy[n].targeti -= -1 - rand() % 30;
					enemy[n].targeti -= -1 - rand() % 10;
				} else if (enemy[n].targeti < playeri) {
//						enemy[n].targeti += -1 - rand() % 30;
					enemy[n].targeti += -1 - rand() % 10;
				}
			}
			
		}
		
	}
	
	
	
	// 启用成功，没有旧标记了
	// 改颜色禁用测试碰撞效果
	// 删除旧数据，在敌人移动之前
	for (int n = 0; n < enemysum; n++) {
		camera_t b;
		// 测试批量网格
		// 自100追加num
		b.num = enemy[n].number;
		// 在发现进检测周围一周格子，于是原样删除，就仅删除四周一环格子，
		for (int i = 0; i < enemy[n].targetheight ; i++) {
			b.pos.x = enemy[n].targetj + 0;
			b.pos.y = enemy[n].targeti + i;
			render_quadtreev3_delete(root, b, quad_depth);
		}
		for (int i = 0; i < enemy[n].targetheight ; i++) {
			b.pos.x = enemy[n].targetj + enemy[n].targetwidth;
			b.pos.y = enemy[n].targeti + i;
			render_quadtreev3_delete(root, b, quad_depth);
		}
		
		for (int j = 0; j < enemy[n].targetwidth ; j++) {
			b.pos.x = enemy[n].targetj + j;
			b.pos.y = enemy[n].targeti + 0;
			render_quadtreev3_delete(root, b, quad_depth);
		}
		for (int j = 0; j < enemy[n].targetwidth ; j++) {
			b.pos.x = enemy[n].targetj + j;
			b.pos.y = enemy[n].targeti + enemy[n].targetheight ;
			render_quadtreev3_delete(root, b, quad_depth);
		}
	}
	
	
	DrawRectangleLines(root->min.x, root->min.y, root->max.x - root->min.x, root->max.y - root->min.y, RED);
	
	
	// 绘制敌人
	for (int n = 0; n < enemysum; n++) {
		DrawTexturePro(enemy[n].pic.texture,
			{0, 0, enemy[n].targetwidth, enemy[n].targetheight},
			{enemy[n].targetj, enemy[n].targeti, enemy[n].targetwidth, enemy[n].targetheight},
			{0, 0}, 0, WHITE);
	}
	
	
	// 敌人移动
	for (int n = 0; n < enemysum; n++) {
		if (enemy[n].islive == 1) {
			if (enemy[n].targetj < playerj) {
				enemy[n].targetj += 1;
			} else if (enemy[n].targetj > playerj) {
				enemy[n].targetj -= 1;
			}
			
			if (enemy[n].targeti > playeri) {
				enemy[n].targeti -= 1;
			} else if (enemy[n].targeti < playeri) {
				enemy[n].targeti += 1;
			}
		}
	}
	
	
	
	
	// draw frustum left plane
	DrawLine(camera.pos.x, camera.pos.y, fl.x, fl.y, GREEN);
	// draw frustum right plane
	DrawLine(camera.pos.x, camera.pos.y, fr.x, fr.y, RED);
	
	//  draw camera
	DrawLine(camera.pos.x, camera.pos.y, cam_dir.x, cam_dir.y, YELLOW);
	DrawCircle(camera.pos.x, camera.pos.y, 10, BLUE);
	
	// draw texts
	//DrawText(TextFormat("mouse.pos: (%f, %f)", px, py), 0, 0, 20, DARKGRAY);
	//DrawText(TextFormat("camera.pos: (%f, %f)", camera.pos.x, camera.pos.y), 0, 25, 20, DARKGRAY);
	
	
	DrawText(TextFormat("FPS %d", GetFPS()), 0, 0, 30, BLACK);
	EndDrawing();
	//----------------------------------------------------------------------------------
}

a1309602336
关注
使用四叉树优化碰撞检测
~生命淡如水~
06-18 3893
四叉树是干什么的？ 百度百科 四元树又称四叉树是一种树状数据结构，在每一个节点上会有四个子区块。四元树常应用于二维空间数据的分析与分类。 它将数据区分成为四个象限。数据范围可以是方形或矩形或其他任意形状。 从定义我们可以看出重点信息： 树状结构 四个区块 分类 矩形 图示讲解 讲解之前需要先说明一下四叉树是用来做什么的，明白了原理才好理解它的行为。 使用四叉树就是使用分类的方法，减少碰撞节点的个数，只取出与给定碰撞体相同区域或者压在碰撞体所在区域边上的对象。 将游戏屏幕分为四个区域。 插入对象
用四叉树加速碰撞检测
MaxLykoS的博客
10-04 2451
长话短说 一.Define Quad Tree 四叉树的作用就是从原点开始根据一定的范围画出周围的四个象限，然后每个子象限继续划分为四个孙子象限，以此类推，到达递归深度最大值时停止。 二.在碰撞检测中的作用 如果场景里有1万个障碍物和1个子弹，那么子弹需要和每个障碍物进行一次碰撞检测。而我们进行了空间划分之后，只需要将子弹与其所在的区域内的障碍物进行检测即可。 相当于将碰撞检测分成了两部分，第一部分（粗测）尽可能将不会碰到的物体扔掉，从所有的物体中筛选出与子弹最接近最可能碰到的物体，第二部分（精测）使用尽
Cocos Creator | 碰撞检测优化-四叉树
Valiancer
07-12 3504
四叉树原理本人就不赘述了，很多前辈都有详细的讲解 首先说明下四叉树并不是一个碰撞引擎，它只是一种减少碰撞候选者的算法，所以在利用四叉树得到碰撞候选元素后，还需要去检测这些候选元素与目标元素是否发生碰撞 2D中是四叉树，3D中则对应的为八叉树 项目（微信小游戏《宇宙少女》）中实测： 同屏极限情况下，可碰撞元素为： 200左右子弹+70左右怪物+若干buff+玩家 碰撞关系为： 子弹和怪物碰撞 特定怪物和其他怪物碰撞反弹 玩家和怪物碰撞 玩家和buff碰撞 ...
游戏应用：AOI机制四叉树碰撞检测
weixin_41919596的博客
01-05 915
随笔：游戏中使用AOI机制 四叉树来快速确定目标的位置和分发事件
四叉树优化碰撞检测
u010536615的专栏
03-27 937
原文地址：http://blog.csdn.net/qq276592716/article/details/45999831 游戏中碰撞检测分为两个阶段：broad phase 和 narrow phase。接下来要介绍的就是broad phase。在broad phase这个阶段，我们的主要任务是将屏幕上的物体进行筛选，筛选出最可能发生碰撞的物体集合。 试想想，屏幕上有N个物体，
cocosCreator3.X四叉树碰撞检测 ts
weixin_63087450的博客
11-10 444
我们为了读起来方便也写成了按顺序压入临时数组0 1 2 3来表示输入范围在当前节点范围的哪几个象限，那么问题是：输入的范围可能位于一个象限时有多种可能，即他会处于一个象限的同时也处于另一个或多个象限。我们从结果看，列出所有的可能寻找共通点，便豁然开朗。这其实时坐标转换的问题，只要在传入时修改一下，或者直接更改第一次创建四叉树所使用的节点的轴值，设置为(0,0)即可。两个参数的意义，当这两个参数联合判断时便能得到传入的范围是否处于第一象限的结果（但不仅限于第二象限），我们可以再看看第二象限的案例。
2D碰撞优化 四叉树碰撞检测算法
liuyingbo.com
06-02 1322
代码解析 构造函数 function Quadtree( bounds, max_objects, max_levels, level ) { this.max_objects = max_objects || 10;　//每个区域可以容纳的最大对象数，超过就需要划分 this.max_levels = max_levels || 4;　//最多划几层四叉树 this.level = level || 0;　//当前树或子树的层.
冰冰教你用“四叉树”手写“碰撞检测”，太感动了！
奎特尔星球
07-08 573
四叉树与引擎内置碰撞检测的结合运用，完整项目见文末。效果预览绿色为参加检测的对象(当前四叉树节点)，红色为碰撞对象。如何使用引入脚本 QuadtreeCollision.ts ， 新建一...
2D空间中使用Quadtree四叉树进行碰撞检测优化
热门推荐
Mr_厚厚的博客
12-22 1万+
很多游戏中都需要使用碰撞检测算法检测两个物体的碰撞，但通常这些碰撞检测算法都很耗时很容易拖慢游戏的速度。这里我们学习一下使用四叉树来对碰撞检测进行优化，优化的根本是碰撞检测时跳过那些明显离得很远的物体，加快检测速度。【注：这里算法的实现使用的Java语言，但算法和语言没有关系，理解了其中的原理可以应用到各种碰撞检测场景中。】 介绍 碰撞检测是多数游戏的关键部分，不管是2d游戏还是3d游戏中，检测
QuadTree四叉树实现代码 C#
02-07
总之，这个C#实现的四叉树代码提供了创建、维护和使用四叉树结构的功能，特别适合处理2D空间中的碰撞检测问题。通过理解和应用这些文件，开发者可以掌握四叉树的基本原理，并将其应用于实际的项目中，优化性能，提升...
四叉树代码
04-09
四叉树（Quadtree）是一种数据结构，它与二叉树类似，但每个节点有四个子节点，分别代表上、下、左、右四个方向。...提供的代码文件可能包含了四叉树的实现细节，进一步学习这些代码将有助于深入理解四叉树的工作机制。
ts-pixi-exp：尝试四叉树碰撞和PIXI
02-18
本项目“ts-pixi-exp”旨在探索和实现基于TypeScript的四叉树碰撞检测以及与PIXI.js图形库的集成。 四叉树是一种数据结构，特别适用于在二维空间中组织和查询对象，特别是在游戏开发或实时图形应用中处理大量静态或...
四叉树　unity实现　源码
08-17
通过研究这个压缩包中的源代码，开发者可以深入了解如何在Unity中实现四叉树，以及如何将其与其他Unity组件如时间线、网络框架和XR技术集成。这不仅可以提升开发者的游戏开发技能，还有助于理解Unity引擎的工作原理...
JS实现的四叉树算法详解
12-09
最近在看canvas动画方面教程，里面提到了采用四叉树检测碰撞。之前也看到过四叉树这个名词，但是一直不是很懂。于是就又找了一些四叉树方面的资料看了看，做个笔记，就算日后忘了，也可以回来看看。 QuadTree四叉树...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 397
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
最新发布
qq_42568323的博客
09-27 865
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 522
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
python 实现harmonic series调和级数算法
luthane的博客
09-24 917
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
JS实现的四叉树碰撞检测详解与代码示例
四叉树是一种数据结构，其每个节点拥有四个子节点，用于递归地将二维空间划分为四个子区域，常用于空间索引、碰撞检测、图像处理等领域。在游戏开发中，特别是碰撞检测方面，四叉树能显著减少碰撞检查的计算量，提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值