由连连看游戏作弊器想到的

最新推荐文章于 2024-11-10 20:07:33 发布
最新推荐文章于 2024-11-10 20:07:33 发布
阅读量2.8k 收藏
点赞数
分类专栏： <b>我的ABCD</b> 文章标签： 游戏 c pivot 算法 null input
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wbusy/article/details/370124
版权

   前几天逛VCKbase的时候看到了这样一篇文章：http://www.vckbase.com/document/viewdoc/?id=1415。文章一开始就介绍了基本算法，即先获得QQ连连看窗口句柄，然而获得其DC，然后对每个方格进行颜色取样，计算出每种方格的颜色特征值，构造出方格特征矩阵，在该矩阵上实现连连看的算法，模拟鼠标点击事件。

   文章还给了一段关键的代码，即构造方格特征矩阵部分的代码。不过老实说，那些代码太难看了，命名混乱得很，我看了看源代码，比那个更糟，基本没注释。不过既然知道了算法，自己写也许比读那些难看的代码来得更快一些。

   经过实验，作者的算法的确不错，准确率接近100％，只有4种左右的方格无法识别。但是这个不是问题，只需要将取样点增加到6个就可以达到很高的分辨能力了。但是在模拟鼠标的过程中遇到了一些麻烦。一开始使用mouse_event模拟鼠标的单击，但是未能如愿以偿，每次只能单击一个方格，无法单击第二个。后来又试了试SendInput，问题依旧。去CSDN上逛了逛，没什么收获，现在还不知道问题出在哪里，看来还得自己慢慢研究。

    试验过后，觉得可以将这个思路用到类似的游戏中，比如QQ对对碰。构造特征矩阵的方法一样，只不过游戏算法不一样而已。

附：我的Code，算法有很大的改进余地。

// For SendInput() and INPUT Struct

#include "Winable.h"

//
// 一些常量和数据的定义

// 自定义消息
#define    MM_DONE   WM_USER + 1000
// 空格
#define    GRID_BLANK  (0)
// QQ连连看的游戏区方格是11行×19列
#define  ROWS  11
#define  COLS  19
// 游戏区相对于客户区的偏移（可以改变）
#define  YCOFFSET 181
#define  XCOFFSET 14
// 连连看方格的尺寸（可以改变）
#define  WIDTH  31
#define  HEIGHT  35
// 每个方格的取样点个数（可以改变）
#define  SAMPLES  4
// 各取样点相对于方格左上角的偏移量（可以改变）
const static POINT g_Offsets[SAMPLES] = {
 {15, 17},
 {11, 19},
 {16, 17},
 {21, 17}
};
// 判断两种不同颜色的容差（可以改变）
#define  TOLERANCE 15
// 方格结构
typedef struct _GRID_{
 // 方格的类别ID（hash），大于等于0，0为空格。
 //  它的作用很明显，只有同类的方格才可能被消除。
 int   iID;
 // 该方格中心坐标（客户的，为了避免因为连连看窗口位置发生变化带来的问题）
 CPoint  pt;
 // 该方格的取样点的颜色。它的作用是为了帮助确定所有方格的iID。
 COLORREF cl[SAMPLES];
}GRID;
// 整个游戏区所有的方格
static GRID  g_Grid[ROWS][COLS];
// 当前的方格种类ID(Hash)最大值
static  int   g_iGridID = 0;
// 作弊器窗口句柄。给它发送消息的时候要用到
static  HWND  g_hThisWnd = NULL;
// 连连看 HWND
static  HWND  g_hLLKWnd = NULL;

// 
// 一些辅助宏

// 获得RGB个分量
#define  B(X)  (GetBValue(X))
#define  G(X)  (GetGValue(X))
#define  R(X)  (GetRValue(X))
// 比较大小
#define  MIN(X, Y) ((X) > (Y) ? (Y) : (X))
#define  MAX(X, Y) ((X) > (Y) ? (X) : (Y))
// 差的绝对值
#define  ABS(X, Y) ((X) < (Y) ? (Y) - (X) : (X) - (Y))

//
// 计算两种颜色个分量的差值之和
int   Difference(const COLORREF &c1, const COLORREF &c2)
{
 return ABS(R(c1), R(c2))
  +  ABS(G(c1), G(c2))
  +  ABS(B(c1), B(c2));
}
// 在矩阵中查找和指定颜色的差别在容差范围内的方格(r, c)。如果不存在则返回 － 1,
// 否则返回0和该颜色所在方格的位置。
int   FindColor(const COLORREF cl[SAMPLES], int &r, int &c)
{
 int i, j, k, iDiff;
 for(i = 0; i < ROWS; i ++)
 {
  for(j = 0 ; j < COLS; j ++)
  {
   // 不用和空格比较
   if(g_Grid[i][j] .iID == GRID_BLANK)
    continue;
   iDiff = 0;
   // 计算该颜色和指定颜色之间的差别
   for(k = 0; k < SAMPLES; k ++)
   {
    iDiff += Difference(g_Grid[i][j] .cl[k], cl[k]);
   }
   if(iDiff <= TOLERANCE)
   {
    // 找到
    r = i;
    c = j;
    return 0;
   }
  }
 }
 return - 1;
}
// 通过取样点的RGB值确定一个方格的类别ID(Hash)
int   GetGridID(const COLORREF cl[SAMPLES])
{
 // 根据颜色将方格分类
 for(int i = 0; i < SAMPLES; i ++)
 {
  // 空格的RGB分量范围
  // R(44~74), G(49~91), B(102~103)
  if (R(cl[i]) > 44 && R(cl[i]) < 74
   && G(cl[i]) > 49 && G(cl[i]) < 91
   && B(cl[i]) > 102 && R(cl[i]) < 130)
  {
  }
  else
  {
   // 是否已经存在？
   int r, c;
   if(FindColor(cl, r, c) == - 1)
   {
    // 不存在,则添加
    g_iGridID ++;
    return g_iGridID;
   }
   else
   {
    // 存在则返回ID
    return g_Grid[r][c] .iID;
   }
  }
 }
 // 空格
 return GRID_BLANK;
}
// 报告错误
void   ReportError(CString strMsg)
{
 AfxMessageBox(strMsg);
}

// 获得游戏方格特征矩阵
BOOL  InitMatrix(HWND hWnd)
{
 // 获得连连看CWnd
 CWnd* pWnd = CWnd ::FromHandle(hWnd);
 if(NULL == pWnd)
  return FALSE;
 // 连连看最小化了？
 if(pWnd ->IsIconic())
 {
  pWnd ->ShowWindow(SW_RESTORE);
  Sleep(200);
 }
 // 连连看没有激活？
 if(pWnd ->GetActiveWindow() ->GetSafeHwnd() != hWnd)
 {
  pWnd ->SetForegroundWindow();
  pWnd ->SetActiveWindow();
  Sleep(200);
 }
 // 获得连连看的CDC
 CDC* pDC = pWnd ->GetDC();
 if(pDC == NULL)
  return FALSE;
 // 获得连连看游戏区左上角第一个方格的中心坐标（客户区的）
 CPoint pt(0, 0);
 // 获得对应所有方格的特征
 for(int i = 0; i < ROWS; i ++)
 {
  // 方格左上角的Y坐标
  pt .y = YCOFFSET + i * HEIGHT;
  for(int j = 0; j < COLS; j ++)
  {
   // 方格左上角的X坐标
   pt .x = XCOFFSET + j * WIDTH;
   // 保存方格中心坐标（客户区）
   g_Grid[i][j] .pt .Offset(pt .x + WIDTH / 2, pt .y + HEIGHT / 2);
   // 得到该方格的取样点的RGB
   for(int k = 0; k < SAMPLES; k ++)
   {
    // 如果用户关闭了程序窗口
    if(::IsWindow(hWnd))
    {
     g_Grid[i][j] .cl[k] = pDC ->GetPixel(pt .x + g_Offsets[k] .x, pt .y + g_Offsets[k] .y);
    }
    else
    {
     // 窗口已经被关闭！
     ReportError(_T("窗口在编码时被关闭，请检查连连看的状态，并尝试重新编码！"));
     return FALSE;
    }
   }
   // 确定该方格类别Hash
   g_Grid[i][j] .iID = GetGridID(g_Grid[i][j] .cl);
   TRACE(_T("%4d,"), g_Grid[i][j] .iID);
  }
  TRACE(_T("/r/n"));
 }
 return TRUE;
}

// 判断两个在同一行（列）的方格(必须同类，可以是空格)之间是否存在直线通路
BOOL  GridsConnected(int pivot, int l, int h, BOOL bHorizontal = TRUE)
{
 // 是否同类？
 if(bHorizontal)
 {
  if(g_Grid[pivot][l] .iID != g_Grid[pivot][h] .iID)
   return FALSE;
 }
 else
 {
  if(g_Grid[l][pivot] .iID != g_Grid[h][pivot] .iID)
   return FALSE;
 }
 int L = MIN(l, h);
 int H = MAX(l, h);
 // 两个方格之间必须都是空格
 for(int i = L + 1; i < H; i ++)
 {
  if(bHorizontal)
  {
   if(g_Grid[pivot][i] .iID != GRID_BLANK)
    return FALSE;
  }
  else
  {
   if(g_Grid[i][pivot] .iID != GRID_BLANK)
    return FALSE;
  }
 }
 return TRUE;
}
// 输出路径
void  OutputPath(int r1, int c1, int r2, int c2)
{
 if(r1 == r2 && c1 == c2)
  return;
 //TRACE(_T(">>>(%d, %d) -> (%d, %d)./r/n"), r1, c1, r2, c2);
}
// 判断两个方格(r1, c1)和(r2, c2)(不能是空格)是否可以消除
BOOL  Match(const int r1, const int c1, const int r2, const int c2)
{
 // 不能是空格
 if(g_Grid[r1][c1] .iID == GRID_BLANK
  || g_Grid[r2][c2] .iID == GRID_BLANK)
  return FALSE;
 // 必须是同一种方格
 if(g_Grid[r1][c1] .iID != g_Grid[r2][c2] .iID)
  return FALSE;
 // 起始点的类别
 const int iID = g_Grid[r1][c1] .iID;

 // 它们在同一行？
 if(r1 == r2)
 {
  if(c1 <= c2)
  {
   // 它们之间是否有直线通路？
   if(GridsConnected(r1, c1, c2))
   {
    OutputPath(r1, c1, r1, c2);
    return TRUE;
   }
   // 是否有其他通路？
   for(int i = 0; i < ROWS; i ++)
   {
    // 已经判断过了
    if(i == r1)
     continue;
    // 两个拐点必须是空格
    if(GRID_BLANK == g_Grid[i][c1] .iID
     && GRID_BLANK == g_Grid[i][c2] .iID)
    {
     // 将两个拐点的类别设置为iID，然后判断是否有路径
     g_Grid[i][c1] .iID = g_Grid[i][c2] .iID = iID;
     if(GridsConnected(c1, i, r1, FALSE)
      && GridsConnected(i, c1, c2)
      && GridsConnected(c2, i, r1, FALSE))
     {
      // OK，还原类别
      g_Grid[i][c1] .iID = GRID_BLANK;
      g_Grid[i][c2] .iID = GRID_BLANK;
      OutputPath(i, c1, r1, c1);
      OutputPath(i, c1, i, c2);
      OutputPath(i, c2, r1, c2);
      return TRUE;
     }
     else
     {
      // 不通，则测试下一条路径，并且还原拐点类别
      g_Grid[i][c1] .iID = GRID_BLANK;
      g_Grid[i][c2] .iID = GRID_BLANK;
     }
    }
   } // end for
   // 不通
   return FALSE;
  }
  else
  {
   return Match(r1, c2, r1, c1);
  }
 }
 // 它们在同一列？
 if(c1 == c2)
 {
  if(r1 <= r2)
  {
   if(GridsConnected(c1, r1, r2, FALSE))
   {
    OutputPath(r1, c1, r2, c1);
    return TRUE;
   }
   // 是否有其他通路？
   for(int i = 0; i < COLS; i ++)
   {
    if(i == c1)
     continue;
    // 必须为空格
    if( GRID_BLANK == g_Grid[r1][i] .iID
     && GRID_BLANK == g_Grid[r2][i] .iID)
    {
     //将两个拐点的类别设置为iID，然后判断是否有路径
     g_Grid[r1][i].iID = g_Grid[r2][i] .iID = iID;
     if(GridsConnected(r1, i, c1)
      && GridsConnected(i, r1, r2, FALSE)
      && GridsConnected(r2, i, c1))
     {
      // OK, 还原类别
      g_Grid[r1][i].iID = GRID_BLANK;
      g_Grid[r2][i].iID = GRID_BLANK;
      OutputPath(r1, c1, r1, i);
      OutputPath(r1, i, r2, i);
      OutputPath(r2, i, r2, c1);
      return TRUE;
     }
     else
     {
      // 不通，则测试下一条路径，并且还原拐点类别
      g_Grid[r1][i].iID = GRID_BLANK;
      g_Grid[r2][i].iID = GRID_BLANK;
     }
    }
   }
   // 不通
   return FALSE;
  }
  else
  {
   return Match(r2, c1, r1, c1);
  }
 }
 // 不在同一列或者行
 // 通过在拐点构造和方格类别相同的方格，然后判断它们是否联通（最多3条线，最少2两条
 //  其中一条退化）
 for(int i = 0; i < ROWS; i ++)
 {
  // 拐点1必须为空格
  if(g_Grid[i][c1] .iID != GRID_BLANK)
   continue;
  // 起点和拐点1联通吗？
  g_Grid[i][c1] .iID = iID;
  if(GridsConnected(c1, i, r1, FALSE))
  {
   // 是的，拐点2必须为空格
   if(g_Grid[i][c2] .iID != GRID_BLANK)
   {
    // 还原拐点1的类别，尝试下一条路径
    g_Grid[i][c1] .iID = GRID_BLANK;
    continue;
   }
   // 拐点2和拐点1联通吗？
   g_Grid[i][c2] .iID = iID;
   if(GridsConnected(i, c1, c2))
   {
    // 是的，然后判断拐点2和(r2, c2)是否联通
    if(GridsConnected(c2, i, r2, FALSE))
    {
     // 是的，路径找到，还原拐点类别
     g_Grid[i][c2] .iID = GRID_BLANK;
     g_Grid[i][c1] .iID = GRID_BLANK;
     //
     OutputPath(r1, c1, i, c1);
     OutputPath(i, c1, i, c2);
     OutputPath(i, c2, r2, c2);
     return TRUE;
    }
   }
   // 拐点2和拐点1不通，还原拐点类别，尝试下一行
   g_Grid[i][c1] .iID = GRID_BLANK;
   g_Grid[i][c2] .iID = GRID_BLANK;
  }
  else
  {
   // 起点和拐点1不联通，还原拐点类别
   g_Grid[i][c1] .iID = GRID_BLANK;
  }
 } // end for
  
 for(i = 0; i < COLS; i ++)
 {
  // 拐点1必须为空格
  if(g_Grid[r1][i] .iID != GRID_BLANK)
   continue;
  // 起点和拐点1联通吗？
  g_Grid[r1][i] .iID = iID;
  if(GridsConnected(r1, i, c1))
  {
   // 是的，拐点2 必须为空格
   if(g_Grid[r2][i] .iID != GRID_BLANK)
   {
    // 还原拐点1的类别，尝试下一条路径
    g_Grid[r1][i] .iID = GRID_BLANK;
    continue;
   }
   // 拐点2和拐点1联通吗？
   g_Grid[r2][i] .iID = iID;
   if(GridsConnected(i, r1, r2, FALSE))
   {
    // 是的，然后判断拐点2和(r2, c2)是否联通
    if(GridsConnected(r2, i, c2))
    {
     // 是的，路径找到，还原拐点类别
     g_Grid[r1][i] .iID = GRID_BLANK;
     g_Grid[r2][i] .iID = GRID_BLANK;
     //
     OutputPath(r1, c1, r1, i);
     OutputPath(r1, i, r2, i);
     OutputPath(r2, i, r2, c2);
     return TRUE;
    }
   }
   // 拐点2和拐点1不通，还原拐点类别，尝试下一行
   g_Grid[r1][i] .iID = GRID_BLANK;
   g_Grid[r2][i] .iID = GRID_BLANK;
  }
  else
  {
   // 起点和拐点1不通，则还原拐点类别，尝试下一条路径
   g_Grid[r1][i] .iID = GRID_BLANK;
  }
 }
 return FALSE;
}
// 模拟点击两次鼠标。实际情况有点不一样，鼠标没有点击两次，至少看起来是这样。事实上只是点击了第一次，后一次没有点击。用SendInput问题一样。
void  MouseClick(const CPoint& p1, const CPoint& p2)
{
 // 将客户区坐标转换为屏幕坐标
 CPoint pp1(p1), pp2(p2);
 ::ClientToScreen(g_hLLKWnd, &pp1);
 ::ClientToScreen(g_hLLKWnd, &pp2);
 // 点击两次鼠标
 /* */
 ::SetCursorPos(pp1 .x, pp1 .y);
 mouse_event( MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
 mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
 Sleep(100);
 ::SetCursorPos(pp2 .x, pp2 .y);
 mouse_event( MOUSEEVENTF_LEFTDOWN , 0, 0, 0, 0);
 mouse_event( MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);

 /*
 INPUT clk;
 ZeroMemory(&clk, sizeof(clk));
 clk .type  = INPUT_MOUSE;
 clk . mi .dwFlags =  MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP;
 clk . mi .dwFlags =  MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP;
 ::SetCursorPos(pp1 .x, pp1 .y);
 VERIFY(1 == SendInput(1, &clk, sizeof(clk)));
 Sleep(300);
 ::SetCursorPos(pp2 .x, pp2 .y);
 VERIFY(1 == SendInput(1, &clk, sizeof(clk)));
 Sleep(300);
 */
}

wbusy
关注
专栏目录
连连看辅助工具
weixin_34245082的博客
08-31 508
相信玩过连连看的朋友都有过这样的感觉，在网络卡的时候，经常是看到别人还有很多没点的时候，突然之间就完了，让人感到很是郁闷，现在可好了，有了这个工具以后，大家也可以做出这样神奇的事情来！不仅可以让你远离苦恼，还可以让你快速升级哦，不过在用的时候可要注意影响，不要太过火了！ 以下是下载的地址：http://disk24.sh.com/?endl　中lianliankan的文件夹中！ 转载于:htt...
（转载）连连看游戏外挂详细制作过程
weixin_34128839的博客
03-16 2295
标 题: 【原创】新人入手第一个游戏外挂,附上详细制作过程 作 者: caigui 时 间: 2013-01-09,00:56:16 链 接: http://bbs.pediy.com/showthread.php?t=160887 此教程为原创,但本人是个菜鸟,刚入手写程序,因此本帖有部分内容是参照其他一些教程,以及本论坛里有关连连看的帖...
用Python做一个连连看游戏辅助脚本，完整编程思路分享
Python4857的博客
12-23 2262
一、说明 简述：本文将以4399小游戏《 宠物连连看经典版2 》作为测试案例，通过识别小图标，模拟鼠标点击，快速完成配对。对于有兴趣学习游戏脚本的同学有一定的帮助。 运行环境：Win10/Python3.5。 主要模块：win32gui（识别窗口、窗口置顶等操作）、PIL（屏幕截图）、numpy（创建矩阵）、operator（比较值）、pymouse（模拟鼠标点击）。 注意点： 1、如果安装pymouse不成功或者运行报错，可以考虑先通过whl 安装pyHook、然后再通过pip安装pyuseri
200行Python实现效果逆天的连连看外挂
Three_dog的博客
07-19 3355
本文内容转自我本人的知乎回答：你看过/写过哪些有意思的代码？ - 三级狗的回答 - 知乎 https://www.zhihu.com/question/275611095/answer/407984155 。转载请务必联系作者授权，并注明出处。 博客里不能加小视频，上几张图展示下外挂的惊人效果，图中是将时间间隔设置为0的效果。 前言 python写的连连看外挂，图中时间间隔设置成了0，效...
JAVA实训-连连看（二）总结
忆_恒心的博客
07-09 3477
修改界面，添加功能 修复那个事件的bug重列、计分、重新开一局，推出游戏
连连看外挂制作 —— 无限时间（2）
Koma的主页
12-11 5325
标 题: 连连看外挂制作 —— 无限时间（2） 作 者: Koma 时 间: 2009-12-11 08:10 链 接: http://blog.csdn.net/wangningyu/archive/2009/12/11/4983620.aspx 本章节会介绍用远程线程，来锁定远程进程
连连看外挂1.0
panda1987的专栏
11-01 7718
        一时兴起，决定写个连连看的外挂玩玩...于是断断续续经过几个晚上的努力基本呈现雏形...之前也看过一些外挂技术的文章，确实这里面的技术深不可测，第一次写就搞个简单的吧，以后再慢慢改进。        最简单的外挂莫过于器械式的，也就是通过界面分析，然后去模拟一些鼠标或者键盘动作。连连看外挂就可以通过这种方式去写。整个外挂基本分为以下几步完成：1. 获取界面信息，当然最主要的
用Python做一个游戏辅助脚本，完整编程思路分享
m0_62051288的博客
01-04 2681
一、说明 简述：本文将以4399小游戏《 宠物连连看经典版2 》作为测试案例，通过识别小图标，模拟鼠标点击，快速完成配对。对于有兴趣学习游戏脚本的同学有一定的帮助。 运行环境：Win10/Python3.5。 主要模块：win32gui（识别窗口、窗口置顶等操作）、PIL（屏幕截图）、numpy（创建矩阵）、operator（比较值）、pymouse（模拟鼠标点击）。 注意点： 1、如果安装pymouse不成功或者运行报错，可以考虑先通过whl 安装pyHook、然后再通过pip安装pyuseri
游戏服务器浅析
dssdss123的专栏
08-12 2062
（一）平台选择 windows还是linux？ 1、平台费用：如果是大型公司，用windows server就要向微软交点保护费，如果是小型公司。。。你懂的，所以很多大型公司都选择了linux开发服务器，但不一定就说linux的好。 2、开发环境搭建：windows有现成的VS开发环境，安装一下，一般不会出错，而且像VS助手这样的插件还有联合编译器都很容易安装成功，但linux上安装起来就比
案例教程—200行python实现杀手级连连看外挂程序
简书博客搬家测试账号
06-11 3091
欢迎关注天善智能，我们是专注于商业智能BI，人工智能AI，大数据分析与挖掘领域的垂直社区，学习，问答、求职一站式搞定！ 对商业智能BI、大数据分析挖掘、机器学习，python，R等数据领域感兴趣的同学加微信：tsaiedu，并注明消息来源，邀请你进入数据爱好者交流群，数据爱好者们都在这儿。 作者：三级狗 长不帅的程序猿小哥哥 Python爱好者社区专...
【Java从入门到天黑|01】SE入门之Java的前生今世
孙叫兽的博客
04-16 3888
JavaSE入门基础
软件工程学习报告
weixin_30832983的博客
12-27 918
软件工程课程设计团队项目总结与项目报告 团队成员自评 漆艺： 身为团队的PM项目经理，开始的时候自己还不知道该做些什么，因为自己项目经验不足，团队把这个重要的角色交给我，那就有责任和义务把团队项目做好，并且发挥各个成员的作用。开始我们团队想的是做一个网页单机游戏，后来想到这种类型很多，就加了个心理分析，这种很少见，功能也很特别。在搭建服务器的过程中，自己做了很多，在网上也查了很多资料...
软件工程课程设计项目总结与项目报告
weixin_30561177的博客
12-28 1251
软件工程课程设计团队项目总结与项目报告 团队成员自评 漆艺： 身为团队的PM项目经理，开始的时候自己还不知道该做些什么，因为自己项目经验不足，团队把这个重要的角色交给我，那就有责任和义务把团队项目做好，并且发挥各个成员的作用。开始我们团队想的是做一个网页单机游戏，后来想到这种类型很多，就加了个心理分析，这种很少见，功能也很特别。在搭建服务器的过程中，自己做了很多，在网上也查了很多资料...
Unity Windows 2023 Release-Notes
qq_26318597的博客
11-07 833
Unity Windows 2023 Release-Notes
在双显示器环境中利用Sunshine与Moonlight实现游戏串流的同时与电脑其他任务互不干扰
最新发布
LY的博客
11-10 202
我和老婆经常会同时需要操作家里的电脑，在周末老婆有时要用电脑加班上网办公，而我想在难得的周末好好地Game一下（在客厅用电视机或者平板串流），但是电脑只有一个，以往我一直都是把电脑让给老婆，自己到客厅去电视机上看动漫。我作为一个热爱游戏的发烧友，同时又是一位极客，总是想彻底地在双方需求之间找到合理的最终解决方案，通过十五分钟左右的尝试，我利用现有的双显示器找到了完美的解决方案，既能满足我远程玩游戏的乐趣，又能确保老婆在主显示器上安心办公，互不干扰。
Unity常见问题合集（一）
我与岁月的森林的博客
11-10 63
Unity常见问题合集（一）
Unity中RTS游戏的设计模式处理： 游戏中的对象选择和命令委托的基本框架
网易搬砖选手
11-06 412
单个集中类（例如，）跟踪当前选择的单元/对象，并处理用于选择游戏中对象的任何光线投射逻辑。可选对象附加了一个组件，其中公开了一个公共函数，该函数返回一个实现该接口的类。类实现特定于控制单个单元的自定义逻辑。这是通过一个公共函数完成的，每次玩家单击一个新对象时都会调用该函数。当玩家单击屏幕时，单个类会进行光线投射，以获取有关单击哪个对象的信息。该类还跟踪当前正在控制的单元，并将新单击的对象提供给该单元的控制逻辑。如果没有选择任何内容，我们将尝试选择接下来单击的对象。
运用Agent搭建“狼人杀”游戏服务器端！
python12345_的博客
11-08 811
总的来说，Agent是当下比较火热的技术。在本文中，我们主要聚焦于如何使用大模型来驱动游戏Agent，并结合提示词工程的一些技巧以及游戏的特性进行架构设计。可以看到，LLM的能力不断增长，超长上下文、响应速度、拒答率等因素不再成为约束，其在”游戏智能 NPC”的探索和应用会越来越多。借助其优秀的推理能力，游戏的玩法和设计也会变得更加丰富多彩。然而，目前我们还看到一些其他的限制：角色的表现力、游戏的沉浸感这块目前属于大模型能力的短板。
Mesh网格
2301_76618920的博客
11-10 202
定义：Mesh 是一个包含等数据的对象。它定义了3D模型的几何形状。功能：顶点（Vertices）：构成3D模型的点。三角形（Triangles）：由三个顶点组成的面，定义了模型的表面。法线（Normals）：定义了表面的朝向，对于光照计算非常重要。UV坐标（UV Coordinates）：用于将纹理映射到3D模型上。颜色（Colors）：可以为每个顶点或每个子网格指定颜色。骨骼权重（Bone Weights）：用于骨骼动画，定义了顶点如何受到骨骼的影响。
C++编程实现连连看游戏开发教程
5. 面向对象编程(OOP)：C++支持面向对象编程，这意味着在编写游戏代码时，可以将游戏元素定义为对象，例如将一个图案、一个计分器或游戏棋盘作为一个对象。利用类的封装、继承和多态等特性可以提高代码的可重用性...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值