Skip to content

Y
YGOMobile
Commit eb028f4b authored by fallenstardust's avatar fallenstardust
Browse files
Options

sync ocgcore 

添加注释game
parent 039c168a
Show whitespace changes
Inline Side-by-side
Showing with 456 additions and 192 deletions
Classes/gframe/game.cpp
View file @ eb028f4b
......@@ -12,7 +12,7 @@
#include <thread>
#include <string>
#include <regex>
#ifdef _IRR_ANDROID_PLATFORM_
#include <android/CAndroidGUIEditBox.h>
#include <android/CAndroidGUIComboBox.h>
#include <android/CAndroidGUISkin.h>
......@@ -21,13 +21,22 @@
#include <COGLESExtensionHandler.h>
#include <COGLES2Driver.h>
#include <COGLESDriver.h>
#endif
namespace ygo {
Game* mainGame;
/**
* @brief 清空决斗信息结构体中的所有数据
*
* 该函数将DuelInfo结构体中的所有成员变量重置为初始状态，
* 包括决斗状态标志、玩家生命值、回合信息、时间限制等。
*
* @param this 指向DuelInfo对象的指针
* @return 无返回值
*/
void DuelInfo::Clear() {
// 重置决斗状态标志
isStarted = false;
isInDuel = false;
isFinished = false;
......@@ -40,18 +49,26 @@ void DuelInfo::Clear() {
tag_player[0] = false;
tag_player[1] = false;
isReplaySwapped = false;
// 重置生命值相关数据
lp[0] = 0;
lp[1] = 0;
start_lp = 0;
// 重置决斗规则和回合信息
duel_rule = 0;
turn = 0;
curMsg = 0;
// 清空主机名和客户端名称
hostname[0] = 0;
clientname[0] = 0;
hostname_tag[0] = 0;
clientname_tag[0] = 0;
strLP[0][0] = 0;
strLP[1][0] = 0;
// 重置玩家类型和时间限制
player_type = 0;
time_player = 0;
time_limit = 0;
......@@ -59,10 +76,20 @@ void DuelInfo::Clear() {
time_left[1] = 0;
}
/**
* @brief 处理游戏事件
* @param event 输入事件引用，包含鼠标或键盘等输入信息
*
* 该函数主要用于处理鼠标输入事件，对鼠标的坐标进行优化处理。
* 当事件类型为鼠标输入时，会获取当前鼠标坐标并调用optX和optY函数
* 对坐标进行转换或优化，然后更新鼠标输入事件中的坐标值。
*/
void Game::process(irr::SEvent &event) {
// 检查事件类型是否为鼠标输入事件
if (event.EventType == irr::EET_MOUSE_INPUT_EVENT) {
irr::s32 x = event.MouseInput.X;
irr::s32 y = event.MouseInput.Y;
// 对鼠标坐标进行优化处理并更新事件中的坐标值
event.MouseInput.X = optX(x);
event.MouseInput.Y = optY(y);
}
......@@ -135,59 +162,85 @@ bool IsExtension(const char* filename, const char* extension) {
}
bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
// 保存应用程序句柄
this->appMain = app;
// 初始化随机数种子
srand(time(0));
// 创建Irrlicht引擎参数结构体
irr::SIrrlichtCreationParameters params{};
// 获取OpenGL版本设置
glversion = options->getOpenglVersion();
// 根据OpenGL版本选择渲染驱动类型
if (glversion == 0) {
params.DriverType = irr::video::EDT_OGLES1;
} else{
params.DriverType = irr::video::EDT_OGLES2;
}
// 设置应用程序私有数据
params.PrivateData = app;
// 设置颜色深度为24位
params.Bits = 24;
// 设置Z缓冲区深度为16位
params.ZBufferBits = 16;
params.AntiAlias = 0;
// 关闭抗锯齿
params.AntiAlias = 1;
// 设置窗口大小为自适应
params.WindowSize = irr::core::dimension2d<irr::u32>(0, 0);
// 创建Irrlicht设备实例
device = irr::createDeviceEx(params);
// 检查设备创建是否成功
if(!device) {
ErrorLog("Failed to create Irrlicht Engine device!");
return false;
}
// 执行Android平台特定的初始化技巧
if (!irr::android::perfromTrick(app)) {
return false;
}
// 初始化Java桥接并获取应用位置信息
irr::core::vector2di appPosition = irr::android::initJavaBridge(app, device);
// 设置位置修正参数
setPositionFix(appPosition);
// 设置进程接收器
device->setProcessReceiver(this);
// 设置输入事件处理函数
app->onInputEvent = irr::android::handleInput;
// 获取日志记录器
irr::ILogger* logger = device->getLogger();
// logger->setLogLevel(ELL_WARNING);
// 检查是否启用钟摆刻度显示
isPSEnabled = options->isPendulumScaleEnabled();
// 获取文件系统并设置给数据管理器
dataManager.FileSystem = device->getFileSystem();
// 设置应用命令回调函数
((irr::CIrrDeviceAndroid*)device)->onAppCmd = onHandleAndroidCommand;
// 获取屏幕缩放比例
xScale = irr::android::getXScale(app);
yScale = irr::android::getYScale(app);
ALOGD("cc game: xScale = %f, yScale = %f", xScale, yScale);
SetCardS3DVertex();//reset cardfront cardback S3DVertex size
//io::path databaseDir = options->getDBDir();
// 重置卡片顶点数据大小
SetCardS3DVertex();
// 获取工作目录路径
irr::io::path workingDir = options->getWorkDir();
ALOGD("cc game: workingDir= %s", workingDir.c_str());
// 更改工作目录
dataManager.FileSystem->changeWorkingDirectoryTo(workingDir);
/* Your media must be somewhere inside the assets folder. The assets folder is the root for the file system.
This example copies the media in the Android.mk makefile. */
// 定义媒体资源路径
irr::core::stringc mediaPath = "media/";
// The Android assets file-system does not know which sub-directories it has (blame google).
// So we have to add all sub-directories in assets manually. Otherwise we could still open the files,
// but existFile checks will fail (which are for example needed by getFont).
// 遍历文件档案，为Android资产文件系统添加目录列表
for ( irr::u32 i=0; i < dataManager.FileSystem->getFileArchiveCount(); ++i )
{
IFileArchive* archive = dataManager.FileSystem->getFileArchive(i);
......@@ -197,11 +250,12 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
break;
}
}
//pics.zip, scripts.zip, ...zip
// 加载ZIP压缩包资源
irr::io::path* zips = options->getArchiveFiles();
int len = options->getArchiveCount();
for(int i=0;i<len;i++){
irr::io::path zip_path = zips[i];
// 添加文件档案
if(dataManager.FileSystem->addFileArchive(zip_path.c_str(), false, false, EFAT_ZIP)) {
ALOGD("cc game: add arrchive ok:%s", zip_path.c_str());
}else{
......@@ -209,7 +263,9 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
}
}
// 加载配置文件
LoadConfig();
// 初始化各种游戏状态变量
linePatternD3D = 0;
linePatternGL = 0x0f0f;
waitFrame = 0;
......@@ -223,15 +279,19 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
is_building = false;
menuHandler.prev_operation = 0;
menuHandler.prev_sel = -1;
// 获取视频驱动和场景管理器
driver = device->getVideoDriver();
#ifdef _IRR_ANDROID_PLATFORM_
// 获取卡片质量设置
int quality = options->getCardQualityOp();
// 检查是否支持非2次幂纹理
if (driver->getDriverType() == irr::video::EDT_OGLES2) {
isNPOTSupported = ((irr::video::COGLES2Driver *) driver)->queryOpenGLFeature(irr::video::COGLES2ExtensionHandler::IRR_OES_texture_npot);
} else {
isNPOTSupported = ((irr::video::COGLES1Driver *) driver)->queryOpenGLFeature(irr::video::COGLES1ExtensionHandler::IRR_OES_texture_npot);
}
ALOGD("cc game: isNPOTSupported = %d", isNPOTSupported);
// 根据纹理支持情况设置纹理创建标志
if (isNPOTSupported) {
if (quality == 1) {
driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS, false);
......@@ -242,30 +302,33 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
driver->setTextureCreationFlag(irr::video::ETCF_ALLOW_NON_POWER_2, true);
driver->setTextureCreationFlag(irr::video::ETCF_CREATE_MIP_MAPS, false);
}
#endif
// 设置纹理优化质量标志
driver->setTextureCreationFlag(irr::video::ETCF_OPTIMIZED_FOR_QUALITY, true);
// 初始化图像管理器
imageManager.SetDevice(device);
imageManager.ClearTexture();
// 初始化图像资源
if(!imageManager.Initial(workingDir)) {
ErrorLog("Failed to load textures!");
return false;
}
// LoadExpansions only load zips, the other cdb databases are still loaded by getDBFiles
// 加载数据库文件
irr::io::path* cdbs = options->getDBFiles();
len = options->getDbCount();
//os::Printer::log("load cdbs count %d", len);
for(int i=0;i<len;i++){
irr::io::path cdb_path = cdbs[i];
wchar_t wpath[1024];
// 解码UTF8路径
BufferIO::DecodeUTF8(cdb_path.c_str(), wpath);
// 加载数据库
if(dataManager.LoadDB(wpath)) {
ALOGD("cc game: add cdb ok:%s", cdb_path.c_str());
}else{
ALOGW("cc game: add cdb fail:%s", cdb_path.c_str());
}
}
//if(!dataManager.LoadDB(workingDir.append("/cards.cdb").c_str()))
// return false;
// 加载字符串配置文件
if(dataManager.LoadStrings((workingDir + path("/expansions/strings.conf")).c_str())){
ALOGD("cc game: loadStrings expansions/strings.conf");
}
......@@ -273,27 +336,38 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
ErrorLog("Failed to load strings!");
return false;
}
// 加载扩展卡包
LoadExpansions();
// 加载禁限卡表
deckManager.LoadLFList(options);
// 获取GUI环境
env = device->getGUIEnvironment();
// 检查是否启用字体抗锯齿
bool isAntialias = options->isFontAntiAliasEnabled();
// 创建各种字体
numFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.numfont, 18 * yScale, isAntialias, false);
adFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.numfont, 12 * yScale, isAntialias, false);
lpcFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.numfont, 48 * yScale, isAntialias, true);
guiFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.textfont, 18 * yScale, isAntialias, true);
titleFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.textfont, 32 * yScale, isAntialias, true);
textFont = irr::gui::CGUITTFont::createTTFont(env, gameConf.textfont, (int)gameConf.textfontsize * yScale, isAntialias, true);
// 检查字体创建是否成功
if(!numFont || !guiFont) {
ALOGW("cc game: add font fail ");
}
// 获取场景管理器
smgr = device->getSceneManager();
// 设置窗口标题
device->setWindowCaption(L"[---]");
// 禁止窗口大小调整
device->setResizable(false);
// 创建并设置新的GUI皮肤
irr::gui::IGUISkin* newskin = irr::gui::CAndroidGUISkin::createAndroidSkin(irr::gui::EGST_BURNING_SKIN, driver, env, xScale, yScale);
newskin->setFont(guiFont);
env->setSkin(newskin);
// 释放皮肤资源
newskin->drop();
#ifdef _IRR_ANDROID_PLATFORM_
//main menu
wMainMenu = env->addWindow(Resize(450, 40, 900, 600), false, L"");
wMainMenu->getCloseButton()->setVisible(false);
......@@ -772,7 +846,7 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
scrOption->setLargeStep(1);
scrOption->setSmallStep(1);
scrOption->setMin(0);
#endif
//pos select
wPosSelect = env->addWindow(irr::core::recti(660 * xScale - 223 * yScale, 160 * yScale, 660 * xScale + 223 * yScale, (160 + 228) * yScale), false, dataManager.GetSysString(561));
wPosSelect->getCloseButton()->setVisible(false);
......@@ -790,7 +864,7 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
btnPSDD->setImageSize(irr::core::dimension2di(CARD_IMG_WIDTH * 0.6f * yScale, CARD_IMG_HEIGHT * 0.6f * yScale));
btnPSDD->setImageRotation(270);
btnPSDD->setImage(imageManager.tCover[0]);//show cover of player1
#ifdef _IRR_ANDROID_PLATFORM_
//card select
wCardSelect = env->addWindow(irr::core::recti(660 * xScale - 340 * yScale, 55 * yScale, 660 * xScale + 340 * yScale, 400 * yScale), false, L"");
wCardSelect->getCloseButton()->setVisible(false);
......@@ -825,7 +899,7 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
scrDisplayList = env->addScrollBar(true, Resize_Y(30, 245, 30 + 620, 285), wCardDisplay, SCROLL_CARD_DISPLAY);
btnDisplayOK = env->addButton(Resize_Y(340 - 55, 295, 340 + 55, 335), wCardDisplay, BUTTON_CARD_DISP_OK, dataManager.GetSysString(1211));
ChangeToIGUIImageButton(btnDisplayOK, imageManager.tButton_S, imageManager.tButton_S_pressed);
#endif
//announce number
wANNumber = env->addWindow(Resize(500, 50, 800, 470), false, L"");
wANNumber->getCloseButton()->setVisible(false);
......@@ -1012,7 +1086,7 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
for(int i = 1370; i <= 1373; i++)
cbSortType->addItem(dataManager.GetSysString(i));
wSort->setVisible(false);
#ifdef _IRR_ANDROID_PLATFORM_
//filters
wFilter = env->addWindow(Resize(610, 1, 1020, 130), false, L"");
wFilter->getCloseButton()->setVisible(false);
......@@ -1089,9 +1163,7 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
scrFilter->setLargeStep(10);
scrFilter->setSmallStep(1);
scrFilter->setVisible(false);
#endif
#ifdef _IRR_ANDROID_PLATFORM_
//LINK MARKER SEARCH
btnMarksFilter = env->addButton(Resize(60, 80 + 125 / 6, 190, 100 + 125 / 6), wFilter, BUTTON_MARKS_FILTER, dataManager.GetSysString(1374));
ChangeToIGUIImageButton(btnMarksFilter, imageManager.tButton_L, imageManager.tButton_L_pressed);
......@@ -1283,7 +1355,7 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
chkMusicMode->setEnabled(false);
chkMusicMode->setVisible(false);
}
#endif
//big picture
wBigCard = env->addWindow(Resize(0, 0, 0, 0), false, L"");
wBigCard->getCloseButton()->setVisible(false);
......@@ -1325,112 +1397,167 @@ bool Game::Initialize(ANDROID_APP app, irr::android::InitOptions *options) {
col.setAlpha(200);
env->getSkin()->setColor((irr::gui::EGUI_DEFAULT_COLOR)i, col);
}
#ifdef _IRR_ANDROID_PLATFORM_
irr::gui::IGUIStaticText *text = env->addStaticText(L"", Resize(1,1,100,45), false, false, 0, GUI_INFO_FPS);
#endif
irr::gui::IGUIStaticText *text = env->addStaticText(L"", Resize(1,1,100,45), false, false, 0, GUI_INFO_FPS);
hideChat = false;
hideChatTimer = 0;
return true;
}//bool Game::Initialize
/**
* @brief 游戏主循环函数，负责渲染游戏画面、处理输入事件以及更新逻辑状态。
*
* 此函数初始化摄像机、设置投影矩阵与视图矩阵，并根据平台加载对应的着色器材质。
* 在主循环中进行场景绘制、界面刷新、音频播放等操作，并控制帧率和时间显示。
* 同时支持多线程同步机制（如互斥锁）以确保数据安全访问。
*/
void Game::MainLoop() {
wchar_t cap[256];
wchar_t cap[256]; // 字符缓冲区，用于临时存储宽字符文本
// 添加一个摄像机节点到场景管理器
camera = smgr->addCameraSceneNode(0);
// 构建并设置自定义的投影矩阵
irr::core::matrix4 mProjection;
BuildProjectionMatrix(mProjection, -0.90f, 0.45f, -0.42f, 0.42f, 1.0f, 100.0f);
camera->setProjectionMatrix(mProjection);
mProjection.buildCameraLookAtMatrixLH(irr::core::vector3df(4.2f, 8.0f, 7.8f), irr::core::vector3df(4.2f, 0, 0), irr::core::vector3df(0, 0, 1));
// 设置摄像机视角变换矩阵（LookAt）
mProjection.buildCameraLookAtMatrixLH(
irr::core::vector3df(4.2f, 8.0f, 7.8f), // 摄像机位置
irr::core::vector3df(4.2f, 0, 0), // 观察目标点
irr::core::vector3df(0, 0, 1) // 上方向向量
);
camera->setViewMatrixAffector(mProjection);
// 设置环境光颜色为白色
smgr->setAmbientLight(irr::video::SColorf(1.0f, 1.0f, 1.0f));
float atkframe = 0.1f;
float atkframe = 0.1f; // 动画帧计数器初始值
// 获取设备定时器并重置时间为0
irr::ITimer* timer = device->getTimer();
timer->setTime(0);
// get FPS
irr::gui::IGUIElement *stat = device->getGUIEnvironment()->getRootGUIElement()->getElementFromId ( GUI_INFO_FPS );
int fps = 0;
int cur_time = 0;
#if defined(_IRR_ANDROID_PLATFORM_)
// 获取GUI中的FPS信息控件
irr::gui::IGUIElement *stat = device->getGUIEnvironment()->getRootGUIElement()->getElementFromId(GUI_INFO_FPS);
int fps = 0; // 当前秒内已渲染帧数
int cur_time = 0; // 定时器当前时间戳
// 初始化OpenGL ES 2.0材质类型变量
ogles2Solid = 0;
ogles2TrasparentAlpha = 0;
ogles2BlendTexture = 0;
// 根据GL版本选择是否使用内置或外部着色器文件
if (glversion == 0 || glversion == 2) {
ogles2Solid = irr::video::EMT_SOLID;
ogles2TrasparentAlpha = irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL;
ogles2BlendTexture = irr::video::EMT_ONETEXTURE_BLEND;
} else {
// 着色器文件路径配置
irr::io::path solidvsFileName = "media/ogles2customsolid.frag";
irr::io::path TACvsFileName = "media/ogles2customTAC.frag";
irr::io::path blendvsFileName = "media/ogles2customblend.frag";
irr::io::path psFileName = "media/ogles2custom.vert";
// 检查硬件是否支持像素着色器
if (!driver->queryFeature(irr::video::EVDF_PIXEL_SHADER_1_1) &&
!driver->queryFeature(irr::video::EVDF_ARB_FRAGMENT_PROGRAM_1))
{
ALOGD("cc game: WARNING: Pixel shaders disabled "
"because of missing driver/hardware support.");
!driver->queryFeature(irr::video::EVDF_ARB_FRAGMENT_PROGRAM_1)) {
ALOGD("cc game: WARNING: Pixel shaders disabled because of missing driver/hardware support.");
psFileName = "";
}
// 检查硬件是否支持顶点着色器
if (!driver->queryFeature(irr::video::EVDF_VERTEX_SHADER_1_1) &&
!driver->queryFeature(irr::video::EVDF_ARB_VERTEX_PROGRAM_1))
{
ALOGD("cc game: WARNING: Vertex shaders disabled "
"because of missing driver/hardware support.");
!driver->queryFeature(irr::video::EVDF_ARB_VERTEX_PROGRAM_1)) {
ALOGD("cc game: WARNING: Vertex shaders disabled because of missing driver/hardware support.");
solidvsFileName = "";
TACvsFileName = "";
blendvsFileName = "";
}
// 加载高级着色器程序
irr::video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();
if (gpu) {
const irr::video::E_GPU_SHADING_LANGUAGE shadingLanguage = irr::video::EGSL_DEFAULT;
ogles2Solid = gpu->addHighLevelShaderMaterialFromFiles(
psFileName, "vertexMain", irr::video::EVST_VS_1_1,
solidvsFileName, "pixelMain", irr::video::EPST_PS_1_1,
&customShadersCallback, irr::video::EMT_SOLID, 0, shadingLanguage);
ogles2TrasparentAlpha = gpu->addHighLevelShaderMaterialFromFiles(
psFileName, "vertexMain", irr::video::EVST_VS_1_1,
TACvsFileName, "pixelMain", irr::video::EPST_PS_1_1,
&customShadersCallback, irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL, 0 , shadingLanguage);
&customShadersCallback, irr::video::EMT_TRANSPARENT_ALPHA_CHANNEL, 0, shadingLanguage);
ogles2BlendTexture = gpu->addHighLevelShaderMaterialFromFiles(
psFileName, "vertexMain", irr::video::EVST_VS_1_1,
blendvsFileName, "pixelMain", irr::video::EPST_PS_1_1,
&customShadersCallback, irr::video::EMT_ONETEXTURE_BLEND, 0 , shadingLanguage);
&customShadersCallback, irr::video::EMT_ONETEXTURE_BLEND, 0, shadingLanguage);
ALOGD("cc game:ogles2Sold = %d", ogles2Solid);
ALOGD("cc game:ogles2BlendTexture = %d", ogles2BlendTexture);
ALOGD("cc game:ogles2TrasparentAlpha = %d", ogles2TrasparentAlpha);
}
}
// 将着色器材质应用至各个材质对象
// 设置卡片正面材质类型为混合纹理着色器
matManager.mCard.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2BlendTexture;
// 设置纹理材质类型为透明alpha通道着色器
matManager.mTexture.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2TrasparentAlpha;
// 设置背景线条材质类型为混合纹理着色器
matManager.mBackLine.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2BlendTexture;
// 设置选择区域材质类型为混合纹理着色器
matManager.mSelField.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2BlendTexture;
// 设置轮廓线材质类型为纯色着色器
matManager.mOutLine.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2Solid;
// 设置透明纹理材质类型为透明alpha通道着色器
matManager.mTRTexture.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2TrasparentAlpha;
// 设置攻击指示器材质类型为混合纹理着色器
matManager.mATK.MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2BlendTexture;
// 若不支持非幂次纹理尺寸，则设置纹理环绕模式为边缘夹紧
if (!isNPOTSupported) {
// 当不支持非2次幂纹理时，设置各个材质的纹理环绕模式为边缘夹紧(CLAMP_TO_EDGE)
// 卡片正面材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mCard.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mCard.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
// 纹理材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mTexture.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mTexture.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
// 背景线条材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mBackLine.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mBackLine.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
// 选择区域材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mSelField.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mSelField.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
// 轮廓线材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mOutLine.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mOutLine.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
// 透明纹理材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mTRTexture.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mTRTexture.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
// 攻击指示器材质的U轴和V轴纹理环绕模式设为边缘夹紧
matManager.mATK.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
matManager.mATK.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP_TO_EDGE;
}
#endif
// 主循环开始：持续运行直到窗口关闭
while(device->run()) {
//ALOGV("cc game draw frame");
linePatternD3D = (linePatternD3D + 1) % 30;
linePatternGL = (linePatternGL << 1) | (linePatternGL >> 15);
atkframe += 0.1f;
atkdy = (float)sin(atkframe);
linePatternD3D = (linePatternD3D + 1) % 30; // 更新线条图案索引（Direct3D风格）
linePatternGL = (linePatternGL << 1) | (linePatternGL >> 15); // 更新线条图案掩码（OpenGL风格）
atkframe += 0.1f; // 增加动画帧计数
atkdy = (float)sin(atkframe); // 计算攻击动作偏移量
// 开始渲染场景
driver->beginScene(true, true, irr::video::SColor(0, 0, 0, 0));
#ifdef _IRR_ANDROID_PLATFORM_
// 设置2D材质并启用2D渲染
driver->getMaterial2D().MaterialType = (irr::video::E_MATERIAL_TYPE)ogles2Solid;
if (!isNPOTSupported) {
driver->getMaterial2D().TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP_TO_EDGE;
......@@ -1438,88 +1565,121 @@ void Game::MainLoop() {
}
driver->enableMaterial2D(true);
driver->getMaterial2D().ZBuffer = irr::video::ECFN_NEVER;
// 绘制背景图像
if(imageManager.tBackGround) {
driver->draw2DImage(imageManager.tBackGround, Resize(0, 0, GAME_WIDTH, GAME_HEIGHT), irr::core::recti(0, 0, imageManager.tBackGround->getOriginalSize().Width, imageManager.tBackGround->getOriginalSize().Height));
driver->draw2DImage(imageManager.tBackGround, Resize(0, 0, GAME_WIDTH, GAME_HEIGHT),
irr::core::recti(0, 0, imageManager.tBackGround->getOriginalSize().Width,
imageManager.tBackGround->getOriginalSize().Height));
}
if(imageManager.tBackGround_menu) {
driver->draw2DImage(imageManager.tBackGround_menu, Resize(0, 0, GAME_WIDTH, GAME_HEIGHT), irr::core::recti(0, 0, imageManager.tBackGround->getOriginalSize().Width, imageManager.tBackGround->getOriginalSize().Height));
driver->draw2DImage(imageManager.tBackGround_menu, Resize(0, 0, GAME_WIDTH, GAME_HEIGHT),
irr::core::recti(0, 0, imageManager.tBackGround->getOriginalSize().Width,
imageManager.tBackGround->getOriginalSize().Height));
}
if(imageManager.tBackGround_deck) {
driver->draw2DImage(imageManager.tBackGround_deck, Resize(0, 0, GAME_WIDTH, GAME_HEIGHT), irr::core::recti(0, 0, imageManager.tBackGround->getOriginalSize().Width, imageManager.tBackGround->getOriginalSize().Height));
driver->draw2DImage(imageManager.tBackGround_deck, Resize(0, 0, GAME_WIDTH, GAME_HEIGHT),
irr::core::recti(0, 0, imageManager.tBackGround->getOriginalSize().Width,
imageManager.tBackGround->getOriginalSize().Height));
}
driver->enableMaterial2D(false);
// 多线程保护：锁定互斥锁防止并发修改共享资源
gMutex.lock();
// 根据不同状态绘制对应内容
if(dInfo.isStarted) {
DrawBackImage(imageManager.tBackGround);
DrawBackGround();
DrawCards();
DrawMisc();
smgr->drawAll();
DrawBackImage(imageManager.tBackGround); // 背景图片
DrawBackGround(); // 场地背景
DrawCards(); // 所有卡牌
DrawMisc(); // 其他元素
smgr->drawAll(); // 渲染所有3D场景节点
driver->setMaterial(irr::video::IdentityMaterial);
driver->clearZBuffer();
driver->clearZBuffer(); // 清除深度缓存
} else if(is_building) {
DrawBackImage(imageManager.tBackGround_deck);
DrawBackImage(imageManager.tBackGround_deck); // 牌组编辑界面背景
driver->enableMaterial2D(true);
DrawDeckBd();
DrawDeckBd(); // 绘制牌组边框
driver->enableMaterial2D(false);
} else {
DrawBackImage(imageManager.tBackGround_menu);
DrawBackImage(imageManager.tBackGround_menu); // 菜单界面背景
}
// 绘制用户界面及特殊效果
driver->enableMaterial2D(true);
DrawGUI();
DrawSpec();
DrawGUI(); // UI组件
DrawSpec(); // 特效相关
driver->enableMaterial2D(false);
gMutex.unlock();
playBGM();
gMutex.unlock(); // 解锁互斥锁
playBGM(); // 播放背景音乐
// 控制信号帧倒计时
if(signalFrame > 0) {
signalFrame--;
if(!signalFrame)
frameSignal.Set();
frameSignal.Set(); // 发送信号通知其他线程
}
// 显示等待提示消息
if(waitFrame >= 0) {
waitFrame++;
if(waitFrame % 90 == 0) {
stHintMsg->setText(dataManager.GetSysString(1390));
stHintMsg->setText(dataManager.GetSysString(1390)); // 提示文字1
} else if(waitFrame % 90 == 30) {
stHintMsg->setText(dataManager.GetSysString(1391));
stHintMsg->setText(dataManager.GetSysString(1391)); // 提示文字2
} else if(waitFrame % 90 == 60) {
stHintMsg->setText(dataManager.GetSysString(1392));
stHintMsg->setText(dataManager.GetSysString(1392)); // 提示文字3
}
}
driver->endScene();
driver->endScene(); // 结束渲染过程
// 检查是否需要退出对战窗口
if(closeSignal.Wait(1))
CloseDuelWindow();
fps++;
cur_time = timer->getTime();
fps++; // 帧计数增加
cur_time = timer->getTime(); // 获取当前时间
// 控制帧率为约60FPS（每帧最大延迟20毫秒）
if(cur_time < fps * 17 - 20)
std::this_thread::sleep_for(std::chrono::milliseconds(20));
// 每秒钟更新一次FPS显示和剩余时间
if(cur_time >= 1000) {
if ( stat ) {
if(stat) {
irr::core::stringw str = L"FPS: ";
str += (irr::s32)device->getVideoDriver()->getFPS();
stat->setText ( str.c_str() );
stat->setText(str.c_str());
}
fps = 0;
cur_time -= 1000;
timer->setTime(0);
// 更新玩家剩余时间
if(dInfo.time_player == 0 || dInfo.time_player == 1)
if(dInfo.time_left[dInfo.time_player]) {
dInfo.time_left[dInfo.time_player]--;
RefreshTimeDisplay();
}
}
device->yield(); // probably nicer to the battery
#endif
device->yield(); // 礼让CPU，节省电池电量
}
// 游戏结束后的清理工作
DuelClient::StopClient(true);
if(dInfo.isSingleMode)
SingleMode::StopPlay(true);
usleep(500000);
usleep(500000); // 等待半秒后保存配置
SaveConfig();
usleep(500000);
usleep(500000); // 再等待半秒后释放设备资源
device->drop();
}
void Game::RefreshTimeDisplay() {
for(int i = 0; i < 2; ++i) {
if(dInfo.time_left[i] && dInfo.time_limit) {
......@@ -1611,7 +1771,6 @@ std::wstring Game::SetStaticText(irr::gui::IGUIStaticText* pControl, irr::u32 cW
}
void Game::LoadExpansions() {
// TODO: get isUseExtraCards
#ifdef _IRR_ANDROID_PLATFORM_
DIR * dir;
struct dirent * dirp;
if((dir = opendir("./expansions/")) == NULL)
......@@ -1625,7 +1784,7 @@ void Game::LoadExpansions() {
dataManager.FileSystem->addFileArchive(upath, true, false, EFAT_ZIP);
}
closedir(dir);
#endif
for(irr::u32 i = 0; i < dataManager.FileSystem->getFileArchiveCount(); ++i) {
auto archive = dataManager.FileSystem->getFileArchive(i)->getFileList();
for(irr::u32 j = 0; j < archive->getFileCount(); ++j) {
......
Classes/ocgcore/processor.cpp
View file @ eb028f4b
......@@ -732,8 +732,7 @@ uint32_t field::process() {
core.units.pop_front(); // 移除当前处理单元
}
return pduel->buffer_size(); // 返回缓冲区大小
}
}
case PROCESSOR_REMOVE_OVERLAY: {
if(remove_overlay_card(it->step, it->arg3, (card*)(it->ptarget), it->arg1 >> 16,
(it->arg1 >> 8) & 0xff, it->arg1 & 0xff, it->arg2 & 0xffff, it->arg2 >> 16)) {
......@@ -4017,34 +4016,58 @@ int32_t field::process_turn(uint16_t step, uint8_t turn_player) {
}
return TRUE;
}
/**
* @brief 处理连锁的添加过程
*
* 该函数负责将新发动的效果添加到连锁中，包括处理发动cost、移动卡片、设置连锁状态等操作。
* 连锁添加过程分为多个步骤，每个步骤处理不同的阶段，如cost处理、位置调整、取对象选择等。
*
* @param step 当前处理步骤
* @return int32_t 处理结果，TRUE表示处理完成，FALSE表示需要继续处理
*/
int32_t field::add_chain(uint16_t step) {
switch (step) {
case 0: {
// 如果没有新的连锁需要处理，则直接返回TRUE结束
if (!core.new_chains.size())
return TRUE;
// 获取第一个待处理的连锁
auto& clit = core.new_chains.front();
effect* peffect = clit.triggering_effect;
card* phandler = peffect->get_handler();
effect* peffect = clit.triggering_effect; // 获取发动的效果
card* phandler = peffect->get_handler(); // 获取效果持有者卡片
// 处理发动cost(EFFECT_ACTIVATE_COST)
effect_set eset;
filter_player_effect(clit.triggering_player, EFFECT_ACTIVATE_COST, &eset);
for(effect_set::size_type i = 0; i < eset.size(); ++i) {
// 添加参数并检查条件
pduel->lua->add_param(eset[i], PARAM_TYPE_EFFECT);
pduel->lua->add_param(clit.triggering_effect, PARAM_TYPE_EFFECT);
pduel->lua->add_param(clit.triggering_player, PARAM_TYPE_INT);
if(!pduel->lua->check_condition(eset[i]->target, 3))
continue;
// 如果有条件且有操作，则执行操作
if(eset[i]->operation) {
core.sub_solving_event.push_back(clit.evt);
add_process(PROCESSOR_EXECUTE_OPERATION, 0, eset[i], 0, clit.triggering_player, 0);
}
}
// 如果是卡的发动类型的效果
if(peffect->type & EFFECT_TYPE_ACTIVATE) {
// 获取手牌或场地设置所需的效果
if(peffect->get_required_handorset_effects(&clit.required_handorset_effects, clit.triggering_player, clit.evt) != 2) {
clit.required_handorset_effects.clear();
}
// 如果卡片在手牌中
if(phandler->current.location == LOCATION_HAND) {
uint32_t zone = 0xff;
uint32_t zone = 0xff; // 默认可放置区域
// 如果不是场地卡或钟摆卡，且有限制区域标志
if(!(phandler->data.type & (TYPE_FIELD | TYPE_PENDULUM)) && peffect->is_flag(EFFECT_FLAG_LIMIT_ZONE)) {
// 添加参数计算可用区域
pduel->lua->add_param(clit.triggering_player, PARAM_TYPE_INT);
pduel->lua->add_param(clit.evt.event_cards , PARAM_TYPE_GROUP);
pduel->lua->add_param(clit.evt.event_player, PARAM_TYPE_INT);
......@@ -4056,12 +4079,19 @@ int32_t field::add_chain(uint16_t step) {
if(!zone)
zone = 0xff;
}
// 禁用手牌效果，设置从手发动状态
phandler->enable_field_effect(false);
phandler->set_status(STATUS_ACT_FROM_HAND, TRUE);
// 场地卡只能放在特定区域
if(phandler->data.type & TYPE_FIELD)
zone = 0x1U << 5;
// 移动卡片到场上
move_to_field(phandler, phandler->current.controler, phandler->current.controler, LOCATION_SZONE, POS_FACEUP, FALSE, 0, (phandler->data.type & TYPE_PENDULUM) ? TRUE : FALSE, zone);
} else {
// 如果不在手牌中，清除从手牌发动状态，并改为表侧表示
phandler->set_status(STATUS_ACT_FROM_HAND, FALSE);
change_position(phandler, 0, phandler->current.controler, POS_FACEUP, 0);
}
......@@ -4069,32 +4099,47 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 1: {
// 获取当前处理的连锁
auto& clit = core.new_chains.front();
effect* peffect = clit.triggering_effect;
card* phandler = peffect->get_handler();
// 刷新卡片的禁用状态
phandler->refresh_disable_status();
// 如果是卡的发动类型效果，更新发动状态
if(peffect->type & EFFECT_TYPE_ACTIVATE) {
clit.set_triggering_state(phandler);
}
// 向客户端发送连锁消息
pduel->write_buffer8(MSG_CHAINING);
pduel->write_buffer32(phandler->data.code);
pduel->write_buffer32(phandler->get_info_location());
pduel->write_buffer8(clit.triggering_controler);
pduel->write_buffer8((uint8_t)clit.triggering_location);
pduel->write_buffer8(clit.triggering_sequence);
pduel->write_buffer32(peffect->description);
pduel->write_buffer8((uint8_t)core.current_chain.size() + 1);
pduel->write_buffer32(phandler->data.code); // 卡片密码
pduel->write_buffer32(phandler->get_info_location()); // 卡片位置
pduel->write_buffer8(clit.triggering_controler); // 诱发的玩家
pduel->write_buffer8((uint8_t)clit.triggering_location); // 诱发位置
pduel->write_buffer8(clit.triggering_sequence); // 诱发序号
pduel->write_buffer32(peffect->description); // 效果描述
pduel->write_buffer8((uint8_t)core.current_chain.size() + 1); // 连锁序号
// 清除连锁限制
for(auto& ch_lim : core.chain_limit)
luaL_unref(pduel->lua->lua_state, LUA_REGISTRYINDEX, ch_lim.function);
core.chain_limit.clear();
// 设置效果类型
peffect->card_type = phandler->get_type();
if((peffect->card_type & (TYPE_TRAP | TYPE_MONSTER)) == (TYPE_TRAP | TYPE_MONSTER))
peffect->card_type -= TYPE_TRAP;
peffect->set_active_type();
// 处理叠置素材效果
if (peffect->type & EFFECT_TYPE_XMATERIAL) {
peffect->active_handler = peffect->handler->overlay_target;
peffect->last_handler = peffect->handler->overlay_target;
}
// 设置连锁属性
clit.chain_count = (uint8_t)core.current_chain.size() + 1;
clit.target_cards = 0;
clit.target_player = PLAYER_NONE;
......@@ -4102,18 +4147,28 @@ int32_t field::add_chain(uint16_t step) {
clit.disable_reason = 0;
clit.disable_player = PLAYER_NONE;
clit.replace_op = 0;
// 如果从手牌发动，设置相应标志
if(phandler->current.location == LOCATION_HAND)
clit.flag |= CHAIN_HAND_EFFECT;
// 将连锁添加到当前连锁列表
core.current_chain.push_back(clit);
core.is_target_ready = false;
// 检查连锁计数
check_chain_counter(peffect, clit.triggering_player, clit.chain_count);
// triggered events which are not caused by event create relation with the handler
// 为非事件诱发的效果创建关系
if(!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY)
&& (!(peffect->type & (EFFECT_TYPE_TRIGGER_F | EFFECT_TYPE_TRIGGER_O)) || peffect->get_code_type() == CODE_PHASE)) {
phandler->create_relation(clit);
}
// 设置效果拥有者
peffect->effect_owner = clit.triggering_player;
// DISABLE_CHAIN should be check before cost
// 检查禁用效果
effect* deffect;
if(!peffect->is_flag(EFFECT_FLAG_FIELD_ONLY) && phandler->is_has_relation(clit) && (deffect = phandler->is_affected_by_effect(EFFECT_DISABLE_EFFECT))) {
effect* negeff = pduel->new_effect();
......@@ -4124,32 +4179,42 @@ int32_t field::add_chain(uint16_t step) {
negeff->reset_flag = RESET_CHAIN | RESET_EVENT | deffect->get_value();
phandler->add_effect(negeff);
}
// 从新连锁列表中移除已处理的连锁
core.new_chains.pop_front();
return FALSE;
}
case 2: {
// 获取当前连锁
auto& clit = core.current_chain.back();
int32_t playerid = clit.triggering_player;
effect* peffect = clit.triggering_effect;
// 检查是否存在CEFFECT（手牌或场地区域设置效果）
if(get_cteffect(peffect, playerid, TRUE)) {
// 检查是否在伤害步骤且效果不允许在伤害步骤使用
const bool damage_step = infos.phase == PHASE_DAMAGE && !peffect->is_flag(EFFECT_FLAG_DAMAGE_STEP);
const bool damage_cal = infos.phase == PHASE_DAMAGE_CAL && !peffect->is_flag(EFFECT_FLAG_DAMAGE_CAL);
if(damage_step || damage_cal) {
returns.ivalue[0] = TRUE;
return FALSE;
}
// 询问玩家是否使用CEFFECT
add_process(PROCESSOR_SELECT_EFFECTYN, 0, 0, (group*)peffect->get_handler(), playerid, 94);
} else
returns.ivalue[0] = FALSE;
return FALSE;
}
case 3: {
// 如果玩家选择不使用CEFFECT
if(!returns.ivalue[0]) {
core.select_chains.clear();
core.select_options.clear();
core.units.begin()->step = 4;
return FALSE;
}
// 如果有多个CEFFECT选项，让玩家选择
if(core.select_chains.size() > 1) {
auto& clit = core.current_chain.back();
add_process(PROCESSOR_SELECT_OPTION, 0, 0, 0, clit.triggering_player, 0);
......@@ -4158,25 +4223,37 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 4: {
// 处理CEFFECT选择结果
auto& clit = core.current_chain.back();
chain& ch = core.select_chains[returns.ivalue[0]];
int32_t playerid = clit.triggering_player;
effect* peffect = ch.triggering_effect;
card* phandler = peffect->get_handler();
// 发送选择提示消息
pduel->write_buffer8(MSG_HINT);
pduel->write_buffer8(HINT_OPSELECTED);
pduel->write_buffer8(playerid);
pduel->write_buffer32(core.select_options.size() > 1 ? core.select_options[returns.ivalue[0]] : 65);
// 更新连锁效果和事件
clit.triggering_effect = peffect;
clit.evt = ch.evt;
phandler->create_relation(clit);
peffect->set_active_type();
peffect->dec_count(playerid);
// 如果不是卡的发动类型效果，添加发动标志
if(!(peffect->type & EFFECT_TYPE_ACTIVATE)) {
peffect->type |= EFFECT_TYPE_ACTIVATE;
clit.flag |= CHAIN_ACTIVATING;
}
// 清理选择项
core.select_chains.clear();
core.select_options.clear();
// 添加客户端提示效果
effect* deffect = pduel->new_effect();
deffect->owner = phandler;
deffect->code = 0;
......@@ -4188,16 +4265,19 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 5: {
// 处理必需的手牌或场地设置效果
auto& clit = core.current_chain.back();
if (!clit.required_handorset_effects.size()) {
core.units.begin()->step = 6;
return FALSE;
}
// 如果只有一个必需效果，直接使用
if(clit.required_handorset_effects.size() == 1) {
returns.ivalue[0] = 0;
return FALSE;
} else {
// check if there's only one type of ceffects
// 检查是否所有效果都是同一种类型
auto peffect = clit.triggering_effect;
auto playerid = clit.triggering_player;
int32_t ceffect_unique_id = 0;
......@@ -4214,11 +4294,13 @@ int32_t field::add_chain(uint16_t step) {
}
}
if (ceffect_unique_id) {
// all ceffects are the same type, so skip asking
// 所有效果相同，无需选择
returns.ivalue[0] = 0;
return FALSE;
}
}
// 让玩家选择必需效果
core.select_options.clear();
for(effect_set::size_type i = 0; i < clit.required_handorset_effects.size(); ++i) {
core.select_options.push_back(clit.required_handorset_effects[i]->description);
......@@ -4227,15 +4309,20 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 6: {
// 执行选择的必需效果
auto& clit = core.current_chain.back();
auto ceffect = clit.required_handorset_effects[returns.ivalue[0]];
ceffect->dec_count(clit.triggering_player);
// 发送选择提示
if(ceffect->description) {
pduel->write_buffer8(MSG_HINT);
pduel->write_buffer8(HINT_OPSELECTED);
pduel->write_buffer8(clit.triggering_player);
pduel->write_buffer32(ceffect->description);
}
// 执行支付cost步骤
if(ceffect->cost) {
pduel->lua->add_param(clit.triggering_effect, PARAM_TYPE_EFFECT);
core.sub_solving_event.push_back(clit.evt);
......@@ -4244,6 +4331,7 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 7: {
// 支付主要效果的cost
auto& clit = core.current_chain.back();
effect* peffect = clit.triggering_effect;
peffect->cost_checked = TRUE;
......@@ -4254,6 +4342,7 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 8: {
// 执行选择主要效果的发动对象
auto& clit = core.current_chain.back();
effect* peffect = clit.triggering_effect;
if(peffect->target) {
......@@ -4263,12 +4352,15 @@ int32_t field::add_chain(uint16_t step) {
return FALSE;
}
case 9: {
// 连锁添加完成后的处理
break_effect();
core.is_target_ready = true;
auto& clit = core.current_chain.back();
effect* peffect = clit.triggering_effect;
peffect->cost_checked = FALSE;
card* phandler = peffect->get_handler();
// 处理作为对象的卡片成为目标事件
if(clit.target_cards && clit.target_cards->container.size()) {
if(peffect->is_flag(EFFECT_FLAG_CARD_TARGET)) {
for(auto& pcard : clit.target_cards->container)
......@@ -4278,29 +4370,42 @@ int32_t field::add_chain(uint16_t step) {
raise_event(clit.target_cards->container, EVENT_BECOME_TARGET, peffect, 0, clit.triggering_player, clit.triggering_player, clit.chain_count);
}
}
// 处理发动的卡片的离场确认
if(peffect->type & EFFECT_TYPE_ACTIVATE) {
core.leave_confirmed.insert(phandler);
if(!(phandler->data.type & (TYPE_CONTINUOUS | TYPE_FIELD | TYPE_EQUIP | TYPE_PENDULUM))
&& !phandler->is_affected_by_effect(EFFECT_REMAIN_FIELD))
phandler->set_status(STATUS_LEAVE_CONFIRMED, TRUE);
}
// 设置连续卡片标志
if((phandler->get_type() & (TYPE_SPELL | TYPE_TRAP))
&& (phandler->get_type() & (TYPE_CONTINUOUS | TYPE_FIELD | TYPE_EQUIP | TYPE_PENDULUM))
&& phandler->is_has_relation(clit) && phandler->current.location == LOCATION_SZONE
&& !peffect->is_flag(EFFECT_FLAG_FIELD_ONLY))
clit.flag |= CHAIN_CONTINUOUS_CARD;
// 发送连锁完成消息
pduel->write_buffer8(MSG_CHAINED);
pduel->write_buffer8(clit.chain_count);
// 诱发连锁事件
raise_event(phandler, EVENT_CHAINING, peffect, 0, clit.triggering_player, clit.triggering_player, clit.chain_count);
process_instant_event();
// 如果还有新的连锁需要处理，继续添加
if(core.new_chains.size())
add_process(PROCESSOR_ADD_CHAIN, 0, 0, 0, 0, 0);
// 调整所有状态
adjust_all();
return TRUE;
}
}
return TRUE;
}
void field::solve_continuous(uint8_t playerid, effect* peffect, const tevent& e) {
chain newchain;
newchain.chain_id = 0;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment