网站开发工程师报名地点,系统开发生命周期法,做一些购物网站,seo岗位职责前置知识
c分享#xff5c;并查集从入门到出门 - 力扣#xff08;LeetCode#xff09; 彻底搞懂克鲁斯卡尔#xff08;Kruskal#xff09;算法#xff08;附C代码实现#xff09; - QuanHa - 博客园 (cnblogs.com) 白色点矩形是地牢#xff0c;其中白线是按照krsukal…前置知识
c分享并查集从入门到出门 - 力扣LeetCode 彻底搞懂克鲁斯卡尔Kruskal算法附C代码实现 - QuanHa - 博客园 (cnblogs.com) 白色点矩形是地牢其中白线是按照krsukal算法连接的画总长最短的线连出来的路径 其中关键算法
#include stdio.h#define MAX_VEX 12
#define MAX_EDGE 144typedef struct edge {int startpoint; // 起点在数组中的序号int endpoint; // 终点在数组中的序号int weight;
} edge;typedef struct link {int startx; // 起点的坐标int starty;int endx; // 终点的坐标int endy;int used; // 是否已经使用int lenth; // 距离edge edgelink;
} link;typedef struct target {int targeti 0; // 左上角网格坐标int targetj 0;int targetwidth 0; // 长宽int targetheight 0;int islive 0;// RenderTexture2D* picture; // 敌人贴图
// RenderTexture2D picture; // 敌人贴图int** oldmap; // 局部复原数据int** mapv3; // 像素也当成网格每个记录像素是否能穿过target* area; // 敌人内部的点int arealenth; // 用于记录范围lenth是半径
} target;int find_root(int roots[], int n) {while (roots[n] ! -1) {n roots[n];}return n;
}int main() {link linkside[12][12]; // 兼容之前参数int vex 12; //顶点个数int edgeside 12 * 12; //边个数link graph[MAX_EDGE];edge graphv2[MAX_EDGE];//
// for (int k 0; k edgeside; k) {
// for (int n 0; n 11; n) {
// for (int m 0; m 11; m) {
// if (linkside[n][m].used 0) {
// graph[k].startx linkside[n][m].startx;
// graph[k].starty linkside[n][m].starty;
// graph[k].endx linkside[n][m].endx;
// graph[k].endy linkside[n][m].endy;
// graph[k].lenth linkside[n][m].lenth;
// graph[k].used 1;
//
// graphv2[k].startpointn;
// graphv2[k].endpointm;
// graph[k].lenthlinkside[n][m].lenth;
// }
// }
// }
// }for (int n 0; n 144; n) {graph[n].used 0;}int k 0;for (int n 0; n 11; n) {for (int m 0; m 11; m) {if (linkside[n][m].used 0) {graph[k].startx linkside[n][m].startx;graph[k].starty linkside[n][m].starty;graph[k].endx linkside[n][m].endx;graph[k].endy linkside[n][m].endy;graph[k].lenth linkside[n][m].lenth;graph[k].used 1;graph[k].edgelink.startpoint n;graph[k].edgelink.endpoint m;graph[k].edgelink.weight linkside[n][m].lenth;k;}}}// 标记不用数据for (int n 0; n 144; n) {if (graph[n].used 0) {graph[n].lenth 999999;graph[n].edgelink.weight 999999;}}// 插入排序link max;int index;for (int n 0; n 144; n) {index n;max graph[n];for (int m n 1; m 144; m) {if (graph[m].lenth max.lenth) {max graph[m];index m;}}graph[index] graph[n];graph[n] max;}int roots[MAX_VEX]; //根数组存放各顶点的根节点以区别是否属于同一个集合edge MST[MAX_EDGE]; //存放最小生成树minimum spanning treeint count 0;for (int n 0; n MAX_VEX; n) {roots[n] -1;}// for (int n 0; n MAX_EDGE; n) {
//
// }for (int n 0; n MAX_EDGE; n) {if (graph[n].used 1) {int vex_m find_root(roots, graph[n].edgelink.startpoint);int vex_n find_root(roots, graph[n].edgelink.endpoint);if (vex_m ! vex_n) { //如果两者的根节点不同说明他们属于不同的集合可以相连MST[count] graph[n].edgelink;//将此边放入MST数组count;roots[vex_m] vex_n; //将两个树合并即将顶点vex_n作为vex_m的根节点}if (count vex - 1) {break;}}}for (int i 0; i vex - 1; i){printf((%d,%d)%d\n, MST[i].startpoint, MST[i].endpoint, MST[i].weight); //打印最小生成树}return 0;
} int vex 12; //顶点个数int edgeside 12 * 12; //边个数link graph[MAX_EDGE];edge graphv2[MAX_EDGE];/*// for (int k 0; k edgeside; k) {// for (int n 0; n 11; n) {// for (int m 0; m 11; m) {// if (linkside[n][m].used 0) {// graph[k].startx linkside[n][m].startx;// graph[k].starty linkside[n][m].starty;// graph[k].endx linkside[n][m].endx;// graph[k].endy linkside[n][m].endy;// graph[k].lenth linkside[n][m].lenth;// graph[k].used 1;//// graphv2[k].startpointn;// graphv2[k].endpointm;// graph[k].lenthlinkside[n][m].lenth;// }// }// }// }*/for (int n 0; n 144; n) {graph[n].used 0;}
//int k 0;for (int n 0; n 11; n) {for (int m 0; m 11; m) {if (linkside[n][m].used 0) {graph[k].startx linkside[n][m].startx;graph[k].starty linkside[n][m].starty;graph[k].endx linkside[n][m].endx;graph[k].endy linkside[n][m].endy;graph[k].lenth linkside[n][m].lenth;graph[k].used 1;graph[k].edgelink.startpoint n;graph[k].edgelink.endpoint m;graph[k].edgelink.weight linkside[n][m].lenth;k;}}}// 标记不用数据for (int n 0; n MAX_EDGE; n) {if (graph[n].used 0) {graph[n].lenth 999999;graph[n].edgelink.weight 999999;}}// 插入排序link max;int index;for (int n 0; n MAX_EDGE; n) {index n;max graph[n];for (int m n 1; m MAX_EDGE; m) {if (graph[m].lenth max.lenth) {max graph[m];index m;}}graph[index] graph[n];graph[n] max;}int roots[MAX_VEX]; //根数组存放各顶点的根节点以区别是否属于同一个集合edge MST[MAX_EDGE]; //存放最小生成树minimum spanning treeint count 0;for (int n 0; n MAX_VEX; n) {roots[n] -1;}for (int n 0; n MAX_EDGE; n) {if (graph[n].used 1) {int vex_m find_root(roots, graph[n].edgelink.startpoint);int vex_n find_root(roots, graph[n].edgelink.endpoint);if (vex_m ! vex_n) { //如果两者的根节点不同说明他们属于不同的集合可以相连MST[count] graph[n].edgelink;//将此边放入MST数组count;roots[vex_m] vex_n; //将两个树合并即将顶点vex_n作为vex_m的根节点}if (count vex - 1) {break;}}}for (int k 0; k vex - 1; k) {
// printf((%d,%d)%d\n, MST[k].startpoint, MST[k].endpoint, MST[k].weight); //打印最小生成树int start MST[k].startpoint;int end MST[k].endpoint;for (int n 0; n 10; n) {drawline(linkside[start][end].startyn,linkside[start][end].startx,linkside[start][end].endyn,linkside[start][end].endx, enemy[i].mapv3, 254, enemy[i].targetheight*pixnum, enemy[i].targetwidth*pixnum);drawline(linkside[start][end].starty,linkside[start][end].startxn,linkside[start][end].endy,linkside[start][end].endxn, enemy[i].mapv3, 254, enemy[i].targetheight*pixnum, enemy[i].targetwidth*pixnum);}} 完整代码
//author bilibili 民用级脑的研发记录
// 开发环境 小熊猫c 2.25.1 raylib 版本 4.5
// 2024-7-14
// AABB 碰撞检测 在拖拽绘制放大缩小中
// 2024-7-20
// 直线改每帧打印一个点生长的直线直线炮弹
// 2024-8-4
// 实现敌人追击与敌人死亡与mapv2 敌人轨迹不绘制
#include raylib.h
#include stdio.h
#include math.h
#include stdlib.h
#include time.h#define MAX_VEX 12
#define MAX_EDGE 144// 重整原因解决新函数放大缩小之下raylib 的网格采样部分选择数组的一部分刷新倒缓冲区里
// 从直接建立缓冲区到先在数组里进行移动然后再设置检查缓冲区
// 最大距离 - 当前坐标实现坐标系变化同时对应最顶上变成新坐标下的最底下可750-1749数数得到// 炮弹
typedef struct lineboom {int playeriv2 0; // 一开始发射炮弹的玩家坐标int playerjv2 0;int drawiv2 0; // 发射目标位置坐标int drawjv2 0;int oldx 0; // 记录上一格子用于覆盖旧黑色点产生炮弹轨迹int oldy 0;int atking 0; // 是否正在攻击因为有好几个炮弹命中之后就结束炮弹运行int timev3 0; // 记录运行时间或者长度到达位置炮弹爆炸。v3是沿用time,和之前代码变量名字一样
// int toward -1; // 朝向在剥离代码发现不同朝向直线代码不同结束比较符号不同int isboom 0; // 是否到了爆炸的时机在修改直线代码中发现的可以合并重复代码产生的控制变量
} lineboom;
// 随机敌人
typedef struct target {int targeti 0; // 左上角网格坐标int targetj 0;int targetwidth 0; // 长宽int targetheight 0;int islive 0;// RenderTexture2D* picture; // 敌人贴图RenderTexture2D picture; // 敌人贴图int** oldmap; // 局部复原数据int** mapv3; // 像素也当成网格每个记录像素是否能穿过target* area; // 敌人内部的点int arealenth; // 用于记录范围lenth是半径
} target;
// 边
//typedef struct link {
// int startx; // 起点
// int starty;
// int endx; // 终点
// int endy;
// int used; // 是否已经使用
// int lenth; // 距离
//
//} link;// 边
typedef struct edge {int startpoint; // 起点在数组中的序号int endpoint; // 终点在数组中的序号int weight;
} edge;
// 边
typedef struct link {int startx; // 起点的坐标int starty;int endx; // 终点的坐标int endy;int used; // 是否已经使用int lenth; // 距离edge edgelink; // 需要查点记录所在数组位置
} link;
// 并查集查是否连通
int find_root(int roots[], int n) {while (roots[n] ! -1) {n roots[n];}return n;
}// 检测碰撞AABB碰撞检测检测到碰撞时碰撞产生矩形左上角的坐标是 bangi j ,碰撞长宽是 bangwidth, bangheight
// 复制粘贴自碰撞检测
int bang(int drawi, int drawj, int mousewidth, int mouseheight, int targeti, int targetj, int targetwidth, int targetheight, int *bangi, int *bangj, int *bangwidth, int *bangheight) {int isbang 0; // 如果碰撞就返回1
// 变- i 变 jif (drawi targeti targeti drawi - mouseheight) {// 左上角重叠if (targeti - targetheight drawi - mouseheight) {if (drawj targetj targetj drawj mousewidth) {// 左上角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight - (drawi - targeti) ; i) {
// for (int j 0; j mousewidth - ( targetj - drawj); j) {
// map[targeti - i][targetj j] 2024;
// }map[targeti - i][targetj] 2024;
// }
// for (int j 0; j mousewidth - ( targetj - drawj); j) {
// map[targeti][targetj j] 2024;
// }
// 左上角位置*bangi targeti;*bangj targetj;
// 长度就是注释掉的循环的次数*bangwidth mousewidth - (targetj - drawj);*bangheight -(mouseheight - (drawi - targeti));isbang 1;}//被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight - (drawi - targeti) ; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j targetwidth; j) {
// map[targeti - i][targetj j] 2024;
// }
// }*bangi targeti;*bangj targetj;// 注意负号代表向下*bangwidth targetwidth;*bangheight -(mouseheight - (drawi - targeti));isbang 1;}} else if (targetj drawj drawj targetj targetwidth) {// 右下角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight - (drawi - targeti) ; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j mousewidth ; j) {
// map[targeti - i][drawj j] 2024;
// }
// }*bangi targeti;*bangj drawj;*bangwidth mousewidth;*bangheight -(mouseheight - (drawi - targeti));isbang 1;}
// //被包围了else if (targetj targetwidth drawj mousewidth) {// for (int i 0; i mouseheight - (drawi - targeti) ; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j targetwidth - (drawj - targetj); j) {
// map[targeti - i][drawj j] 2024;
// }
// }*bangi targeti;*bangj drawj;*bangheight -(mouseheight - (drawi - targeti));*bangwidth targetwidth - (drawj - targetj);isbang 1;}}
// for (int i 0; i mouseheight - (drawi - targeti) ; i) {
// map[targeti - i][targetj] 2024;
// }}//被包围了else if (targeti - targetheight drawi - mouseheight) {
// for (int i 0; i targetheight; i) {
// map[targeti - i][targetj] 2024;
// }if (drawj targetj targetj drawj mousewidth) {// 左上角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j mousewidth - ( targetj - drawj); j) {
// map[targeti - i][targetj j] 2024;
// }
// }*bangi targeti;*bangj targetj;*bangwidth mousewidth - (targetj - drawj);*bangheight -targetheight;isbang 1;}//被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j targetwidth; j) {
// map[targeti - i][targetj j] 2024;
// }
// }*bangi targeti;*bangj targetj;*bangwidth targetwidth;*bangheight targetheight;isbang 1;}} else if (targetj drawj drawj targetj targetwidth) {// 右下角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j mousewidth ; j) {
// map[targeti - i][drawj j] 2024;
// }
// }*bangi targeti;*bangj drawj;*bangwidth mousewidth;*bangheight targetheight;isbang 1;}
// //被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight; i) {map[targeti - i][targetj] 2024;
// for (int j 0; j targetwidth - (drawj - targetj); j) {
// map[targeti - i][drawj j] 2024;
// }
// }*bangi targeti;*bangj drawj;*bangwidth targetwidth - (drawj - targetj);*bangheight -targetheight;isbang 1;}}}} else if (targeti drawi drawi targeti - targetheight) {// 被包围了if (targeti - targetheight drawi - mouseheight) {
// for (int i 0; i mouseheight ; i) {
// map[drawi - i][targetj] 2024;
// }if (drawj targetj targetj drawj mousewidth) {// 左上角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight ; i) {map[drawi - i][targetj] 2024;
// for (int j 0; j mousewidth - ( targetj - drawj); j) {
// map[drawi - i][targetj j] 2024;
// }
// }*bangi drawi;*bangj targetj;*bangwidth mousewidth - ( targetj - drawj);*bangheight -mouseheight;isbang 1;}//被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight ; i) {map[drawi - i][targetj] 2024;
// for (int j 0; j targetwidth; j) {
// map[drawi - i][targetj j] 2024;
// }
// }*bangi drawi;*bangj targetj;*bangwidth targetwidth;*bangheight -mouseheight;isbang 1;}} else if (targetj drawj drawj targetj targetwidth) {// 右下角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight ; i) {map[drawi - i][targetj] 2024;
// for (int j 0; j mousewidth ; j) {
// map[drawi - i][drawj j] 2024;
// }
// }*bangi drawi;*bangj drawj;*bangwidth mousewidth;*bangheight -mouseheight;isbang 1;}
// //被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i mouseheight ; i) {map[drawi - i][targetj] 2024;
// for (int j 0; j targetwidth - (drawj - targetj); j) {
// map[drawi - i][drawj j] 2024;
// }
// }*bangi drawi;*bangj drawj;*bangwidth targetwidth - (drawj - targetj);*bangheight -mouseheight;isbang 1;}}}// //被包围了else if (targeti - targetheight drawi - mouseheight) {
// for (int i 0; i targetheight - ( targeti - drawi ); i) {
// map[drawi - i][targetj] 2024;
// }if (drawj targetj targetj drawj mousewidth) {// 左上角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight - ( targeti - drawi ); i) {map[drawi - i][targetj] 2024;
// for (int j 0; j mousewidth - ( targetj - drawj); j) {
// map[drawi - i][targetj j] 2024;
// }
// }*bangi drawi;*bangj targetj;*bangwidth mousewidth - ( targetj - drawj);*bangheight -(targetheight - ( targeti - drawi ));isbang 1;}//被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight - ( targeti - drawi ); i) {map[drawi - i][targetj] 2024;
// for (int j 0; j targetwidth; j) {
// map[drawi - i][targetj j] 2024;
// }
// }*bangi drawi;*bangj targetj;*bangwidth targetwidth;*bangheight -(targetheight - ( targeti - drawi ));isbang 1;}} else if (targetj drawj drawj targetj targetwidth) {// 右下角重叠if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight - ( targeti - drawi ); i) {map[drawi - i][targetj] 2024;
// for (int j 0; j mousewidth ; j) {map[drawi - i][drawj j] 2024;
// map[drawi - i][drawj j] 2024;
// }
// }*bangi drawi;*bangj drawj;*bangwidth mousewidth;*bangheight -(targetheight - ( targeti - drawi ));isbang 1;}
// //被包围了else if (targetj targetwidth drawj mousewidth) {
// for (int i 0; i targetheight - ( targeti - drawi ); i) {
// map[drawi - i][targetj] 2024;
// for (int j 0; j targetwidth - (drawj - targetj); j) {
// map[drawi - i][drawj j] 2024;
// }
// }*bangi drawi;*bangj drawj;*bangwidth targetwidth - (drawj - targetj);*bangheight -(targetheight - ( targeti - drawi ));isbang 1;}}}}if (isbang 1) {return isbang;} else {return 0;}
}// 直线攻击检测恢复炮弹个数
void checkend(lineboom* booms, int boomsum, int* have, int** map, int mapi, int mapj) {for (int n 0; n boomsum; n) {if (booms[n].isboom 1) {for (int i 0; i 3; i) {for (int j 0; j 10; j) {// 注意m 增加数字增加却是往上增加所以需要往下走要减if (booms[n].drawiv2 - i 0 || booms[n].drawiv2 - i mapi || booms[n].drawjv2 j 0 || booms[n].drawjv2 j mapj) {break;}map[booms[n].drawiv2 - i][booms[n].drawjv2 j] 1224;}}booms[n].atking 0;booms[n].timev3 0;booms[n].isboom 0;*have 1;}}}// 炮弹爆炸
void checkboom(lineboom booms, target* enemy, int** map, int enemysum, int mapi, int mapj) {// 直线炮弹碰撞检测for (int n 0; n enemysum; n) {int bangi 0;int bangj 0;int bangwidth 0;int bangheight 0;// 最小是11这样才绘制一次此时绘制到炮弹点上if (bang(booms.oldy, booms.oldx, 10, 10, enemy[n].targeti, enemy[n].targetj, enemy[n].targetwidth, enemy[n].targetheight, bangi, bangj, bangwidth, bangheight)) {for (int i 0; i bangheight; i--) {for (int j 0; j bangwidth; j) {// m 小于零因为高度是负数向下原因是之前bang 函数代码直接记录符号了都是向下负数小于零加一个负数即可// 浅蓝色if (bangi i 0 || bangi i mapi || bangj j 0 || bangj j mapj) {break;}map[bangi i][bangj j] 12;}}// 敌人死亡这是在敌人移动之后追加的代码enemy[n].islive 0;
// printf(bang ji width height %d %d %d %d\n, bangj, bangi, bangwidth, bangheight);}}
}
// 直线炮弹移动攻击
void lineatk(lineboom* booms, int boomsum, int** map) {float k 0;for (int n 0; n boomsum; n) {// 如果是正在攻击的炮弹if (booms[n].atking 1) {} else {continue;}// 如果炮弹已经发射一格if (booms[n].timev3 0) {} else {// 用黄色覆盖第一个点map[booms[n].oldy][booms[n].oldx] 224;}int drawj booms[n].drawjv2;int drawi booms[n].drawiv2;int playeri booms[n].playeriv2;int playerj booms[n].playerjv2;// 重整向东走东北东南偏// 追加两个大小情况if (drawj - playerj 0 // 0 0 会导致炮弹不能移动炮弹数目不恢复((drawi - playeri 0 drawi - playeri drawj - playerj)|| (drawi - playeri 0 (-(drawi - playeri)) drawj - playerj))) {// 炮弹到达目的地就爆炸往东南北偏时if (drawj - playerj booms[n].timev3) {booms[n].isboom 1;}// 东北偏// 注意大于0if (drawi - playeri 0 drawi - playeri drawj - playerj) {k (drawi - playeri) / (1.0 * ( drawj - playerj));int height 0;float a 0;for (int lenth 0; lenth drawj - playerj; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri height][playerj lenth] 1949;
// lenth (drawj - playerj 改 if (lenth booms[n].timev3 || lenth (drawj - playerj)) {booms[n].timev3 lenth 1;map[playeri height][playerj lenth] 1949;booms[n].oldy playeri height;booms[n].oldx playerj lenth;break;}}}//东南偏else if (drawi - playeri 0 (-(drawi - playeri)) drawj - playerj) {k -(drawi - playeri) / (1.0 * ( drawj - playerj));int height 0;float a 0;for (int lenth 0; lenth drawj - playerj; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri (-height)][playerj lenth] 1949;if (lenth booms[n].timev3 || lenth (drawj - playerj)) {booms[n].timev3 lenth 1;map[playeri (-height)][playerj lenth] 1949;booms[n].oldy playeri (- height);booms[n].oldx playerj lenth;break;}}}}// 向西走西北西南偏else if (drawj - playerj 0 // 注意 部分 drawi - playeri -(drawj - playerj) 可以等于这个是斜线((drawi - playeri 0 drawi - playeri -(drawj - playerj))|| (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj)))) {// 炮弹到达目的地就爆炸往西南北偏时if (-(drawj - playerj) booms[n].timev3) {booms[n].isboom 1;}// 西北偏// 注意drawi - playeri大于0if (drawi - playeri 0 drawi - playeri -(drawj - playerj)) {k (drawi - playeri) / (1.0 * (-( drawj - playerj)));int height 0;float a 0;for (int lenth 0; lenth -(drawj - playerj); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri height][playerj (-lenth)] 1949;if (lenth booms[n].timev3 || lenth -(drawj - playerj)) {booms[n].timev3 lenth 1;map[playeri height][playerj (-lenth)] 1949;booms[n].oldy playeri height;booms[n].oldx playerj (-lenth);break;}}}//西南偏else if (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj)) {k -(drawi - playeri) / (1.0 * (-( drawj - playerj)));int height 0;float a 0;// 注意在测试检测方位后发现没有增加-号for (int lenth 0; lenth -(drawj - playerj); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri (-height)][playerj (-lenth)] 1949;if (lenth booms[n].timev3 || lenth (drawj - playerj)) {booms[n].timev3 lenth 1;map[playeri (-height)][playerj (-lenth)] 1949;booms[n].oldy playeri (- height);booms[n].oldx playerj (-lenth);break;}}}}// 重整向北走东北西北偏if (drawi - playeri 0 ((drawi - playeri 0 drawi - playeri drawj - playerj drawj - playerj 0)|| (drawi - playeri 0 drawi - playeri -(drawj - playerj) drawj - playerj 0) )) {if (drawi - playeri booms[n].timev3) {booms[n].isboom 1;}// 东北偏// 注意大于0if (drawi - playeri 0 drawi - playeri drawj - playerj drawj - playerj 0) {k (drawj - playerj) / (1.0 * ( drawi - playeri));int height 0;float a 0;for (int lenth 0; lenth drawi - playeri; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri lenth][playerj height] 1949;
// lenth (drawi - playeri 改 解决炮弹不回复问题if (lenth booms[n].timev3 || lenth (drawi - playeri)) {booms[n].timev3 lenth 1;
// booms[n].timev3 lenth 10;map[playeri lenth][playerj height ] 1949;booms[n].oldy playeri lenth;booms[n].oldx playerj height ;break;}}}// 西北偏// 注意drawi - playeri大于0
// drawj - playerj 0 等于0是竖直的线// 发现bug 间距黑色线改lenth 间隔发现黑色点间距变化// 注意垂直部分大于0但不是等于0和西北偏和东北偏如果在一块会有垂直的黑色间距线
// if (drawi - playeri 0 drawi - playeri -(drawj - playerj) drawj - playerj 0) {if (drawi - playeri 0 drawi - playeri -(drawj - playerj) drawj - playerj 0) {k -(drawj - playerj) / (1.0 * ( drawi - playeri));int height 0;float a 0;for (int lenth 0; lenth drawi - playeri; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri lenth][playerj (-height)] 1949;if (lenth booms[n].timev3 || lenth (drawi - playeri)) {booms[n].timev3 lenth 1;
// booms[n].timev3 lenth 3;map[playeri lenth][playerj (-height)] 1949;booms[n].oldy playeri lenth;booms[n].oldx playerj (-height);break;}}
// map[drawi][drawj] 224;}}// 向南走东南西南偏else if (drawi - playeri 0 ((drawi - playeri 0 -(drawi - playeri) drawj - playerj drawj - playerj 0)|| (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj) drawj - playerj 0))) {if (-(drawi - playeri) booms[n].timev3) {booms[n].isboom 1;}// 东南偏// 注意drawi - playeri大于0if (drawi - playeri 0 -(drawi - playeri) drawj - playerj drawj - playerj 0) {k (drawj - playerj) / (1.0 * (-( drawi - playeri)));int height 0;float a 0;for (int lenth 0; lenth -(drawi - playeri); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri (-lenth)][playerj height] 1949;if (lenth booms[n].timev3 || lenth -(drawi - playeri)) {booms[n].timev3 lenth 1;map[playeri (-lenth)][playerj height ] 1949;booms[n].oldy playeri (-lenth);booms[n].oldx playerj height;break;}}// map[drawi][drawj] 224;}//西南偏else if (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj) drawj - playerj 0) {k -(drawj - playerj) / (1.0 * (-( drawi - playeri)));int height 0;float a 0;// 注意在测试检测方位后发现没有增加-号for (int lenth 0; lenth -(drawi - playeri); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}
// map[playeri (-lenth)][playerj (-height)] 1949;if (lenth booms[n].timev3 || lenth -(drawi - playeri)) {booms[n].timev3 lenth 1;map[playeri (-lenth)][playerj (-height)] 1949;booms[n].oldy playeri (-lenth);booms[n].oldx playerj (-height);break;}}}}}
}void drawline(int drawi, int drawj, int playeri, int playerj, int** map, int sign, int mapi, int mapj) {float k 0;// 重整向东走东北东南偏// 追加两个大小情况if (drawj - playerj 0 // 0 0 会导致炮弹不能移动炮弹数目不恢复((drawi - playeri 0 drawi - playeri drawj - playerj)|| (drawi - playeri 0 (-(drawi - playeri)) drawj - playerj))) {// 东北偏// 注意大于0if (drawi - playeri 0 drawi - playeri drawj - playerj) {k (drawi - playeri) / (1.0 * ( drawj - playerj));int height 0;float a 0;for (int lenth 0; lenth drawj - playerj; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri height 0 playeri height mapi playerj lenth 0 playerj lenth mapj) {map[playeri height][playerj lenth] sign;}}}//东南偏else if (drawi - playeri 0 (-(drawi - playeri)) drawj - playerj) {k -(drawi - playeri) / (1.0 * ( drawj - playerj));int height 0;float a 0;for (int lenth 0; lenth drawj - playerj; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri (-height) 0 playeri (-height) mapi playerj lenth 0 playerj lenth mapj) {map[playeri (-height)][playerj lenth] sign;}}}}// 向西走西北西南偏else if (drawj - playerj 0 // 注意 部分 drawi - playeri -(drawj - playerj) 可以等于这个是斜线((drawi - playeri 0 drawi - playeri -(drawj - playerj))|| (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj)))) {// 炮弹到达目的地就爆炸往西南北偏时// 西北偏// 注意drawi - playeri大于0if (drawi - playeri 0 drawi - playeri -(drawj - playerj)) {k (drawi - playeri) / (1.0 * (-( drawj - playerj)));int height 0;float a 0;for (int lenth 0; lenth -(drawj - playerj); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri height 0 playeri height mapi playerj (-lenth) 0 playerj (-lenth) mapi) {map[playeri height][playerj (-lenth)] sign;}}}//西南偏else if (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj)) {k -(drawi - playeri) / (1.0 * (-( drawj - playerj)));int height 0;float a 0;// 注意在测试检测方位后发现没有增加-号for (int lenth 0; lenth -(drawj - playerj); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri (-height) 0 playeri (-height) mapi playerj (-lenth) 0 playerj (-lenth) mapj) {map[playeri (-height)][playerj (-lenth)] sign;}}}}// 重整向北走东北西北偏if (drawi - playeri 0 ((drawi - playeri 0 drawi - playeri drawj - playerj drawj - playerj 0)|| (drawi - playeri 0 drawi - playeri -(drawj - playerj) drawj - playerj 0) )) {// 东北偏// 注意大于0if (drawi - playeri 0 drawi - playeri drawj - playerj drawj - playerj 0) {k (drawj - playerj) / (1.0 * ( drawi - playeri));int height 0;float a 0;for (int lenth 0; lenth drawi - playeri; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri lenth 0 playeri lenth mapi playerj height 0 playerj height mapj) {map[playeri lenth][playerj height] sign;}}}// 西北偏// 注意drawi - playeri大于0
// drawj - playerj 0 等于0是竖直的线// 发现bug 间距黑色线改lenth 间隔发现黑色点间距变化// 注意垂直部分大于0但不是等于0和西北偏和东北偏如果在一块会有垂直的黑色间距线
// if (drawi - playeri 0 drawi - playeri -(drawj - playerj) drawj - playerj 0) {if (drawi - playeri 0 drawi - playeri -(drawj - playerj) drawj - playerj 0) {k -(drawj - playerj) / (1.0 * ( drawi - playeri));int height 0;float a 0;for (int lenth 0; lenth drawi - playeri; lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri lenth 0 playeri lenth mapi playerj (-height) 0 playerj (-height) mapj) {map[playeri lenth][playerj (-height)] sign;}}}}// 向南走东南西南偏else if (drawi - playeri 0 ((drawi - playeri 0 -(drawi - playeri) drawj - playerj drawj - playerj 0)|| (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj) drawj - playerj 0))) {// 东南偏// 注意drawi - playeri大于0if (drawi - playeri 0 -(drawi - playeri) drawj - playerj drawj - playerj 0) {k (drawj - playerj) / (1.0 * (-( drawi - playeri)));int height 0;float a 0;for (int lenth 0; lenth -(drawi - playeri); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri (-lenth) 0 playeri (-lenth) mapi playerj height 0 playerj height mapj) {map[playeri (-lenth)][playerj height] sign;}}}//西南偏else if (drawi - playeri 0 (-(drawi - playeri)) -(drawj - playerj) drawj - playerj 0) {k -(drawj - playerj) / (1.0 * (-( drawi - playeri)));int height 0;float a 0;// 注意在测试检测方位后发现没有增加-号for (int lenth 0; lenth -(drawi - playeri); lenth) {a a k;if (a 1) {a - 1;height 1;} else {}if (playeri (-lenth) 0 playeri (-lenth) mapi playerj (-height) 0 playerj (-height) mapj) {map[playeri (-lenth)][playerj (-height)] sign;}}}}
}int main() {int boomsum;boomsum 100;// 炮弹数目记录int have boomsum;// 我方直线炮弹lineboom* booms new lineboom[boomsum];for (int i 0; i boomsum; i) {booms[i].playeriv2 0;booms[i].playerjv2 0;booms[i].drawiv2 0;booms[i].drawjv2 0;booms[i].oldx 0;booms[i].oldy 0;booms[i].timev3 0;booms[i].atking 0;booms[i].isboom 0;}// 敌人的炮弹爆炸int boomsumv2 100;int havev2 100;// 敌人发射的直线炮弹lineboom* boomsv2 new lineboom[boomsumv2];for (int i 0; i boomsumv2; i) {boomsv2[i].playeriv2 0;boomsv2[i].playerjv2 0;boomsv2[i].drawiv2 0;boomsv2[i].drawjv2 0;boomsv2[i].oldx 0;boomsv2[i].oldy 0;boomsv2[i].timev3 0;boomsv2[i].atking 0;boomsv2[i].isboom 0;}int pixnum;// 屏幕显示的方格个数int showi;int showj;
// 比屏幕多出的边距int side; // 可变边距测试成功// 一个缓冲区的大小int bkmeshmapmaxi;int bkmeshmapmaxj;int bkmeshwidth;int bkmeshheight;
// 一个游戏地图的大小int mapi;int mapj;// pixnum 30;
// pixnum 15; // mesh中一个网格正方形的边长
// pixnum 64; // mesh中一个网格正方形的边长
// pixnum 130; // mesh中一个网格正方形的边长pixnum 30; // mesh中一个网格正方形的边长
// pixnum 3; // mesh中一个网格正方形的边长int pixnumv2;
// 显示区的网格大小是沿用之前的pixnum但是自己设定也没问题于是产生新的变量
// 其实是测试pixnum对帧率影响结果发现是drawi j 影响大pixnumv2 30;// 30*100大小测试结果// 参数核显 41帧
// Renderer: Intel(R) Iris(R) Xe Graphics
// INFO: Version: 3.3.0 - Build 31.0.101.4502
// INFO: GLSL: 3.30 - Build 31.0.101.4502// RTX3060 57帧被遮挡47帧率
// Vendor: NVIDIA Corporation
// INFO: Renderer: NVIDIA GeForce RTX 3060 Laptop GPU/PCIe/SSE2
// INFO: Version: 3.3.0 NVIDIA 512.78
// INFO: GLSL: 3.30 NVIDIA via Cg compiler// showi 30;
// showj 30;
// showi 600;
// showj 600;
// showi 150;
// showj 150;
// showi 200;
// showj 200;
// showi 100; // 测试破案了单个瓦片刷新没有影响但是绘制Draw Texture 是主要限制100*100每个循环改pixnum不影响
// showj 100;
// showi 500; // 测试破案了单个瓦片刷新没有影响但是绘制Draw Texture 是主要限制100*100每个循环改pixnum不影响
// showj 500;
// showi 1500;
// showj 1500;
// showi 1000;
// showj 1000;
// showi 1100; // 1500*1500 1200*1200 超GPU显存了
// showj 1100;// 注意刷新规模上限70帧下最多每帧发送100*100的绘制小正方形瓦片密度是100*100/1000*1000 1/1001%的平均密度
// showi 1000; // 1000*1000*30*30 像素个数是界限了
// showj 1000;
// showi 100; // 1000*1000*30*30 像素个数是界限了
// showj 100;
// showi 30; // 1000*1000*30*30 像素个数是界限了
// showj 30;
// showi 1000; // 测试大地图碰撞检测
// showj 1000;showi 1001; // 测试大地图碰撞检测showj 1001;
// 150 50帧率 99%GPU 82°C
// 还是100
// showi 150;
// showj 150;
// showi 10; // 测试破案了单个瓦片刷新没有影响但是绘制Draw Texture 是主要限制100*100每个循环改pixnum不影响
// showj 10;
// showi 200; // 测试破案了单个瓦片刷新没有影响但是绘制Draw Texture 是主要限制100*100每个循环改pixnum不影响
// showj 200;
// 去除刷新检测可以100 持续57帧率
// side20;
// side showj*0.2;
// side 0;
// side 10; // 绘制四个角的红白矩形抖动原因是 后面的 if对draftx进行平移平移后采样区域回到靠左或靠右出现复位
// side 1;
// side 1; // while 边界检测1解决0导致的死循环允许side0
// side 1; // while 边界检测1解决0导致的死循环允许side0 改完由于偏移于是不准确了又拒绝了1于是不能设置为0保留窗口抖动
// side 10; // while 边界检测1解决0导致的死循环允许side0 改完由于偏移于是不准确了又拒绝了1于是不能设置为0保留窗口抖动,但是拒绝边界检测又测试允许0side 0;if (showi * showj 100 * 100) { // 如果超出GPU网格刷新界限就变成单宫格模式side 0;} else {side 1;}// while 边界检测1解决0导致的死循环允许side0 改完由于偏移于是不准确了又拒绝了1于是不能设置为0保留窗口抖动,但是拒绝边界检测又测试允许0
// 修正原来是由于绘制GPU画布采样界限多余部分会自动镜像绘制数组越界却没有发生
// 再解释破案了数组越界但是没闪退又有边界检测结果采样不会采样到出界部分。
// 于是增加边界检测// 边界处理bkmeshmapmaxi side showi side; // 象形表示左右各有这样的边距bkmeshmapmaxj side showj side;bkmeshwidth bkmeshmapmaxj * pixnum; // 用于瓦片刷新bkmeshheight bkmeshmapmaxi * pixnum;// mapi bkmeshmapmaxi * 20;
// mapj bkmeshmapmaxj * 20;//测试边界
// mapi bkmeshmapmaxi * 1;
// mapj bkmeshmapmaxj * 1;
// mapi bkmeshmapmaxi * 2;
// mapj bkmeshmapmaxj * 2;
// mapi bkmeshmapmaxi * 20;
// mapj bkmeshmapmaxj * 20;// 加上else 出现黑边BUG
// if (side 0) {
// mapi bkmeshmapmaxi * 1; // side0 则只有一个宫格
// mapj bkmeshmapmaxj * 1;
// } else {
// mapi bkmeshmapmaxi * 20;
// mapj bkmeshmapmaxj * 20;
// }if (side 0) {mapi bkmeshmapmaxi * 1; // side0 则只有一个宫格mapj bkmeshmapmaxj * 1;} else {mapi bkmeshmapmaxi * 5;mapj bkmeshmapmaxj * 5;}int **map;int **meshmap;int maxgamex; // 允许的最大位置int maxgamey;int** mapv2; // 解决敌人轨迹覆盖地图target* region; // 记录像素玩家所在区域在哪个敌人区域上用于减少比较性能优化region NULL;int regionflag 0; // 不在区域里// 回滚代码原因是采样区没法修改罢了
// maxgamey mapi * 30 - showi * 30; // 左上角拖拽距离游戏边界差一个背景采样区大小
// maxgamex mapj * 30 - showj * 30;maxgamey mapi * pixnum - showi * pixnum; // 左上角拖拽距离游戏边界差一个背景采样区大小maxgamex mapj * pixnum - showj * pixnum;// 但是发现可以修改粘贴的大小int showiv2; // 解决showij导致显示不全边距变化后检测限制的BUGint showjv2;
// showiv2 30;
// showjv2 30;showiv2 40;showjv2 60;// 记录bkmeshmap 网格,用于出界刷新int bkmeshmapi;int bkmeshmapj;bkmeshmapi 0;
// bkmeshmapi 0; // 解决黑边BUG 原来是复制粘贴初始化重复了导致没初始化对应在后面的参考点变化bkmeshmapj 0;// 拖拽边界int limitleft;int limittop;// 坐标系变化现在是在底部进行左下角是00原点limitleft 0;limittop 0;map new int*[mapi];for (int i 0; i mapi; i) {map[i] new int[mapj];}for (int i 0; i mapi; i) {for (int j 0; j mapj; j) {map[i][j] (j i) % 27; // 测试数据渐变 25改105 柔和}}// 测试边界for (int j 0; j mapj; j) {map[0][j] 9999;map[mapi - 1][j] 9999;}for (int i 0; i mapi; i) {map[i][0] 9999;map[i][mapj - 1] 9999;}meshmap new int*[bkmeshmapmaxi];for (int i 0; i bkmeshmapmaxi; i) {meshmap[i] new int[bkmeshmapmaxj];}for (int i 0; i bkmeshmapmaxi; i) {for (int j 0; j bkmeshmapmaxj; j) {meshmap[i][j] -1;}}mapv2 new int*[mapi];for (int i 0; i mapi; i) {mapv2[i] new int[mapj];}for (int i 0; i mapi; i) {for (int j 0; j mapj; j) {mapv2[i][j] map[i][j];}}// 目标个数int enemysum;
// enemysum20;
// enemysum100; // 100 个就闪退原来是敌人绘制网格出界这是在鼠标点击炮弹击中边界闪退得到的
// enemysum50;
// enemysum150;
// enemysum 50;
// enemysum 250;enemysum 50;// 随机数查的方法,_time64 获取时间srand设置随机数种子// 这俩都行保证每次开机都不一样
// SetRandomSeed((unsigned)_time64(NULL));srand((unsigned)_time64(NULL));// a rand();int enemylive;enemylive enemysum; // 存活敌人个数用于敌人死亡不立即刷新target* enemy new target[enemysum];for (int i 0; i enemysum; i) {enemy[i].islive 1;enemy[i].targeti GetRandomValue(0, mapi - 1);enemy[i].targetj GetRandomValue(0, mapj - 1);enemy[i].targetwidth GetRandomValue(10, 20);enemy[i].targetheight GetRandomValue(10, 20);// 敌人随机贴图// 在3. 测试Texture 之后发现需要在Initwindows 之后使用原因是上下文Opengl 还没设置
// enemy[i].picture new RenderTexture2D();
// enemy[i].picture LoadRenderTexture(enemy[i].targetwidth * pixnum, enemy[i].targetheight * pixnum);
// RenderTexture mesh LoadRenderTexture(enemy[i].targetwidth * pixnum, enemy[i].targetheight * pixnum);
// enemy[i].picture mesh;// enemy[i].picture LoadRenderTexture(enemy[i].targetwidth , enemy[i].targetheight );// BeginTextureMode(enemy[i].picture);
// for (int y 0; y enemy[i].targetheight * pixnum; y) {
// for (int x 0; x enemy[i].targetwidth * pixnum; x) {
// DrawPixel(x, y, {x%255, y%255, x * y%255, 255});
// }
// }
// EndTextureMode();// 记录采样数据用于恢复网格地图覆盖旧贴图enemy[i].oldmap new int*[100];for (int n 0; n 100; n) {enemy[i].oldmap[n] new int[100];}for (int n 0; n enemy[i].targetheight; n) {for (int m 0; m enemy[i].targetwidth; m) {
// enemy[i].oldmap[n][m] map[enemy[i].targeti - n][enemy[i].targetj m];// 追加边界检测解决闪退问题if (enemy[i].targeti - n 0 enemy[n].targeti - n mapi enemy[i].targetj m 0 enemy[i].targetj m mapj) {enemy[i].oldmap[n][m] map[enemy[i].targeti - n][enemy[i].targetj m];}}}// 记录局部区域像素网格enemy[i].mapv3 new int*[1000];for (int n 0; n 1000; n) {enemy[i].mapv3[n] new int[1000];}for (int n 0; n enemy[i].targetheight * pixnum; n) {for (int m 0; m enemy[i].targetwidth * pixnum; m) {
// enemy[i].mapv3[n][m] (m n) % 255;
// enemy[i].mapv3[n][m] (m n) % 250; // 254是白色用于绘制房间黑色覆盖时不覆盖白色enemy[i].mapv3[n][m] 0; // 254是白色用于绘制房间黑色覆盖时不覆盖白色}}// 生成入口enemy[i].area new target[100];int choose GetRandomValue(1, 4); //随机四个方向选一个方向
// int choose 4;enemy[i].area[0].targetwidth GetRandomValue(36, 50); // 先长宽enemy[i].area[0].targetheight GetRandomValue(30, 50);enemy[i].area[0].arealenth 0; // 设置距离很大if (choose 1) { // 东边最右边产生一个区域可以当成入口
// enemy[i].area[0].targetwidth GetRandomValue(6, 20); // 先长宽
// enemy[i].area[0].targetheight GetRandomValue(10, 20);enemy[i].area[0].targetj enemy[i].targetwidth * pixnum - enemy[i].area[0].targetwidth; // 再坐标防止越界enemy[i].area[0].targeti GetRandomValue(0, enemy[i].targetheight * pixnum - enemy[i].area[0].targetheight);} else if (choose 2) { // 北边上边
// enemy[i].area[0].targetj enemy[i].targetj;
// enemy[i].area[0].targeti enemy[i].targeti;enemy[i].area[0].targetj GetRandomValue(0, enemy[i].targetwidth * pixnum - enemy[i].area[0].targetwidth); // 再坐标防止越界enemy[i].area[0].targeti 0;} else if (choose 3) { // 西边enemy[i].area[0].targetj 0;enemy[i].area[0].targeti GetRandomValue(0, enemy[i].targetheight * pixnum - enemy[i].area[0].targetheight);} else if (choose 4) { // 南边enemy[i].area[0].targetj GetRandomValue(0, enemy[i].targetwidth * pixnum - enemy[i].area[0].targetwidth);enemy[i].area[0].targeti enemy[i].targetheight * pixnum - enemy[i].area[0].targetheight;}link** linkside new link*[110];for (int i 0; i 110; i) {linkside[i] new link[110];}for (int i 0; i 110; i) {for (int j 0; j 110; j) {linkside[i][j].used 1;}}for (int n 1; n 10; n) {enemy[i].area[n].targetwidth GetRandomValue(30, 50); // 先长宽enemy[i].area[n].targetheight GetRandomValue(30, 50);enemy[i].area[n].targetj GetRandomValue(0, enemy[i].targetwidth * pixnum - enemy[i].area[n].targetwidth);enemy[i].area[n].targeti GetRandomValue(0, enemy[i].targetheight * pixnum - enemy[i].area[n].targetheight);}// 生成出口int check 1;int minlenth 99999;int goal 0;choose GetRandomValue(1, 4); //随机四个方向选一个方向enemy[i].area[11].targetwidth GetRandomValue(30, 50); // 先长宽enemy[i].area[11].targetheight GetRandomValue(30, 50);if (choose 1) { // 东边最右边产生一个区域可以当成入口
// enemy[i].area[0].targetwidth GetRandomValue(6, 20); // 先长宽
// enemy[i].area[0].targetheight GetRandomValue(10, 20);enemy[i].area[11].targetj enemy[i].targetwidth * pixnum - enemy[i].area[11].targetwidth; // 再坐标防止越界enemy[i].area[11].targeti GetRandomValue(0, enemy[i].targetheight * pixnum - enemy[i].area[11].targetheight);} else if (choose 2) { // 北边上边
// enemy[i].area[0].targetj enemy[i].targetj;
// enemy[i].area[0].targeti enemy[i].targeti;enemy[i].area[11].targetj GetRandomValue(0, enemy[i].targetwidth * pixnum - enemy[i].area[11].targetwidth); // 再坐标防止越界enemy[i].area[11].targeti 0;} else if (choose 3) { // 西边enemy[i].area[11].targetj 0;enemy[i].area[11].targeti GetRandomValue(0, enemy[i].targetheight * pixnum - enemy[i].area[11].targetheight);} else if (choose 4) { // 南边enemy[i].area[11].targetj GetRandomValue(0, enemy[i].targetwidth * pixnum - enemy[i].area[11].targetwidth);enemy[i].area[11].targeti enemy[i].targetheight * pixnum - enemy[i].area[11].targetheight;}// 增加数据for (int n 0; n 11; n) {for (int m 0; m 11; m) {int startx enemy[i].area[n].targetj;int starty enemy[i].area[n].targeti;int endx enemy[i].area[m].targetj;int endy enemy[i].area[m].targeti;linkside[n][m].startx enemy[i].area[n].targetj;linkside[n][m].starty enemy[i].area[n].targeti;linkside[n][m].endx enemy[i].area[m].targetj;linkside[n][m].endy enemy[i].area[m].targeti;linkside[n][m].used 0;if (n m) {linkside[n][m].used 1;
// linkside[n][m].lenth999999;
// linkside[n][m].edgelink.weight999999;} else {linkside[n][m].lenth sqrt((startx - endx) * (startx - endx) (starty - endy) * (starty - endy));}// printf(%d\n,linkside[n][m].lenth);}
// printf(%d %d\n,linkside[n][0].startx,linkside[n][0].starty);}// for (int n 0; n 11; n) {
// int goal 2;
// int lenth 999999;
//
// // 找当前最小边
// for (int m 0; m 11; m) {
// if (linkside[n][m].used 1) {
//
// } else {
// if (linkside[n][m].lenth lenth) {
// lenth linkside[n][m].lenth;
// goal m;
// }
// }
// }
//
// // 连线
// for (int m 0; m 10; m) {
// drawline(linkside[n][goal].starty m, linkside[n][goal].startx, linkside[n][goal].endy m, linkside[n][goal].endx, enemy[i].mapv3, 254, enemy[i].targetheight * pixnum, enemy[i].targetwidth * pixnum);
// drawline(linkside[n][goal].starty, linkside[n][goal].startx m, linkside[n][goal].endy, linkside[n][goal].endx m, enemy[i].mapv3, 254, enemy[i].targetheight * pixnum, enemy[i].targetwidth * pixnum);drawline(0,0, 550,550,enemy[i].mapv3, 254, enemy[i].targetheight*pixnum, enemy[i].targetwidth*pixnum);
//
// }
// linkside[n][goal].used 1; // 连完的线linkside[goal][n].used 1;
// }// link linkside[12][12]; // 兼容之前参数int vex 12; //顶点个数int edgeside 12 * 12; //边个数link graph[MAX_EDGE];edge graphv2[MAX_EDGE];/*// for (int k 0; k edgeside; k) {// for (int n 0; n 11; n) {// for (int m 0; m 11; m) {// if (linkside[n][m].used 0) {// graph[k].startx linkside[n][m].startx;// graph[k].starty linkside[n][m].starty;// graph[k].endx linkside[n][m].endx;// graph[k].endy linkside[n][m].endy;// graph[k].lenth linkside[n][m].lenth;// graph[k].used 1;//// graphv2[k].startpointn;// graphv2[k].endpointm;// graph[k].lenthlinkside[n][m].lenth;// }// }// }// }*/for (int n 0; n 144; n) {graph[n].used 0;}
//int k 0;for (int n 0; n 11; n) {for (int m 0; m 11; m) {if (linkside[n][m].used 0) {graph[k].startx linkside[n][m].startx;graph[k].starty linkside[n][m].starty;graph[k].endx linkside[n][m].endx;graph[k].endy linkside[n][m].endy;graph[k].lenth linkside[n][m].lenth;graph[k].used 1;graph[k].edgelink.startpoint n;graph[k].edgelink.endpoint m;graph[k].edgelink.weight linkside[n][m].lenth;k;}}}// 标记不用数据for (int n 0; n MAX_EDGE; n) {if (graph[n].used 0) {graph[n].lenth 999999;graph[n].edgelink.weight 999999;}}// 插入排序link max;int index;for (int n 0; n MAX_EDGE; n) {index n;max graph[n];for (int m n 1; m MAX_EDGE; m) {if (graph[m].lenth max.lenth) {max graph[m];index m;}}graph[index] graph[n];graph[n] max;}int roots[MAX_VEX]; //根数组存放各顶点的根节点以区别是否属于同一个集合edge MST[MAX_EDGE]; //存放最小生成树minimum spanning treeint count 0;for (int n 0; n MAX_VEX; n) {roots[n] -1;}for (int n 0; n MAX_EDGE; n) {if (graph[n].used 1) {int vex_m find_root(roots, graph[n].edgelink.startpoint);int vex_n find_root(roots, graph[n].edgelink.endpoint);if (vex_m ! vex_n) { //如果两者的根节点不同说明他们属于不同的集合可以相连MST[count] graph[n].edgelink;//将此边放入MST数组count;roots[vex_m] vex_n; //将两个树合并即将顶点vex_n作为vex_m的根节点}if (count vex - 1) {break;}}}for (int k 0; k vex - 1; k) {
// printf((%d,%d)%d\n, MST[k].startpoint, MST[k].endpoint, MST[k].weight); //打印最小生成树int start MST[k].startpoint;int end MST[k].endpoint;for (int n 0; n 10; n) {drawline(linkside[start][end].startyn,linkside[start][end].startx,linkside[start][end].endyn,linkside[start][end].endx, enemy[i].mapv3, 254, enemy[i].targetheight*pixnum, enemy[i].targetwidth*pixnum);drawline(linkside[start][end].starty,linkside[start][end].startxn,linkside[start][end].endy,linkside[start][end].endxn, enemy[i].mapv3, 254, enemy[i].targetheight*pixnum, enemy[i].targetwidth*pixnum);}}// 绘制区域// 注意是等于11第十二个for (int n 0; n 11; n) {for (int x 0; x enemy[i].area[n].targetwidth; x) {for (int y 0; y enemy[i].area[n].targetheight; y) {
// 0 漏掉等号导致最顶上像素没覆盖以为是数组对应错位if (0 enemy[i].area[n].targeti y enemy[i].area[n].targeti y enemy[i].targetheight * pixnum 0 enemy[i].area[n].targetj x enemy[i].area[n].targetj x enemy[i].targetwidth * pixnum) {enemy[i].mapv3[enemy[i].area[n].targeti y][enemy[i].area[n].targetj x] 254;}}}}}// 随便一个敌人记录为所在地区只是为了不让region为空减少比较region enemy[0];// enemy[0].picture LoadRenderTexture(50,50);// 绘制敌人for (int n 0; n enemysum; n) {for (int i 0; i enemy[n].targetheight; i) {for (int j 0; j enemy[n].targetwidth; j) {// 发现是没有越界检测所以导致100 个时碰到边界闪退if (enemy[n].targeti - i 0 || enemy[n].targeti - i mapi || enemy[n].targetj j 0 || enemy[n].targetj j mapj) {break;} else {map[enemy[n].targeti - i][enemy[n].targetj j] 1;}}}}// 初始化窗口
// InitWindow(1750, 1050, test for location);
// InitWindow(300showiv2*pixnumv2, 300showjv2*pixnumv2, test for location);InitWindow(showjv2 * pixnumv2, showiv2 * pixnumv2, test for location);
// 设置GPU可以操作的画布,一定要再初始化窗口之后才行实际上是OpenGL的上下文或者说默认环境设置RenderTexture2D mesh LoadRenderTexture(bkmeshmapmaxi * pixnum, bkmeshmapmaxj * pixnum);// 这俩可以追加敌人贴图for (int n 0; n enemysum; n) {enemy[n].picture LoadRenderTexture(enemy[n].targetwidth * pixnum, enemy[n].targetheight * pixnum);BeginTextureMode(enemy[n].picture);for (int y 0; y enemy[n].targetheight * pixnum; y) {for (int x 0; x enemy[n].targetwidth * pixnum; x) {
// DrawPixel(x, y, {x % 255, y % 255, x * y % 255, 255});// 数组增加后是从下往上绘制从下往上打印数组对应从0到999
// DrawPixel(x, y, {enemy[n].mapv3[y][x], enemy[n].mapv3[y][x], enemy[n].mapv3[y][x], 255});// 重新测试边界,查坐标系看数组和像素是否对应if (enemy[n].mapv3[y][x] 254) {DrawPixel(x, y, {enemy[n].mapv3[y][x], enemy[n].mapv3[y][x], enemy[n].mapv3[y][x], 255});} else if (y 0) {DrawPixel(x, y, {0, 255, 255, 255});} else {DrawPixel(x, y, {enemy[n].mapv3[y][x], enemy[n].mapv3[y][x], enemy[n].mapv3[y][x], 255});}}}EndTextureMode();}// 设置缩放过滤器模式// 查找raylib.h得到
// SetTextureFilter(mesh.texture,TEXTURE_FILTER_ANISOTROPIC_16X); // 缩小帧率会下降到50// 这两个带明暗了
// GenTextureMipmaps(mesh.texture); //为Texture生成GPU mipmap
// https://www.cnblogs.com/wuyuan2011woaini/p/15655883.html
// SetTextureFilter(mesh.texture,TEXTURE_FILTER_TRILINEAR); // 线性滤波// GenTextureMipmaps(mesh.texture); //为Texture生成GPU mipmap
// 各向异性过滤
// SetTextureFilter(mesh.texture,TEXTURE_FILTER_ANISOTROPIC_16X);// https://www.cnblogs.com/wuyuan2011woaini/p/15655883.html
// SetTextureFilter(mesh.texture,TEXTURE_FILTER_TRILINEAR); // 单独一行没有mipmap就不是缩小变暗
// SetTextureFilter(mesh.texture,TEXTURE_FILTER_POINT); // 无滤波
// SetTextureFilter(mesh.texture, TEXTURE_FILTER_BILINEAR); // 线性滤波SetTextureFilter(mesh.texture, TEXTURE_FILTER_POINT); // 无滤波// 如果渲染器超出原始边界范围则会复制边缘颜色对超出范围的区域进行着色
// SetTextureWrap(mesh.texture,TEXTURE_WRAP_CLAMP); // 这个相对于出界拉伸
// SetTextureWrap(mesh.texture,TEXTURE_WRAP_REPEAT); // 这个是默认的也就是没有这一行命令也和之前一样
// SetTextureWrap(mesh.texture,TEXTURE_WRAP_MIRROR_REPEAT); // 这个是镜像出界
// SetTextureWrap(mesh.texture,TEXTURE_WRAP_MIRROR_CLAMP); // 这个是镜像出界边线拉伸SetTextureWrap(mesh.texture, TEXTURE_WRAP_REPEAT);// SetTextureFilter(Texture2D texture, int 过滤器); //设置Texture缩放过滤器模式// 设置帧率
// SetTargetFPS(160); // 低帧率四角的矩形会平滑移动效果
// 100*30全面刷新帧率60
// 100*15全面刷新帧率SetTargetFPS(70);
// 设置默认绘制到meshBeginTextureMode(mesh);
// ******
// 取消绘制的GPU画布EndTextureMode();
// 设置默认绘制到桌面BeginDrawing();
// 黑色覆盖全部屏幕ClearBackground(BLACK);DrawTexturePro(mesh.texture, {0, 0, 750, 750}, {0, 0, 750, 750}, {0, 0}, 0, WHITE);
// 结束绘制的桌面EndDrawing();// 绘制粘贴自8.测试DrawTexture 与11.备份 10测试int drawx;int drawy;int mousex;int mousey;int drawi;int drawj;mousex 0;mousey 0;drawx 0;drawy 0;drawi 0;drawj 0;// 拖拽int draftflag;int draftx;int drafty;int gamex;int gamey;
// 记录长按时鼠标按下去的位置减出长按拖拽距离int oldx;int oldy;draftflag 0;draftx 0;drafty 0;
// draftxbkmeshwidth*pixnum/2;
// draftybkmeshheight*pixnum/2;gamex 0;gamey 0;// 滚轮放大缩小float camerasize;camerasize 1.0f;int zoom;int time;zoom 0;//记录滚轮次数滚动快放缩快int cnt 0;// 测试碰撞目标int mousewidth 10;
// int mouseheight 0;int mouseheight 3;int targetheight 45;int targetwidth 25;int targeti mapi - 10;
// int targetj 10;int targetj 20;int ax; // 加速度解决松开就停而产生的变量延长运动时期和按键时期不同int ay;
// ax0;
// ay0;ax 0;ay 0;int speedx; // 玩家速度int speedy;speedx 0;speedy 0;int playeri; // 玩家位置int playerj;int playerx;int playery;playery mapi * pixnum / 2;playerx mapj * pixnum / 2;// playeri mapi - 1; // 左上角
// playerj 0;playeri mapi / 2;playerj mapj / 2;int oldplayeri; // 恢复原状int oldplayerj;oldplayeri playeri;oldplayerj playerj;int cntv2; // 原来的一个cnt被摄像机使用了int timev2; // time 也被摄像机滚轮放大zoom限制使用了cntv2 0;timev2 0;float k 0.0f;// int timev3;
// timev3 0;// int atking; // 记录是否直线攻击
// atking 0; // 不攻击记录为0// 这里开始主循环while (!WindowShouldClose()) {// 按键后增加速度if (IsKeyDown(KEY_A)) {ax -1;}if (IsKeyDown(KEY_D)) {ax 1;}if (IsKeyDown(KEY_W)) {ay 1;}if (IsKeyDown(KEY_S)) {ay -1;}// 键盘松开加速度消失// 四个 if 合并成两个if (IsKeyUp(KEY_A) IsKeyUp(KEY_D)) {ax 0;speedx 0;}if (IsKeyUp(KEY_W) IsKeyUp(KEY_S)) {ay 0;speedy 0;}// 加速度限制if (ax 1) {ax 1;} else if (ax -1) {ax -1;}if (ay 1) {ay 1;} else if (ay -1) {ay -1;}speedy ay;speedx ax;// 速度限制if (speedx 1) {speedx 1;} else if (speedx -1) {speedx -1;}if (speedy 1) {speedy 1;} else if (speedy -1) {speedy -1;}// playerjspeedx 解决复制粘贴 改名不全的导致的 playerj -speedx// 但是只修改网格不是像素绘制上去瓦片贴图是一直刷新的// 禁用红色矩形移动// 不禁用检测贴图移动if (0 playeri speedy playeri speedy mapi 0 playerj speedx playerj speedx mapj) {playeri speedy; // 因为往下是减少速度增加速度往下是正的变成负的是每帧的距离playerj speedx;// map[oldplayeri][oldplayerj] 224;mapv2[oldplayeri][oldplayerj] 224;map[playeri][playerj] 2024;oldplayeri playeri;oldplayerj playerj;}// 红色像素移动if (0 playery speedy playery speedy mapi * 30 0 playerx speedx playerx speedx mapj * 30) {playerx playerx speedx;playery playery speedy;
// BeginTextureMode(mesh);
// DrawPixel(playerx,playery,{255,0,0,255});
// EndTextureMode();}// 如果玩家在区域里if (region ! NULL) {if (playerx region-targetj * pixnum playerx (region-targetj region-targetwidth)*pixnum // 注意坐标系y向下数值会减小所以是小于等于是测试得到的原来的BUG是移动一格任何出现轨迹// 1是发现高度差一行// 原来是1到了上一格子。target是网格坐标mapi是最顶上所以1是往上平移一格因为绘制是GPU左下角绘制所以是网格的左下角所以需要更上一格的左下角。// 是小于上一格子的左下角大于等于最底下一格子的左下角playery (region-targeti 1) * pixnum // 没有发现漏打region-targethieghtplayery (region-targeti 1 - region-targetheight)*pixnum) {regionflag 1;} else {int n 0;for (n 0; n enemysum; n) {if (playerx enemy[n].targetj * pixnum playerx (enemy[n].targetj enemy[n].targetwidth)*pixnum playery (enemy[n].targeti 1) * pixnum playery (enemy[n].targeti 1 - enemy[n].targetheight)*pixnum) {region enemy[n];break;}}// 全部看一遍发现没有重叠的if (n enemysum) {regionflag 0;}}}// 把之前绘制像素碰撞检测分离到数据处理部分if (regionflag 1) {if (region-mapv3[-1 (region-targetheight) * pixnum - ( playery - (region-targeti - region-targetheight 1) * pixnum )][playerx - region-targetj * pixnum] 0) {playerx - speedx;playery - speedy;}}// 解决缩小放大绘制时出现的绘制情况原因是旧位置放大倍数给了新数据现在是新放大倍数给当前数据
// 版本7继续版本5的调参数if (GetMouseWheelMove() 0) {zoom -1;cnt;} else if (GetMouseWheelMove() 0) {zoom 1;cnt--;}
// 30改10配合0.99改0.95增加灵敏度
// 10改5配合0.95改0.97增加减少放大差距提高鼠标滚动延长效果
// 5改5配合0.97改0.98增加减少放大差距提高鼠标滚动延长效果
// 5改5配合0.98改0.981复位1.00001解决无法复位回不到1问题
// 5改5配合0.981改0.9811复位1.00000解决无法复位回不到1问题
// 5改5配合0.981改0.99复位1.00000解决到0.01再返回无法复位回不到1.0问题// 0.99改成0.98在4.版本后if (cnt ! 0 time 5) {
// 改30参数影响放缩时间time;if (zoom 0) {
// 加法改乘法放大感觉平均没有了越小再缩小一次缩小明显更小的追加情况原因是数值小了追加固定数据倍数影响大camerasize camerasize * 0.97;
// 改0.99缩小参数影响每次循环缩小倍数一次缩小的突然更小程度if (camerasize 0.01) {camerasize 0.01;}} else if (zoom 0) {camerasize camerasize / 0.97;if (camerasize 40) {camerasize 40;}}
// 解决复位之后重复写0问题} else if (time ! 0) {time 0;
// zoom 0;
// 多次滚轮则延长摄像机缩放if (cnt 0) {cnt;}if (cnt 0) {cnt--;}
// 消耗完累计次数停止滚动if (cnt 0) {zoom 0;}}// 注意是pressed 不是 Downif (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT)) {draftflag 1;oldx GetMouseX();oldy GetMouseY();}if (draftflag 1) {mousex GetMouseX();mousey GetMouseY();draftx gamex - (mousex - oldx) / camerasize;drafty gamey - (mousey - oldy) / camerasize;}if (IsMouseButtonUp(MOUSE_BUTTON_RIGHT)) {draftflag 0;oldx 0;oldy 0;gamex draftx;gamey drafty;}// 完成角色切换控制缩小倍数锁定玩家不能拖拽// 记录旧数据,缩小还原static int olddraftx;static int olddrafty;static int recoverflag 0; // 摄像机回到原来位置的控制信号原来是靠camerasize if 不够用static int followflag 0; // 追随
// olddraftx draftx;
// olddrafty drafty;// 在确定网格左上角坐标之前覆盖玩家追随数据// 追加追随在放大倍数一定后数据覆盖屏蔽旧拖拽if (camerasize 1) {
// draftx playerx bkmeshwidth / 2 - showjv2 * pixnumv2 / camerasize;
// drafty playery bkmeshheight / 2 - showiv2 * pixnumv2 / camerasize;
// gamexplayerx;
// gameyplayery;// DrawTexturePro(mesh.texture, {(draftx - limitleft ) bkmeshwidth / 2 - showjv2*pixnumv2 / 2 / camerasize,
// (drafty - limittop bkmeshheight / 2) - showiv2*pixnumv2 / 2 / camerasize,
// showjv2*pixnumv2 / camerasize, showiv2*pixnumv2 / camerasize},
// {0, 0, showjv2 * pixnumv2, showiv2 * pixnumv2}, {0, 0}, 0, WHITE);// 采样中心 是玩家 draftx bkmeshwidth / 2 - showjv2*pixnumv2 / 2 / camerasize playerx// 根据旧的记录可知数据draftx 是一开始的左上角区域坐标draftxbkmeshwidth/2是中心 这是延续当时开发先产生的结论,本质是一开始draftx 是0 但是playerx是mapi*pixnum/2
// draftx playerx - bkmeshwidth / 2;
// drafty ( mapi*pixnum-playery) - bkmeshheight / 2;if (followflag 0) {olddraftx draftx;olddrafty drafty;followflag 1;}// 根据旧的记录可知数据draftx 是一开始的左上角区域坐标draftxbkmeshwidth/2是中心 这是延续当时开发先产生的结论,本质是一开始draftx 是0 但是playerx是mapi*pixnum/2draftx playerx - bkmeshwidth / 2;drafty ( mapi * pixnum - playery) - bkmeshheight / 2;followflag 1;recoverflag 1; // 记录覆盖数据已更新} else {followflag 0;}// 第一次切换if (followflag 0 recoverflag 1) {draftx olddraftx;drafty olddrafty;recoverflag 0;}if (side ! 0) {// 新增边界检测if (draftx 0) {draftx 0;} else if (draftx maxgamex ) { // 配合limitleft60 可以看见边界白边draftx maxgamex;}
//打表发现左上角出界刷新实际比较矩形限制在很小的区域 60*60原来的表示则是750*750大小的区域
// 00不会执行不能等于否则出界
// if 又改wihle 解决拖拽时出现绘制点原因是旧坐标没来得及更新
// 1解决side0时去除采样复位导致的抖动避免死循环
// 但是导致偏移鼠标尖点击不准确于是回滚代码去除1while (draftx limitleft ) {
// limitleft - side * pixnum1; // side*pixnum 替换 pixnum 但是 limitleft 不变化limitleft - side * pixnum; // side*pixnum 替换 pixnum 但是 limitleft 不变化}while (draftx limitleft 2 * side * pixnum) { //60 改 30 又改 60 左上角移动两个边距就是2*30
// limitleft side * pixnum1;limitleft side * pixnum;}
// 新增边界检测if (drafty 0) {drafty 0;} else if (drafty maxgamey) {drafty maxgamey;}while (drafty limittop ) {
// limittop - side * pixnum1;limittop - side * pixnum;}while (drafty limittop 2 * side * pixnum) { // 60 改 30 又改 60见到底部白边
// limittop side * pixnum1;limittop side * pixnum;}bkmeshmapj limitleft / pixnum; // 关键在只要保证draftxlimitleft 2 * side * pixnum,边界就不会出来刚好靠边数组打印
// bkmeshmapi mapi - 1 - bkmeshmapmaxi - limittop / pixnum; // 269 -27 -0 27 -i 269 -i 269 -0 269 数组最后一个bkmeshmapi mapi - bkmeshmapmaxi - limittop / pixnum; // 270 -27 -0 27 -i 270 -i 270 -1 269 数组最后一个}// // 追加追随在放大倍数一定后数据覆盖屏蔽旧拖拽
// if (camerasize 0.1) {
// draftx playerx bkmeshwidth / 2 - showjv2 * pixnumv2 / camerasize;
// drafty playery bkmeshheight / 2 - showiv2 * pixnumv2 / camerasize;gamexplayerx;gameyplayery;
//DrawTexturePro(mesh.texture, {(draftx - limitleft ) bkmeshwidth / 2 - showjv2*pixnumv2 / 2 / camerasize,(drafty - limittop bkmeshheight / 2) - showiv2*pixnumv2 / 2 / camerasize,showjv2*pixnumv2 / camerasize, showiv2*pixnumv2 / camerasize},{0, 0, showjv2 * pixnumv2, showiv2 * pixnumv2}, {0, 0}, 0, WHITE);
//
// }// 改变顺序计算完偏移再算绘制解决用上一次偏移坐标组合这一处偏移绘制if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
// drawx GetMousePosition().x;
// 无中生有坐标系变化过程
// 750,实际穷举描述得到在点一下在鼠标坐标系是0100靠顶边
// 在GPU坐标系里0100则是靠底边100像素
// 然后实际上是直接取反然后加上高度上限发现原来可以
// 最后重整旧测试代码实现
// drawy 750 - GetMousePosition().y;
// drawy 751 - GetMousePosition().y;
// if (drawx 0 || drawx 750 || drawy 0 || drawy 750)
// 发现可以直接写标注数据变化于是重新命名变量mousex GetMousePosition().x;mousey GetMousePosition().y;
// 测试之后追加等号发现等号设置在0处解决问题750-0750750/3025数组出界750-1749749/3024
// 可知减的多不出界剩下的少于是就不出界
// if (mousex 0 || mousex showiv2 * pixnum || mousey 0 || mousey showiv2 * pixnum) {
// side0 时进行检测节约性能if (mousex 0 || mousex showjv2 * pixnumv2 || mousey 0 || mousey showiv2 * pixnumv2) {} else {
// int positionx 0 draftx/ camerasize;
// int positionx 0 draftx showjv2 * pixnum / 2 - showjv2 * pixnum / 2 / camerasize;
// 解决采样中心是mesh中心后绘制偏移也修改
// int positionx 0 draftx bkmeshwidth / 2 - showjv2 * pixnum / 2 / camerasize;int positionx 0 draftx bkmeshwidth / 2 - showjv2 * pixnumv2 / 2 / camerasize;
// int positiony 0 drafty / camerasize;
// int positiony 0 drafty showiv2 * pixnum / 2 - showiv2 * pixnum / 2 / camerasize;
// int positiony 0 drafty bkmeshheight / 2 - showiv2 * pixnum / 2 / camerasize;int positiony 0 drafty bkmeshheight / 2 - showiv2 * pixnumv2 / 2 / camerasize;
// 相对于左下角位置水平方向就是当前左下角距离加鼠标横着距离左边界drawx mousex / camerasize positionx; // 乘camerasize不行测试除法发现也不行,换测试位置
// 回滚测试发现x 除法可以在水平移动多少对应绘制多少
// 竖直方向可以理解成先算距离左下角距离然后再加上左下角实际对应的地图点
// 缩小后750变化可以理解成坐标上限增加原来坐标系变化需要750-现在变成1500- 对应两倍坐标系变化drawy mousey / camerasize positiony; // 750/camerasize
// 测试750/camerasize,发现偏移随放大倍数增加改成乘camerasize 发现刚好适配drawj drawx / pixnum;drawi (mapi * pixnum - drawy) / pixnum;
// 出界闪退BUG解决方案drawj没有问题受到边界限制 maxgamex// 但是由于side 0 时会禁用之前的拖拽检测于是丢失了上面的限制所以还是得增加 j x 方向的越界检测if (drawi mapi || drawi 0 || drawj 0 || drawj mapj) {} else {
// for (int j 0; j 10; j) {
// map[drawi][drawj j] 1949;
// }for (int i 0; i mouseheight; i) {for (int j 0; j mousewidth; j) {if (drawi - i 0 drawi - i mapi) {if (drawj j 0 drawj j mapj) {map[drawi - i][drawj j] 1949;} else {break;}} else {break;}}}// atking 1;// 找到一个没有运行的炮弹并启动for (int i 0; i boomsum; i) {// 发现没有运行if (booms[i].atking 0) {
// 启动运行booms[i].atking 1;// 开始运行时间重置为0booms[i].timev3 0;// 记录位置可描述为起点实际是记录所在直线booms[i].playerjv2 playerj;booms[i].playeriv2 playeri;
// 终点booms[i].drawiv2 drawi;booms[i].drawjv2 drawj;// 记录覆盖点重置为0避免旧数据覆盖到其他地方booms[i].oldx 0;booms[i].oldy 0;// 炮弹数目have--;break;}}}}}// 恢复旧贴图数据for (int n 0; n enemysum; n) {for (int i 0; i enemy[n].targetheight; i) {for (int j 0; j enemy[n].targetwidth; j) {
// map[enemy[n].targeti - i][enemy[n].targetj j] enemy[n].oldmap[i][j];// 追加边界检测解决闪退问题if (enemy[n].targeti - i 0 enemy[n].targeti - i mapi enemy[n].targetj j 0 enemy[n].targetj j mapj) {map[enemy[n].targeti - i][enemy[n].targetj j] enemy[n].oldmap[i][j];}}}}// lineatk(booms, boomsum, map);
// lineatk(booms, boomsum, mapv2);lineatk(booms, boomsum, map); // 敌人map重新替换mapv2 ,实现局部刷新// for (int n 0; n boomsum; n) {checkboom(booms[n], enemy, map, enemysum, mapi, mapj);
// checkboom(booms[n], enemy, mapv2, enemysum, mapi, mapj);
// }checkend(booms, boomsum, have, map, mapi, mapj);
// checkend(booms, boomsum, have, mapv2, mapi, mapj);// 敌人伏击检测for (int n 0; n enemysum; n) {int bangi;int bangj;int bangwidth;int bangheight;if (bang(playeri, playerj, 10, 10, enemy[n].targeti 50, enemy[n].targetj - 50, enemy[n].targetwidth 50 50, enemy[n].targetheight 50 50, bangi, bangj, bangwidth, bangheight)) {for (int m 0; m boomsumv2; m) {if (boomsv2[m].atking 0) {boomsv2[m].atking 1;boomsv2[m].playerjv2 enemy[n].targetj;boomsv2[m].playeriv2 enemy[n].targeti;boomsv2[m].drawiv2 playeri;boomsv2[m].drawjv2 playerj;boomsv2[m].timev3 0;havev2--;break;}}}}// 敌人的炮弹移动
// lineatk(boomsv2, 100, map);
// lineatk(boomsv2, 100, mapv2);lineatk(boomsv2, 100, map);// 炮弹命中检测for (int n 0; n 100; n) {int bangi;int bangj;int bangwidth;int bangheight;if (boomsv2[n].atking 1) {if (bang(playeri, playerj, 10, 10, boomsv2[n].oldy - 10 / 2, boomsv2[n].oldx - 10 / 2, 10, 10, bangi, bangj, bangwidth, bangheight)) {boomsv2[n].isboom 1;}}}// checkend(boomsv2, boomsumv2, havev2, map, mapi, mapj);
// checkend(boomsv2, boomsumv2, havev2, mapv2, mapi, mapj);checkend(boomsv2, boomsumv2, havev2, map, mapi, mapj);// 敌人移动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;}}}// 敌人绘制但是帧率低没有复制粘贴过来的跑到帧率高
// for (int n 0; n 100; n) {
// if (enemy[n].islive) {
// for (int i 0; i enemy[n].targetheight; i) {
// for (int j 0; j enemy[n].targetwidth; j) {
// map[enemy[n].targeti - i][enemy[n].targetj j] 7788;
// }
// }
// }
// }// 重新采样数据要在炮弹发射之后这样不会覆盖炮弹轨迹敌人移动之后重新采样for (int n 0; n enemysum; n) {for (int i 0; i enemy[n].targetheight; i) {for (int j 0; j enemy[n].targetwidth; j) {
// enemy[n].oldmap[i][j] map[enemy[n].targeti - i][enemy[n].targetj j];// 追加边界检测解决闪退问题if (enemy[n].targeti - i 0 enemy[n].targeti - i mapi enemy[n].targetj j 0 enemy[n].targetj j mapj) {enemy[n].oldmap[i][j] map[enemy[n].targeti - i][enemy[n].targetj j];}}}}// 绘制敌人for (int n 0; n enemysum; n) {for (int i 0; i enemy[n].targetheight; i) {for (int j 0; j enemy[n].targetwidth; j) {// 发现是没有越界检测所以导致100 个时碰到边界闪退if (enemy[n].targeti - i 0 || enemy[n].targeti - i mapi || enemy[n].targetj j 0 || enemy[n].targetj j mapj) {break;} else {
// map[enemy[n].targeti - i][enemy[n].targetj j] 1;
// mapv2[enemy[n].targeti - i][enemy[n].targetj j] 1;// 之前覆盖原来是重新绘制时有的颜色所在网格序号相同导致不会重绘留下贴图// 已经使用另一个序号覆盖和之前的map 序号不同总是会重新绘制map[enemy[n].targeti - i][enemy[n].targetj j] 2024;}}}}// 敌人复活检测// 发现每次复活都会有残留贴图原来是复活后先贴图玩家再移动于是没有覆盖第一次贴图可知复活在贴图之后
// enemylive 0;
// for (int n 0; n enemysum; n) {
// if (enemy[n].islive 1) {
// enemylive;
// }
// }
//
//
// if (enemylive 5) {
// for (int n 0; n 5; n) {
// if (enemy[n].islive 0) {
// enemy[n].islive 1;
// enemy[n].targeti GetRandomValue(0, mapi - 1);
// enemy[n].targetj GetRandomValue(0, mapj - 1);
// enemy[n].targetwidth GetRandomValue(10, 20);
// enemy[n].targetheight GetRandomValue(10, 20);
// enemylive;
//
// // 敌人复活对应贴图重新设置大小
// enemy[n].picture.texture.width enemy[n].targetwidth * pixnum;
// enemy[n].picture.texture.height enemy[n].targetheight * pixnum;
// }
// }
// }for (int n 0; n boomsum; n) {// 只检测正在运行的炮弹if (booms[n].atking 1) {checkboom(booms[n], enemy, map, enemysum, mapi, mapj);}// checkboom(booms[n], enemy, mapv2, enemysum, mapi, mapj);}
// checkend(booms, boomsum, have, map, mapi, mapj);
// checkend(booms, boomsum, have, mapv2, mapi, mapj);checkend(booms, boomsum, have, map, mapi, mapj); // 重新启用map,敌人重绘贴图替换mapv2//碰撞加局部显示// 两两排列组合-四宫格 左边端点在区间里左边端点不在区间里右边端点在区间里右边端点不在区间里static int bangi 0;static int bangj 0;static int bangwidth 40;static int bangheight 30;int isbang bang(drawi, drawj, mousewidth, mouseheight, targeti, targetj, targetwidth, targetheight, bangi, bangj, bangwidth, bangheight);if (isbang) {for (int i 0; i bangheight; i--) {for (int j 0; j bangwidth; j) {map[bangi i][bangj j] 2024;}}}// 把玩家绘制到敌人贴图里面if (regionflag 1) {BeginTextureMode(region-picture);// 高度-距离左下角位置因为playex是往下时数值增加减去的多则越靠近GPU画布的左下角// 1是一格网格测试出现的。-1是像素偏移
// DrawPixel(playerx - region-targetj * pixnum, -1(region-targetheight) * pixnum - ( playery - (region-targeti - region-targetheight1) * pixnum ), {255, 0, 0, 255});// DrawPixel(playerx - region-targetj * pixnum, -1 (region-targetheight) * pixnum - ( playery - (region-targeti - region-targetheight 1) * pixnum ), {255, 0, 0, 255});// 增加区域碰撞,如果遇到就恢复原状模拟像素碰撞
// if (region-mapv3[-1 (region-targetheight) * pixnum - ( playery - (region-targeti - region-targetheight 1) * pixnum )][playerx - region-targetj * pixnum] 0) {
// playerx - speedx;
// playery - speedy;
// } else {
// DrawPixel(playerx - region-targetj * pixnum, -1 (region-targetheight) * pixnum - ( playery - (region-targeti - region-targetheight 1) * pixnum ), {255, 0, 0, 255});
// }DrawPixel(playerx - region-targetj * pixnum, -1 (region-targetheight) * pixnum - ( playery - (region-targeti - region-targetheight 1) * pixnum ), {255, 0, 0, 255});EndTextureMode();}// 设置默认绘制到meshBeginTextureMode(mesh);// DrawPixel(playerx, playery, {255, 0, 0, 255});// 改成了1并且最后是等于号因为等于时对应数组00格子其实是绘制时发现对不上号和更新总是偏下for (int i 1; i bkmeshmapmaxi; i) {if (bkmeshmapmaxi - i bkmeshmapi 0) {break;}for (int j 0; j bkmeshmapmaxj; j) {if (j bkmeshmapj mapj) { // 如果出界就取消绘制break;}// 增加side 是0 为单宫格检测才进行比较检测选择刷新小片网格if (side 0 meshmap[bkmeshmapmaxi - i ][j] map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj]) {} else {meshmap[bkmeshmapmaxi - i ][j] map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj];// 绘制矩形,原点(0,0)在左下角,现在是从左下角一行一行往上绘制if (map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] 9999) {
// DrawRectangle(j * pixnum, bkmeshmapmaxi * pixnum - i * pixnum - pixnum, pixnum, pixnum, { 255, 255, 255, 255});DrawRectangle(j * pixnum, bkmeshmapmaxi * pixnum - i * pixnum, pixnum, pixnum, { 255, 255, 255, 255});
// DrawRectangle(j * pixnum, bkmeshmapmaxi*pixnum-i * pixnum, pixnum, pixnum, {255, 0, 0, 255});} else if (map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] 2024) {DrawRectangle(j * 30, bkmeshheight - i * 30, pixnum, pixnum, {255, 0, 0, 255});} else if (map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] 224) {DrawRectangle(j * 30, bkmeshheight - i * 30, pixnum, pixnum, {125, 125, 0, 255});} else if (map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] 1224) {DrawRectangle(j * 30, bkmeshheight - i * 30, pixnum, pixnum, {0, 255, 0, 255});} else if (map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] 1949) {DrawRectangle(j * pixnum, bkmeshheight - i * pixnum, pixnum, pixnum, {0, 0, 0, 255});} else if (map[bkmeshmapmaxi - i bkmeshmapi][bkmeshmapj j] 7788) {DrawRectangle(j * pixnum, bkmeshheight - i * pixnum, pixnum, pixnum, {255, 255, 255, 255});} else {
// 60是边界-30是i0时要760打印就没有空间了730打印30高正方形刚好是760同时对应底部的黑边消失了这就是整体下移动30像素
// DrawRectangle(j * 30, 750 60 - i * 30 - 30, 30, 30, {map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] * 1 % 255, map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] * 21 % 255, 255, 255});// 替换常数
// DrawRectangle(j * pixnum, bkmeshmapmaxi * pixnum - i * pixnum -pixnum, pixnum, pixnum, {map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] * 1 % 255, map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] * 21 % 255, 255, 255});DrawRectangle(j * pixnum, bkmeshmapmaxi * pixnum - i * pixnum, pixnum, pixnum, {map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] * 1 % 255, map[bkmeshmapmaxi - i bkmeshmapi][j bkmeshmapj] * 21 % 255, 255, 255});}
// 左下角DrawRectangle(0, 0, 150, 150, {154, 154, 154, 255});
// 左上角DrawRectangle(0, bkmeshmapmaxi * pixnum - 100, 30, 100, {255, 255, 255, 255});
// 屏幕右上角对应的白色矩形DrawRectangle(bkmeshmapmaxi * pixnum - pixnum, bkmeshmapmaxi * pixnum - 100, 30, 100, {255, 255, 255, 255});
// 屏幕右下角对应的红色矩形DrawRectangle(bkmeshmapmaxi * pixnum - pixnum, 0, pixnum, 100, {255, 0, 0, 255});
// 绘制坐标系是左下角00y正方向向上}}}// 颜色复位// 新增复位在绘制后
// for (int i 0; i mapi; i) {
// for (int j 0; j mapj; j) {
// map[i][j] mapv2[i][j];
// }
// }// 绘制敌人贴图不再是网格for (int n 0; n enemysum; n) {DrawTexture(enemy[n].picture.texture, enemy[n].targetj * pixnum, (enemy[n].targeti - enemy[n].targetheight 1)*pixnum, WHITE);}// 绘制像素玩家
// DrawPixel(playerx, playery, {255, 0, 0, 255});if (regionflag 0) {DrawPixel(playerx, playery, {255, 0, 0, 255});}// 取消绘制的GPU画布EndTextureMode();// 敌人复活enemylive 0;for (int n 0; n enemysum; n) {if (enemy[n].islive 1) {enemylive;}}if (enemylive 5) {for (int n 0; n 5; n) {if (enemy[n].islive 0) {enemy[n].islive 1;enemy[n].targeti GetRandomValue(0, mapi - 1);enemy[n].targetj GetRandomValue(0, mapj - 1);enemy[n].targetwidth GetRandomValue(10, 20);enemy[n].targetheight GetRandomValue(10, 20);enemylive;// 敌人复活对应贴图重新设置大小enemy[n].picture.texture.width enemy[n].targetwidth * pixnum;enemy[n].picture.texture.height enemy[n].targetheight * pixnum;// 重新采样地图数据for (int i 0; i enemy[n].targetheight; i) {for (int j 0; j enemy[n].targetwidth; j) {
// enemy[n].oldmap[i][j] map[enemy[n].targeti - i][enemy[n].targetj j];// 追加边界检测解决闪退问题if (enemy[n].targeti - i 0 enemy[n].targeti - i mapi enemy[n].targetj j 0 enemy[n].targetj j mapj) {enemy[n].oldmap[i][j] map[enemy[n].targeti - i][enemy[n].targetj j];}}}// 复活重新设置数组,在追加mapv3,仿照采样地图数据初始化打印复位for (int y 0; y enemy[n].targetheight; y) {for (int x 0; x enemy[n].targetwidth; x) {enemy[n].mapv3[x][y] (x y) % 255;}}}}}// 设置默认绘制到桌面BeginDrawing();
// 黑色覆盖全部屏幕ClearBackground(BLACK);
// 采样坐标系是左上角00y轴正方向向下
// 重新理解由于在不改这行代码的情况下改其他地方的代码跑通了。实现了效果再次理解数据变化draftx60时draftx-limitleft60,实现在网格缓冲区采样
// 可通过边界白边左上角和右上角左右拖拽可得实际采样位置在缓冲区左右
// DrawTexturePro(mesh.texture, {draftx - limitleft, drafty - limittop, 750 / camerasize, 750 / camerasize}, {0, 0, 750, 750}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {draftx - limitleft, drafty - limittop, showj*pixnum / camerasize, showi*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {draftx - limitleft, drafty - limittop, showj*pixnum / camerasize700, showi*pixnum / camerasize700}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// 关于draftx y 和之前的正面没有区别其实是因为坐标系y轴变化但是可以变成同一个坐标系就是一个人倒着看地图头朝地脚朝天代码中保留旧形式只有数组的坐标参考是从最大开始打印的
// DrawTexturePro(mesh.texture, {draftx - limitleft, drafty - limittop, showj*pixnum / camerasize, showi*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {draftx - limitleft, drafty - limittop, showj*pixnum / camerasize, showi*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {(-draftx750/2)-750/2/camerasize, (-drafty750/2)-750/2/camerasize, 750 / camerasize, 750 / camerasize}, {0, 0, 750, 750}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {(draftx- limitleft showjv2*pixnum/2)-showjv2*pixnum/2/camerasize, drafty - limittop, showj*pixnum / camerasize, showi*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {(draftx - limitleft showjv2*pixnum / 2) - showjv2*pixnum / 2 / camerasize, (drafty - limittop showiv2 * pixnum / 2) - showiv2*pixnum / 2 / camerasize, showj*pixnum / camerasize, showi*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// DrawTexturePro(mesh.texture, {(draftx - limitleft showjv2*pixnum / 2) - showjv2*pixnum / 2 / camerasize, (drafty - limittop showiv2 * pixnum / 2) - showiv2*pixnum / 2 / camerasize, showjv2*pixnum / camerasize, showiv2*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);
// 解决bug 绘制出来是把左上角粘贴到中间实际改完增加距离原来是采样采样多了中心是mesh的中心所以要加上meshwidth/2
// DrawTexturePro(mesh.texture, {(draftx - limitleft ) bkmeshwidth / 2 - showjv2*pixnum / 2 / camerasize, (drafty - limittop bkmeshheight / 2) - showiv2*pixnum / 2 / camerasize, showjv2*pixnum / camerasize, showiv2*pixnum / camerasize}, {0, 0, showjv2 * pixnum, showiv2 * pixnum}, {0, 0}, 0, WHITE);DrawTexturePro(mesh.texture, {(draftx - limitleft ) bkmeshwidth / 2 - showjv2*pixnumv2 / 2 / camerasize, (drafty - limittop bkmeshheight / 2) - showiv2*pixnumv2 / 2 / camerasize, showjv2*pixnumv2 / camerasize, showiv2*pixnumv2 / camerasize}, {0, 0, showjv2 * pixnumv2, showiv2 * pixnumv2}, {0, 0}, 0, WHITE);DrawText(TextFormat(mouseV1 %.0f,%.0f, GetMousePosition().x, GetMousePosition().y), 35, 12, 30, BLUE);DrawText(TextFormat(mouseV2 %.0f,%.0f, GetMousePosition().x, 750 - GetMousePosition().y), 35, 62, 30, BLUE);DrawText(TextFormat(draftxyV2 %d,%d, draftx, drafty), 35, 152, 30, RED);DrawText(TextFormat(camerasize %f, camerasize), 35, 192, 30, BLACK);DrawText(TextFormat(limitleft,right %d %d, limitleft, limitleft 60), 35, 222, 30, BLACK);DrawText(TextFormat(limittop,bottom %d %d, limittop, limittop 60 ), 35, 252, 30, BLACK);DrawText(TextFormat(%i FPS, GetFPS()), 300, 2 10, 40, WHITE);DrawText(TextFormat(maxside j %d, bkmeshmapj bkmeshmapmaxj ), 340, 20 60, 40, WHITE);DrawText(TextFormat(maxside i %d, bkmeshmapi bkmeshmapmaxi ), 340, 20 100, 40, WHITE);DrawText(TextFormat(drawjiV2 %d,%d, drawj, drawi), 35, 92, 30, RED);DrawText(TextFormat(drawxyV2 %d,%d, drawx, drawy), 35, 122, 30, RED);DrawText(TextFormat(playerijV2 %d,%d, playeri, playerj), 665, 12, 40, RED);DrawText(TextFormat(playerspeed %d,%d, speedx, speedy), 665, 62, 40, RED);DrawText(TextFormat(playeraxy %d,%d, ax, ay), 665, 102, 40, RED);DrawText(TextFormat(k %f, k), 695, 192, 40, RED);DrawText(TextFormat(have boom %d, have), 1195, 12, 40, RED);DrawText(TextFormat(have boomv2 %d, havev2), 1195, 62, 40, RED);DrawText(TextFormat(playerx y %d %d, playerx, playery), 1195, 102, 40, RED);DrawText(TextFormat(regonflag %d, regionflag), 1195, 162, 40, RED);// DrawText(TextFormat(have boom %d %d %d %d, bangi, bangj, bangwidth, bangheight), 1195, 62, 40, RED);// 如果碰撞了才打印否则不打印来模拟检测是否撞上了if (isbang) {DrawText(TextFormat(have boom %d %d %d %d, bangi, bangj, bangwidth, bangheight), 1195, 62, 40, RED);}
// 结束绘制的桌面EndDrawing();}
// 卸载GPU画布释放GPU内存UnloadRenderTexture(mesh);
// 关闭后台的其他GPU 数据CloseWindow();return 0;
}
