Maniacs Patch - SetPicturePixel Command

Implements the CommandManiacSetPicturePixel function to allow direct pixel manipulation of game pictures via event commands. Handles bitmap uniqueness, format conversion, and window picture detachment to ensure safe editing. Updates command dispatch logic and header declaration.

Author: jetrotal

src/game_interpreter.cpp

@@ -69,6 +69,8 @@
 #include "transition.h"
 #include "baseui.h"
 #include "algo.h"
+#include "sprite_picture.h"
+#include "bitmap.h"
 
 using namespace Game_Interpreter_Shared;
 
@@ -810,6 +812,8 @@ bool Game_Interpreter::ExecuteCommand(lcf::rpg::EventCommand const& com) {
 			return CmdSetup<&Game_Interpreter::CommandManiacCallCommand, 6>(com);
 		case Cmd::Maniac_GetGameInfo:
 			return CmdSetup<&Game_Interpreter::CommandManiacGetGameInfo, 8>(com);
+		case static_cast<Cmd>(3025):
+			return CmdSetup<&Game_Interpreter::CommandManiacSetPicturePixel, 8>(com);
 		case Cmd::EasyRpg_SetInterpreterFlag:
 			return CmdSetup<&Game_Interpreter::CommandEasyRpgSetInterpreterFlag, 2>(com);
 		case Cmd::EasyRpg_ProcessJson:
@@ -4426,6 +4430,136 @@ bool Game_Interpreter::CommandManiacGetGameInfo(lcf::rpg::EventCommand const& co
 	return true;
 }
 
+bool Game_Interpreter::CommandManiacSetPicturePixel(lcf::rpg::EventCommand const& com) {
+	if (!Player::IsPatchManiac()) {
+		return true;
+	}
+
+	int pic_id = ValueOrVariableBitfield(com.parameters[0], 0, com.parameters[1]);
+	if (pic_id <= 0) {
+		Output::Warning("ManiacSetPicturePixel: Invalid picture ID {}", pic_id);
+		return true;
+	}
+
+	auto& pic = Main_Data::game_pictures->GetPicture(pic_id);
+
+	if (pic.IsRequestPending()) {
+		pic.MakeRequestImportant();
+		_async_op = AsyncOp::MakeYieldRepeat();
+		return true;
+	}
+
+	auto* sprite = pic.sprite.get();
+	if (!sprite) return true;
+
+	auto bitmap = sprite->GetBitmap();
+	if (!bitmap) return true;
+
+	// 1. Calculate Spritesheet Offset
+	// Maniacs operations are relative to the currently active cell.
+	int offset_x = 0;
+	int offset_y = 0;
+
+	const auto& data = pic.data;
+	if (data.spritesheet_cols > 1 || data.spritesheet_rows > 1) {
+		int frame_width = bitmap->GetWidth() / data.spritesheet_cols;
+		int frame_height = bitmap->GetHeight() / data.spritesheet_rows;
+
+		// Map current frame index to X/Y coords
+		offset_x = (data.spritesheet_frame % data.spritesheet_cols) * frame_width;
+		offset_y = (data.spritesheet_frame / data.spritesheet_cols) * frame_height;
+	}
+
+	// 2. COW & Window Detach Logic
+	BitmapRef writeable_bitmap = bitmap;
+
+	bool is_cached = !bitmap->GetId().empty() && !StartsWith(bitmap->GetId(), "Canvas:");
+	bool wrong_format = bitmap->bpp() != 4;
+	bool is_window = data.easyrpg_type == lcf::rpg::SavePicture::EasyRpgType_window;
+
+	if (is_cached || wrong_format || is_window) {
+		writeable_bitmap = Bitmap::Create(bitmap->GetWidth(), bitmap->GetHeight());
+		writeable_bitmap->BlitFast(0, 0, *bitmap, bitmap->GetRect(), 255);
+
+		writeable_bitmap->SetId("Canvas:" + std::to_string(pic_id));
+
+		sprite->SetBitmap(writeable_bitmap);
+
+		if (is_window) {
+			pic.data.easyrpg_type = lcf::rpg::SavePicture::EasyRpgType_default;
+		}
+
+		// Force sprite to recalculate its clipping rectangle immediately.
+		// Otherwise, SetBitmap resets src_rect to full size, showing the whole sheet.
+		sprite->OnPictureShow();
+	}
+
+	// 3. Parameters
+	int x = ValueOrVariableBitfield(com.parameters[0], 1, com.parameters[2]);
+	int y = ValueOrVariableBitfield(com.parameters[0], 2, com.parameters[3]);
+	int w = ValueOrVariableBitfield(com.parameters[0], 3, com.parameters[4]);
+	int h = ValueOrVariableBitfield(com.parameters[0], 4, com.parameters[5]);
+
+	int src_var_start = ValueOrVariableBitfield(com.parameters[0], 5, com.parameters[6]);
+
+	int flags = com.parameters[7];
+	bool flag_opaq = (flags & 1) != 0;
+	bool flag_skip_trans = (flags & 2) != 0;
+
+	// 4. Drawing Loop
+	int bmp_w = writeable_bitmap->GetWidth();
+	int bmp_h = writeable_bitmap->GetHeight();
+
+	if (w <= 0 || h <= 0) return true;
+
+	uint32_t* pixels = static_cast<uint32_t*>(writeable_bitmap->pixels());
+	int pitch = writeable_bitmap->pitch() / 4;
+
+	int current_var = src_var_start;
+	auto& vars = *Main_Data::game_variables;
+
+	for (int iy = 0; iy < h; ++iy) {
+		// Apply Y Offset here
+		int py = y + iy + offset_y;
+
+		if (py < 0 || py >= bmp_h) {
+			current_var += w;
+			continue;
+		}
+
+		for (int ix = 0; ix < w; ++ix) {
+			int32_t color_val = vars.Get(current_var++);
+
+			// Apply X Offset here
+			int px = x + ix + offset_x;
+
+			if (px < 0 || px >= bmp_w) continue;
+
+			uint8_t a = (color_val >> 24) & 0xFF;
+			uint8_t r = (color_val >> 16) & 0xFF;
+			uint8_t g = (color_val >> 8) & 0xFF;
+			uint8_t b = (color_val) & 0xFF;
+
+			if (flag_skip_trans && a == 0) continue;
+
+			if (flag_opaq) {
+				a = 0xFF;
+			}
+
+			if (a < 255) {
+				r = (r * a) / 255;
+				g = (g * a) / 255;
+				b = (b * a) / 255;
+			}
+
+			uint32_t final_pixel = Bitmap::pixel_format.rgba_to_uint32_t(r, g, b, a);
+			pixels[py * pitch + px] = final_pixel;
+		}
+	}
+
+	return true;
+}
+
 bool Game_Interpreter::CommandManiacGetSaveInfo(lcf::rpg::EventCommand const& com) {
 	if (!Player::IsPatchManiac()) {
 		return true;

src/game_interpreter.h

@@ -311,6 +311,7 @@ class Game_Interpreter : public Game_BaseInterpreterContext
 	bool CommandEasyRpgCloneMapEvent(lcf::rpg::EventCommand const& com);
 	bool CommandEasyRpgDestroyMapEvent(lcf::rpg::EventCommand const& com);
 	bool CommandManiacGetGameInfo(lcf::rpg::EventCommand const& com);
+	bool CommandManiacSetPicturePixel(lcf::rpg::EventCommand const& com);
 
 	void SetSubcommandIndex(int indent, int idx);
 	uint8_t& ReserveSubcommandIndex(int indent);