1. Toy模板网首页
  2. > Toy博客

C++ 实现游戏（例如MC）键位显示

10月前 作者：Wormwaker 分类：Toy博客 阅读(39) 违法举报

这篇具有很好参考价值的文章主要介绍了C++ 实现游戏（例如MC）键位显示。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

效果：
C++ 实现游戏（例如MC）键位显示,c++,游戏,windows,Minecraft,MC,我的世界
是不是有那味儿了？

  • 显示AWSD，空格，Shift和左右键的按键情况以及左右键的CPS。 彩虹色轮廓，黑白填充。
  • 具有任务栏图标，可以随时关闭
  • 字体是Minecraft AE Pixel，如果你没有装（大概率），你可以换用其他好看的字体（在代码中修改即可）

由于是从一个更大的项目中提取的代码，所以可能会有一些不美观之处。
必要的gcc编译参数：-lgdi32
代码如下：文章来源地址https://www.toymoban.com/news/detail-795500.html

/***************************************
 *           Keystrokes.cpp            *
 *            游戏按键显示             *
 *         Author: Wormwaker           *
 *       StartDate: 2024/1/14          *
 ***************************************/
#include <Windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <cstdarg>
using namespace std;
#define KEY_DOWN(vk) (GetAsyncKeyState(vk)&0x8000?1:0)

int scr_w = 0, scr_h = 0, taskbar_h = 0;
HDC hdcOrigin = NULL, hdcBuffer = NULL;
HWND hwnd = NULL;
HWND hwnd_console = NULL;

HINSTANCE _hInstance = NULL;
HINSTANCE _hPrevInstance = NULL;
LPSTR _lpCmdLine = NULL;
int _nShowCmd = SW_SHOWNORMAL;

/
#define CJZAPI __stdcall
template <typename _T>
string CJZAPI str(const _T& value)
{
	stringstream ss;
	ss << value;
	string res;
	ss >> res;
	return res;
}
string CJZAPI sprintf2(const char* szFormat, ...)
{
	va_list _list;
	va_start(_list, szFormat);
	char szBuffer[1024] = "\0";
	_vsnprintf(szBuffer, 1024, szFormat, _list);
	va_end(_list);
	return string{szBuffer};
}
bool CJZAPI ExistProcess(DWORD dwPid)	//判断是否存在指定进程
{
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);	
	if (INVALID_HANDLE_VALUE == hSnapshot) 	
	{		
		return false;	
	}	
	PROCESSENTRY32 pe = { sizeof(pe) };	
	BOOL fOk;	
	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe)) 	
	{		
		if (pe.th32ProcessID == dwPid) 		
		{			
			CloseHandle(hSnapshot);			
			return true;		
		}	
	}	
	return false;
}
bool CJZAPI ExistProcess(LPCSTR lpName)	//判断是否存在指定进程
{	//******警告！区分大小写！！！！******// 
	//*****警告！必须加扩展名！！！！*****// 
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);	
	if (INVALID_HANDLE_VALUE == hSnapshot) 	
	{		
		return false;	
	}	
	PROCESSENTRY32 pe = { sizeof(pe) };	
	BOOL fOk;	
	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe)) 	
	{		
		if (! stricmp(pe.szExeFile, lpName)) 		
		{			
			CloseHandle(hSnapshot);			
			return true;		
		}	
	}	
	return false;
}
inline int GetScreenHeight(void) //获取屏幕高度
{
	return GetSystemMetrics(SM_CYSCREEN);
}
inline int GetScreenWidth(void) //获取屏幕宽度
{
	return GetSystemMetrics(SM_CXSCREEN);
}
RECT CJZAPI GetSystemWorkAreaRect(void) //获取工作区矩形 
{
	RECT rt;
	SystemParametersInfo(SPI_GETWORKAREA,0,&rt,0);    // 获得工作区大小
	return rt;
}
LONG CJZAPI GetTaskbarHeight(void) 		//获取任务栏高度 
{	
	INT cyScreen = GetScreenHeight();
	RECT rt = GetSystemWorkAreaRect();
	return (cyScreen - (rt.bottom - rt.top));
}
inline HWND GetTaskbarWindow(void)
{
	return WindowFromPoint(POINT{ GetScreenWidth() / 2,GetScreenHeight() - 2 });
}
inline HFONT CJZAPI CreateFont(int height, int width, LPCSTR lpFamilyName)
{
	return CreateFont(height,width,0,0,FW_NORMAL,0,0,0,0,0,0,0,0,lpFamilyName);
}
// 辅助函数：HSV到RGB颜色转换
COLORREF HSVtoRGB(double h, double s, double v) {
	int hi = static_cast<int>(floor(h / 60.0)) % 6;
	double f = h / 60.0 - floor(h / 60.0);
	double p = v * (1.0 - s);
	double q = v * (1.0 - f * s);
	double t = v * (1.0 - (1.0 - f) * s);
	
	switch (hi) {
		case 0: return RGB(static_cast<int>(v * 255), static_cast<int>(t * 255), static_cast<int>(p * 255));
		case 1: return RGB(static_cast<int>(q * 255), static_cast<int>(v * 255), static_cast<int>(p * 255));
		case 2: return RGB(static_cast<int>(p * 255), static_cast<int>(v * 255), static_cast<int>(t * 255));
		case 3: return RGB(static_cast<int>(p * 255), static_cast<int>(q * 255), static_cast<int>(v * 255));
		case 4: return RGB(static_cast<int>(t * 255), static_cast<int>(p * 255), static_cast<int>(v * 255));
		case 5: return RGB(static_cast<int>(v * 255), static_cast<int>(p * 255), static_cast<int>(q * 255));
		default: return RGB(0, 0, 0);  // Shouldn't reach here
	}
}
// 主函数：返回随时间变化的彩虹色
COLORREF RainbowColor() {
	// 假设时间按秒计算，这里使用系统时间或其他适当的时间源
	double timeInSeconds = GetTickCount() / 1000.0;
	
	// 色相按时间变化
	double hue = fmod(timeInSeconds * 30.0, 360.0);  // 假设每秒变化30度
	
	// 饱和度和亮度保持不变
	double saturation = 1.0;
	double value = 1.0;
	
	// 将HSV颜色转换为RGB并返回
	return HSVtoRGB(hue, saturation, value);
}

inline void CJZAPI SetTextColor(COLORREF color)
{
	SetTextColor(hdcBuffer, color);
}
inline void CJZAPI TextOut(int x, int y, LPCSTR lpText, HDC hdc = hdcBuffer)
{
	TextOut(hdc, x, y, lpText, strlen(lpText));
}
inline void CJZAPI TextOutShadow(int x, int y, LPCSTR lpText, HDC hdc = hdcBuffer)
{
	COLORREF oclr = GetTextColor(hdc);
	SetTextColor(RGB(0,0,0));
	TextOut(x+2,y+2,lpText,hdc);
	SetTextColor(oclr);
	TextOut(x,y,lpText,hdc);
}
void ClearDevice(HDC _hdc = hdcBuffer, HWND _hwnd = hwnd)
{
	// 清屏：使用透明色填充整个客户区域
	RECT rcClient;
	GetClientRect(_hwnd, &rcClient);
	HBRUSH hBrush = CreateSolidBrush(RGB(0, 0, 0));
	FillRect(_hdc, &rcClient, hBrush);
	DeleteObject(hBrush);
}
/
int left_cps = 0;
int right_cps = 0;
#define CPS_UPDATE_CD 1000
void UpdateCPS(void)
{
	static DWORD startTime = GetTickCount();
	static int leftClicks = 0, rightClicks = 0;
	static bool leftButtonDown = false, rightButtonDown = false;
	
	bool leftButtonPressed = KEY_DOWN(VK_LBUTTON);
	if (leftButtonPressed && !leftButtonDown) 
		leftClicks++;
	leftButtonDown = leftButtonPressed;
	
	bool rightButtonPressed = KEY_DOWN(VK_RBUTTON);
	if (rightButtonPressed && !rightButtonDown)
		rightClicks++;
	rightButtonDown = rightButtonPressed;
	
	DWORD currentTime = GetTickCount();
	DWORD elapsedTime = currentTime - startTime;
	
	if (elapsedTime >= CPS_UPDATE_CD) 
	{
		left_cps = leftClicks * (1000.0 / CPS_UPDATE_CD);
		right_cps = rightClicks* (1000.0 / CPS_UPDATE_CD);
		
		startTime = currentTime;
		leftClicks = 0;
		rightClicks = 0;
	}
}
inline const int& GetCPS(bool left0_right1)
{
	return left0_right1 ? right_cps : left_cps;
}
void DrawKeyBox(BYTE key, const char* name, int fs, int left, int top, int right, int bottom)
{
	static const char* font = "Minecraft AE Pixel";
	
	COLORREF color;
	if(KEY_DOWN(key))
		color = RGB(200, 200, 200) | (200 << 24);
	else
		color = RGB(1, 1, 1) | (80 << 24);
	HBRUSH hBrush = CreateSolidBrush(color);
	auto prevObj = SelectObject(hdcBuffer, hBrush);
	Rectangle(hdcBuffer, left + (KEY_DOWN(key)?2:0), top + (KEY_DOWN(key)?2:0), right + (KEY_DOWN(key)?2:0), bottom + (KEY_DOWN(key)?2:0));
	SelectObject(hdcBuffer, prevObj);
	DeleteObject(hBrush);
	
	HFONT hFont = CreateFont(fs, 0, font);
	prevObj = SelectObject(hdcBuffer, hFont);
	SetTextColor(RainbowColor());
	SetBkMode(hdcBuffer, TRANSPARENT);
	string text{name};
	int x = left + (KEY_DOWN(key)?2:0) + (right - left) / 2.0f - text.length() * fs / 4.0f;
	int y = top + (KEY_DOWN(key)?2:0) + (bottom - top) / 2.0f - fs / 2.0f;
	TextOutShadow(x, y, text.c_str());
	DeleteObject(hFont);
	SelectObject(hdcBuffer, prevObj);
}
void DrawMouseKeys(int left, int top)
{
	static const int box_w = 85;
	static const int box_h = 45;
	static const int box_gap = 15;
	static const int fs = 15;
	static const int small_fs = 10;
	static const char* font = "Minecraft AE Pixel";
	
	COLORREF color;
	if(KEY_DOWN(VK_LBUTTON))
		color = RGB(200, 200, 200) | (200 << 24);
	else
		color = RGB(1, 1, 1) | (80 << 24);
	HBRUSH hBrush = CreateSolidBrush(color);
	auto prevObj = SelectObject(hdcBuffer, hBrush);
	Rectangle(hdcBuffer, left + (KEY_DOWN(VK_LBUTTON)?2:0), top+ (KEY_DOWN(VK_LBUTTON)?2:0), left + (KEY_DOWN(VK_LBUTTON)?2:0) + box_w, top + box_h+ (KEY_DOWN(VK_LBUTTON)?2:0));
	SelectObject(hdcBuffer, prevObj);
	DeleteObject(hBrush);
	
	if(KEY_DOWN(VK_RBUTTON))
		color = RGB(200, 200, 200) | (200 << 24);
	else
		color = RGB(1, 1, 1) | (80 << 24);
	hBrush = CreateSolidBrush(color);
	prevObj = SelectObject(hdcBuffer, hBrush);
	Rectangle(hdcBuffer, left + (KEY_DOWN(VK_RBUTTON)?2:0) + box_w + box_gap, top + (KEY_DOWN(VK_RBUTTON)?2:0), left + (KEY_DOWN(VK_RBUTTON)?2:0) + box_w*2 + box_gap, top + box_h+ (KEY_DOWN(VK_RBUTTON)?2:0));
	SelectObject(hdcBuffer, prevObj);
	DeleteObject(hBrush);
	
	HFONT hFont = CreateFont(small_fs, 0, font);
	prevObj = SelectObject(hdcBuffer, hFont);
	SetTextColor(RainbowColor());
	SetBkMode(hdcBuffer, TRANSPARENT);
	
	string text = sprintf2("%d CPS", GetCPS(0));
	int x = left + (KEY_DOWN(VK_LBUTTON)?2:0) + box_w / 2.0f - text.length() * small_fs / 4.0f - 3;
	int y = top + (KEY_DOWN(VK_LBUTTON)?2:0) + box_h * 0.75f - small_fs / 2.0f;
	TextOutShadow(x, y, text.c_str());
	
	text = sprintf2("%d CPS", GetCPS(1));
	x = box_gap + (KEY_DOWN(VK_RBUTTON)?2:0) + box_w + left + box_w / 2.0f - text.length() * small_fs / 4.0f - 3;
	y = top + (KEY_DOWN(VK_RBUTTON)?2:0) + box_h * 0.75f - small_fs / 2.0f;
	TextOutShadow(x, y, text.c_str());
	
	DeleteObject(hFont);
	SelectObject(hdcBuffer, prevObj);
	
	hFont = CreateFont(fs, 0, font);
	prevObj = SelectObject(hdcBuffer, hFont);
	SetTextColor(RainbowColor());
	SetBkMode(hdcBuffer, TRANSPARENT);
	
	text = "LMB";
	x = left + (KEY_DOWN(VK_LBUTTON)?2:0) + box_w / 2.0f - text.length() * fs / 4.0f - 4;
	y = top + (KEY_DOWN(VK_LBUTTON)?2:0) + box_h * 0.22f;
	TextOutShadow(x, y, text.c_str());
	
	text = "RMB";
	x = box_gap + (KEY_DOWN(VK_RBUTTON)?2:0) + box_w + left + box_w / 2.0f - text.length() * fs / 4.0f - 4;
	y = top + (KEY_DOWN(VK_RBUTTON)?2:0) + box_h * 0.22f;
	TextOutShadow(x, y, text.c_str());
	
	DeleteObject(hFont);
	SelectObject(hdcBuffer, prevObj);
}
void DrawKeyMouseInfo()
{
	static const int _left = 15;
	static const int _top = 40;
	static const int _pen_size = 2;
	
	static const int box_w = 54;
	static const int box_h = 54;
	static const int box_gap = 10;
	static const int fs = 24;
	
	COLORREF color = RainbowColor();
	HPEN hPen;
	hPen = CreatePen(PS_SOLID, _pen_size, color);
	SelectObject(hdcBuffer, hPen);
	
	DrawKeyBox('A', "A", fs, _left, _top + box_h + box_gap, _left + box_w, _top + box_h + box_gap + box_h);
	DrawKeyBox('W', "W", fs, _left + box_w + box_gap, _top, _left + box_w*2 + box_gap, _top + box_h);
	DrawKeyBox('S', "S", fs, _left + box_w + box_gap, _top + box_h + box_gap, _left + box_w*2 + box_gap, _top + box_h + box_gap + box_h);
	DrawKeyBox('D', "D", fs, _left + box_w * 2 + box_gap * 2, _top + box_h + box_gap, _left + box_w*3 + box_gap * 2, _top + box_h + box_gap + box_h);
	
	static const int space_h = 35;
	DrawKeyBox(' ', "--", fs, _left, _top + box_h*2 + box_gap*2, _left + box_w * 3 + box_gap * 2, _top + box_h*2+box_gap*2+space_h);
	DrawKeyBox(VK_SHIFT, "Shift", fs * 0.75, _left, _top + box_h*2 + box_gap*3 + space_h, _left + box_w * 3 + box_gap * 2, _top + box_h*2+box_gap*3+space_h*2);
	
	DrawMouseKeys(_left, _top + box_h*3 + box_gap*3 + space_h*2);
	
	DeleteObject(hPen);
}

void DrawUI()
{
	DrawKeyMouseInfo();
}

#define TIMER_PAINT_CD 10L
#define TIMER_UPDATE_CD 5L
VOID CALLBACK TimerProc_Paint(
	_In_  HWND hwnd,
	_In_  UINT uMsg,
	_In_  UINT_PTR idEvent,
	_In_  DWORD dwTime
	)
{
	RECT rect;
	GetClientRect(hwnd,&rect);
	InvalidateRect(hwnd, &rect, FALSE);	//会发送WM_PAINT消息
}
VOID CALLBACK TimerProc_Update(
	_In_  HWND hwnd,
	_In_  UINT uMsg,
	_In_  UINT_PTR idEvent,
	_In_  DWORD dwTime
	)
{
	UpdateCPS();
}
PAINTSTRUCT ps;
void BeginDraw()
{
	hdcOrigin = BeginPaint(hwnd, &ps);
	SetBkMode(hdcBuffer, TRANSPARENT);
}
void EndDraw()
{
	EndPaint(hwnd, &ps);
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam) 
{
	static HBITMAP hBitmap = NULL;
	
	switch(Message) 
	{
		case WM_CREATE:{
			hdcBuffer = CreateCompatibleDC(NULL);
			SetTimer(hwnd, 0, TIMER_PAINT_CD, TimerProc_Paint);
			SetTimer(hwnd, 2, TIMER_UPDATE_CD, TimerProc_Update);
			break;
		}
		case WM_DESTROY: {
			if (hdcBuffer)
				DeleteDC(hdcBuffer), hdcBuffer = nullptr;
			if (hBitmap)
				DeleteObject(hBitmap), hBitmap = nullptr;
			KillTimer(hwnd, 0);
			KillTimer(hwnd, 2);
			PostQuitMessage(0);
			break;
		}
		case WM_PAINT:{
			BeginDraw();
			
			// 获取客户区域的大小
			RECT rcClient;
			GetClientRect(hwnd, &rcClient);
			int clientWidth = rcClient.right - rcClient.left;
			int clientHeight = rcClient.bottom - rcClient.top;
			
			// 创建双缓冲
			if (hBitmap)
				DeleteObject(hBitmap);
			hBitmap = CreateCompatibleBitmap(hdcOrigin, clientWidth, clientHeight);
			SelectObject(hdcBuffer, hBitmap);
			
			ClearDevice();
			DrawUI();
			
			// 将缓冲区的内容一次性绘制到屏幕上
			BitBlt(hdcOrigin, 0, 0, clientWidth, clientHeight, hdcBuffer, 0, 0, SRCCOPY);
			EndDraw();
			break;
		}
	default:
		return DefWindowProc(hwnd, Message, wParam, lParam);
	}
	return 0;
}
/
bool TerminalCheck(DWORD dwPid, HWND _hwnd)
{	//检查是否为win11新终端
	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);	
	if (INVALID_HANDLE_VALUE == hSnapshot) 	
	{		
		return false;	
	}	
	PROCESSENTRY32 pe = { sizeof(pe) };	
	BOOL fOk;	
	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe)) 	
	{		
		if (! stricmp(pe.szExeFile, "WindowsTerminal.exe")
			&& pe.th32ProcessID == dwPid) 		
		{			
			CloseHandle(hSnapshot);			
			{
				char title[MAX_PATH];
				GetWindowText(_hwnd, title, MAX_PATH);
				if(strcmp(title, _pgmptr) && strcmp(title, "Keystrokes"))
					return false;
				return true;
			}		
		}	
	}	
	return false;
}
BOOL CALLBACK EnumWindowsProc(HWND _hwnd, LPARAM lParam)
{
	DWORD pid;
	GetWindowThreadProcessId(_hwnd, &pid);
	if(TerminalCheck(pid, _hwnd))
	{
		hwnd_console = _hwnd;
		return FALSE;
	}
	return TRUE;
}
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	_hInstance = hInstance;
	_hPrevInstance = hPrevInstance;
	_lpCmdLine = lpCmdLine;
	_nShowCmd = nShowCmd;
	
	scr_w = GetScreenWidth();
	scr_h = GetScreenHeight();
	taskbar_h = GetTaskbarHeight();
	
	WNDCLASS wc = { 0 };
	wc.lpfnWndProc = WndProc;
	wc.hInstance = hInstance;
	wc.lpszClassName = "KeyStrokesWindowClass";
	
	if(!RegisterClass(&wc)) {
		MessageBox(NULL, "Window Registration Failed!","Error!",MB_ICONEXCLAMATION|MB_OK);
		return 0;
	}
	
	hwnd = CreateWindowEx(WS_EX_LAYERED | WS_EX_TRANSPARENT | WS_EX_TOPMOST, 
		"KeyStrokesWindowClass", "KeyStrokes by Wormwaker", WS_POPUP,
		0, /* x */
		0, /* y */
		scr_w, /* width */
		scr_h, /* height */
		NULL,
		//		NULL,
		NULL,hInstance,NULL);
	
	if(hwnd == NULL) {
		MessageBox(NULL, "Window Creation Failed!","Error!",MB_ICONEXCLAMATION|MB_OK);
		return 0;
	}
	SetConsoleTitle("Keystrokes");
	if(ExistProcess("WindowsTerminal.exe"))
	{	//win11电脑且使用新版终端
		EnumWindows(EnumWindowsProc, 0);
	}else{	//旧版控制台主机
		hwnd_console = GetConsoleWindow();
	}
#ifndef SHOWCONSOLE
	if(hwnd_console != INVALID_HANDLE_VALUE && hwnd_console != nullptr)
		ShowWindow(hwnd_console, SW_HIDE);
#endif
	// 设置窗口透明度
	SetLayeredWindowAttributes(hwnd, RGB(0, 0, 0), 0, LWA_COLORKEY);
	ShowWindow(hwnd, SW_SHOWMAXIMIZED);
	SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, scr_w,scr_h, SWP_NOSIZE);
	MSG msg;
	
	while(GetMessage(&msg, NULL, 0, 0) > 0) { /* If no error is received... */
		TranslateMessage(&msg); /* Translate key codes to chars if present */
		DispatchMessage(&msg); /* Send it to WndProc */
		ShowWindowAsync(hwnd, SW_SHOWMAXIMIZED); //保持显示并最大化
	}
	
	return 0;
}

到了这里，关于C++ 实现游戏（例如MC）键位显示的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • win系统搭建Minecraft世界服务器，MC开服教程，小白开服教程

    win系统搭建Minecraft世界服务器，MC开服教程，小白开服教程

    Windows系统搭建我的世界世界服务器，Minecraft开服教程，小白开服教程，MC 1.19.4版本服务器搭建教程。 此教程使用 Mohist 1.19.4 服务端，此服务端支持Forge模组和Bukkit/Spigot/Paper插件，如果需要开其他服务端也可参考此教程，操作流程差不多。 Mohist是一个出色的Minecraft Forge服务器

    2024年01月23日
    浏览(88)
  • 内网穿透实战应用-windwos10系统搭建我的世界服务器，内网穿透实现联机游戏Minecraft

    内网穿透实战应用-windwos10系统搭建我的世界服务器，内网穿透实现联机游戏Minecraft

    今天和大家分享一下只需简单几步即可在windwos系统搭建我的世界服务器，并通过cpolar内网穿透工具将本地服务暴露到公网连接，实现与小伙伴一起联机游戏。 以windows10系统为例，配置java环境，搭建我的世界服务器,下载最新版java版本 https://www.oracle.com/java/technologies/downloads/

    2024年02月11日
    浏览(50)
  • 无需公网IP，使用MCSM面板一键搭建我的世界Minecraft服务器联机游戏

    无需公网IP，使用MCSM面板一键搭建我的世界Minecraft服务器联机游戏

    MCSManager是一个开源、分布式、轻量级、一键开服、支持大部分游戏服务端和控制台程序的管理工具，我们可以用它来一键部署搭建Minecraft我的世界服务器，跟小伙伴们联机。 现在一般家庭局域网宽带没有公网IP，不在同个局域网下的小伙伴没办法直接联机。所以我们在这个教

    2024年02月05日
    浏览(51)
  • MC我的世界Windows安装forge服务器教程（一）

    MC我的世界Windows安装forge服务器教程（一）

    目录 一、前置环境搭建 1.配置安全组 2.配置阿里云网络源 3.安装JAVA17 二、安装Minecraft服务端 三、整合包补充 高校计划 - 免费学生云服务器 未参与过高校学生免费领取ECS活动的用户，通过学生身份认证及续费任务，最多可领取1+6个月免费ECS资源。 手动添加25565端口用于连接

    2024年02月14日
    浏览(46)
  • UE4 中可全局获取的变量（例如游戏实例、玩家控制器等） 详解

    UE4 中可全局获取的变量（例如游戏实例、玩家控制器等） 详解

    🙋‍♂️ 作者：海码007 📜 专栏：UE虚幻引擎专栏 💥 标题：UE4 中可全局获取的变量（例如游戏实例、玩家控制器、游戏模式等） 详解 ❣️ 寄语：加油，一次专注一件事！ 🎈 最后： 文章作者技术和水平有限，如果文中出现错误，希望大家能指正，同时有问题的话，欢迎

    2024年02月06日
    浏览(113)

  • c++游戏小技巧9：windows.h 句柄介绍+实例

    目录 1.前言 2.正文 1.COORD(结构体) 2.HANDLE（句柄） 3.HWND（句柄） 4.RECT（结构体） 5.CONSOLE_SCREEN_BUFFER_INFO（结构体） 6.point（结构体） 7.代码实例(四个) 1.键鼠操作 2.获得运行框相关信息 3.遍历windows全部可见窗体(执行结果应坤而异) 4.移动运行框 3.后文 (关于MFC的事情我在鸽一段

    2024年02月03日
    浏览(41)
  • 用python实现Minecraft

    用python实现Minecraft

    你有没有想过用python制作一个Minecraft?在github上就有这样一个python程序（链接：https://github.com/zifan-wang/Minecraft.git）,玩起来还像模像样的： 在游戏的文件夹中共有这些文件： 代码：（如有需要可复制，不需要可直接跳过） 一共800多行代码，是程序的主要文件 在这个开源的程序

    2024年02月08日
    浏览(34)
  • 在Windows第一次使用使用vcpkg来安装三方库，例如nanomsg、nng、libpqxx

    在Windows第一次使用使用vcpkg来安装三方库，例如nanomsg、nng、libpqxx

    够早了吧 需要从github上找三方库来使用，看了许多教程后决定为后来者写点简单的流程。记得先装git，安装git教程如下： 到官网下载git添加链接描述 点击下载然后安装。 安装完后会有一系列的应用可以使用 我们主要用的是Git Bash。 vcpkg是微软的包管理工具，可以直接下载三

    2023年04月20日
    浏览(52)
  • linux 下 C++ 与三菱PLC 通过MC Qna3E 二进制 协议进行交互

    linux 下 C++ 与三菱PLC 通过MC Qna3E 二进制 协议进行交互

    西门子plc 有snap7库 进行交互，并且支持c++ 而且跨平台。但是三菱系列PLC并没有现成的开源项目，没办法只能自己拼接，我这里实现了MC 协议 Qna3E 帧，并使用二进制进行交互。 可利用 这个工具进行测试：  协议参考： https://www.jianshu.com/p/ca7f1609c8c1

    2024年02月09日
    浏览(53)
  • C++实战：实现生命游戏

    C++实战：实现生命游戏

    ​ 在C++中实现康威生命游戏是一项结合了算法设计、数据结构和用户交互的实战编程任务。首先，定义一个名为 Life 的类来存储游戏状态，其中包含一个二维数组用于表示细胞网格，并实现初始化（initialize）、打印当前状态（print）以及根据规则更新状态到下一代（update）的

    2024年01月21日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包