Maniacs Patch - Expand expression and control var ops support

src/game_interpreter.cpp

@@ -1198,7 +1198,7 @@ bool Game_Interpreter::CommandControlVariables(lcf::rpg::EventCommand const& com
 		case 10: {
 			// Switch (Maniac)
 			value = com.parameters[5];
-			if (com.parameters[6] == 1) {
+			if (com.parameters[6] == 0) {
 				value = Main_Data::game_switches->GetInt(value);
 			} else {
 				value = Main_Data::game_switches->GetInt(Main_Data::game_variables->Get(value));
@@ -1287,6 +1287,40 @@ bool Game_Interpreter::CommandControlVariables(lcf::rpg::EventCommand const& com
 			// Expression (Maniac)
 			value = ManiacPatch::ParseExpression(MakeSpan(com.parameters).subspan(6, com.parameters[5]), *this);
 			break;
+		case 22: {
+			// Lerp (Maniac)
+			int mode = com.parameters[5];
+			int arg1 = ValueOrVariableBitfield(mode, 0, com.parameters[6]);
+			int arg2 = ValueOrVariableBitfield(mode, 1, com.parameters[7]);
+			int arg3 = ValueOrVariableBitfield(mode, 2, com.parameters[8]);
+			int arg4 = ValueOrVariableBitfield(mode, 3, com.parameters[9]);
+			value = ControlVariables::Lerp(arg1, arg2, arg3, arg4);
+			break;
+		}
+		case 23: {
+			// ArraySum (Maniac)
+			int mode = com.parameters[5];
+			int arg1 = ValueOrVariableBitfield(mode, 0, com.parameters[6]);
+			int arg2 = ValueOrVariableBitfield(mode, 1, com.parameters[7]);
+			value = ControlVariables::ArraySum(arg1, arg2);
+			break;
+		}
+		case 24: {
+			// ArrayMin (Maniac)
+			int mode = com.parameters[5];
+			int arg1 = ValueOrVariableBitfield(mode, 0, com.parameters[6]);
+			int arg2 = ValueOrVariableBitfield(mode, 1, com.parameters[7]);
+			value = ControlVariables::ArrayMin(arg1, arg2);
+			break;
+		}
+		case 25: {
+			// ArrayMax (Maniac)
+			int mode = com.parameters[5];
+			int arg1 = ValueOrVariableBitfield(mode, 0, com.parameters[6]);
+			int arg2 = ValueOrVariableBitfield(mode, 1, com.parameters[7]);
+			value = ControlVariables::ArrayMax(arg1, arg2);
+			break;
+		}
 		default:
 			Output::Warning("ControlVariables: Unsupported operand {}", operand);
 			return true;

src/game_interpreter_control_variables.cpp

@@ -24,6 +24,7 @@
 #include "game_party.h"
 #include "game_player.h"
 #include "game_system.h"
+#include "game_variables.h"
 #include "main_data.h"
 #include "output.h"
 #include "player.h"
@@ -33,6 +34,7 @@
 #include <cmath>
 #include <cstdint>
 #include <lcf/rpg/savepartylocation.h>
+#include <limits>
 
 int ControlVariables::Random(int value, int value2) {
 	int rmax = std::max(value, value2);
@@ -138,6 +140,12 @@ int ControlVariables::Actor(int op, int actor_id) {
 				return actor->GetAtbGauge();
 			}
 			break;
+		case 17:
+			// Required Experience
+			if (Player::IsPatchManiac()) {
+				return actor->GetNextExp();
+			}
+			break;
 	}
 
 	Output::Warning("ControlVariables::Actor: Unknown op {}", op);
@@ -425,23 +433,23 @@ int ControlVariables::Binary(int op, int arg1, int arg2) {
 			if (arg2_64 != 0) {
 				result = arg1_64 % arg2_64;
 			} else {
-				result = arg1_64;
+				result = 0;
 			}
 			break;
 		case 6:
-			result = arg1_64 | arg2_64;
+			result = arg1 | arg2;
 			break;
 		case 7:
-			result = arg1_64 & arg2_64;
+			result = arg1 & arg2;
 			break;
 		case 8:
-			result = arg1_64 ^ arg2_64;
+			result = arg1 ^ arg2;
 			break;
 		case 9:
-			result = arg1_64 << arg2_64;
+			result = static_cast<int64_t>(static_cast<uint32_t>(arg1) << arg2);
 			break;
 		case 10:
-			result = arg1_64 >> arg2_64;
+			result = static_cast<int64_t>(static_cast<uint32_t>(arg1) >> arg2);
 			break;
 		default:
 			Output::Warning("ControlVariables::Binary: Unknown op {}", op);
@@ -480,5 +488,40 @@ int ControlVariables::Divmul(int arg1, int arg2, int arg3) {
 }
 
 int ControlVariables::Between(int arg1, int arg2, int arg3) {
-	return (arg1 >= arg2 && arg2 <= arg3) ? 0 : 1;
+	int min_v = std::min(arg2, arg3);
+	int max_v = std::max(arg2, arg3);
+	return (arg1 >= min_v && arg1 <= max_v) ? 1 : 0;
+}
+
+int ControlVariables::Lerp(int a, int b, int num, int den) {
+	if (den == 0) return a;
+	int64_t diff = static_cast<int64_t>(b) - a;
+	return a + static_cast<int>(diff * num / den);
+}
+
+int ControlVariables::ArraySum(int var_id, int length) {
+	if (length <= 0) return 0;
+	int64_t sum = 0;
+	for (int i = 0; i < length; ++i) {
+		sum += Main_Data::game_variables->Get(var_id + i);
+	}
+	return static_cast<int>(Utils::Clamp<int64_t>(sum, std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max()));
+}
+
+int ControlVariables::ArrayMin(int var_id, int length) {
+	if (length <= 0) return 0;
+	int min_val = Main_Data::game_variables->Get(var_id);
+	for (int i = 1; i < length; ++i) {
+		min_val = std::min<int>(min_val, Main_Data::game_variables->Get(var_id + i));
+	}
+	return min_val;
+}
+
+int ControlVariables::ArrayMax(int var_id, int length) {
+	if (length <= 0) return 0;
+	int max_val = Main_Data::game_variables->Get(var_id);
+	for (int i = 1; i < length; ++i) {
+		max_val = std::max<int>(max_val, Main_Data::game_variables->Get(var_id + i));
+	}
+	return max_val;
 }

src/game_interpreter_control_variables.h

@@ -45,6 +45,10 @@ namespace ControlVariables {
 	int Muldiv(int arg1, int arg2, int arg3);
 	int Divmul(int arg1, int arg2, int arg3);
 	int Between(int arg1, int arg2, int arg3);
+	int Lerp(int a, int b, int num, int den);
+	int ArraySum(int var_id, int length);
+	int ArrayMin(int var_id, int length);
+	int ArrayMax(int var_id, int length);
 }
 
 #endif

src/game_variables.cpp

@@ -125,7 +125,7 @@ constexpr Var_t VarBitShiftLeft(Var_t n, Var_t d) {
 };
 
 constexpr Var_t VarBitShiftRight(Var_t n, Var_t d) {
-	return n >> d;
+	return static_cast<Var_t>(static_cast<uint32_t>(n) >> d);
 };
 
 }