Initial commit

engines/scumm/he/logic/moonbase_logic.cpp

@@ -0,0 +1,784 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "scumm/he/intern_he.h"
+#include "scumm/he/logic_he.h"
+#include "scumm/he/moonbase/moonbase.h"
+#include "scumm/he/moonbase/ai_main.h"
+#ifdef USE_ENET
+#include "scumm/he/net/net_main.h"
+#include "scumm/he/net/net_defines.h"
+#endif
+
+namespace Scumm {
+
+/**
+ * Logic code for:
+ *     Moonbase Commander
+ */
+class LogicHEmoonbase : public LogicHE {
+public:
+	LogicHEmoonbase(ScummEngine_v100he *vm) : LogicHE(vm) { _vm1 = vm; }
+
+	int versionID() override;
+
+	int startOfFrame() override;
+
+	int32 dispatch(int op, int numArgs, int32 *args) override;
+	bool userCodeProcessWizImageCmd(const WizImageCommand *icmdPtr) override;
+	bool overrideImageHitTest(int *outValue, int globNum, int state, int x, int y, int32 flags) override;
+	bool overrideImagePixelHitTest(int *outValue, int globNum, int state, int x, int y, int32 flags) override;
+
+private:
+	int  op_create_multi_state_wiz(int op, int numArgs, int32 *args);
+	int  op_load_multi_channel_wiz(int op, int numArgs, int32 *args);
+	int  op_wiz_from_multi_channel_wiz(int op, int numArgs, int32 *args);
+	void op_dos_command(int op, int numArgs, int32 *args);
+	void op_set_fow_sentinel(int32 *args);
+	void op_set_fow_information(int op, int numArgs, int32 *args);
+	int  op_set_fow_image(int op, int numArgs, int32 *args);
+
+	void op_ai_test_kludge(int op, int numArgs, int32 *args);
+	int op_ai_master_control_program(int op, int numArgs, int32 *args);
+	void op_ai_reset(int op, int numArgs, int32 *args);
+	void op_ai_set_type(int op, int numArgs, int32 *args);
+	void op_ai_clean_up(int op, int numArgs, int32 *args);
+
+#ifdef USE_ENET
+	void op_net_remote_start_script(int op, int numArgs, int32 *args);
+	void op_net_remote_send_array(int op, int numArgs, int32 *args);
+	int op_net_remote_start_function(int op, int numArgs, int32 *args);
+	int op_net_do_init_all(int op, int numArgs, int32 *args);
+	int op_net_do_init_provider(int op, int numArgs, int32 *args);
+	int op_net_do_init_session(int op, int numArgs, int32 *args);
+	int op_net_do_init_user(int op, int numArgs, int32 *args);
+	int op_net_query_providers(int op, int numArgs, int32 *args);
+	int op_net_get_provider_name(int op, int numArgs, int32 *args);
+	int op_net_set_provider(int op, int numArgs, int32 *args);
+	int op_net_close_provider(int op, int numArgs, int32 *args);
+	int op_net_start_query_sessions(int op, int numArgs, int32 *args);
+	int op_net_update_query_sessions(int op, int numArgs, int32 *args);
+	int op_net_stop_query_sessions(int op, int numArgs, int32 *args);
+	int op_net_query_sessions(int op, int numArgs, int32 *args);
+	int op_net_get_session_name(int op, int numArgs, int32 *args);
+	int op_net_get_session_player_count(int op, int numArgs, int32 *args);
+	int op_net_destroy_player(int op, int numArgs, int32 *args);
+	int op_net_get_player_long_name(int op, int numArgs, int32 *args);
+	int op_net_get_player_short_name(int op, int numArgs, int32 *args);
+	int op_net_create_session(int op, int numArgs, int32 *args);
+	int op_net_join_session(int op, int numArgs, int32 *args);
+	int op_net_end_session(int op, int numArgs, int32 *args);
+	int op_net_disable_session_player_join(int op, int numArgs, int32 *args);
+	int op_net_enable_session_player_join(int op, int numArgs, int32 *args);
+	int op_net_set_ai_player_count(int op, int numArgs, int32 *args);
+	int op_net_add_user(int op, int numArgs, int32 *args);
+	int op_net_remove_user(int op, int numArgs, int32 *args);
+	int op_net_who_sent_this(int op, int numArgs, int32 *args);
+	int op_net_who_am_i(int op, int numArgs, int32 *args);
+	int op_net_set_provider_by_name(int op, int numArgs, int32 *args);
+	void op_net_set_fake_latency(int op, int numArgs, int32 *args);
+	int op_net_get_host_name(int op, int numArgs, int32 *args);
+	int op_net_get_ip_from_name(int op, int numArgs, int32 *args);
+	int op_net_host_tcpip_game(int op, int numArgs, int32 *args);
+	int op_net_join_tcpip_game(int op, int numArgs, int32 *args);
+#endif
+
+private:
+	ScummEngine_v100he *_vm1;
+};
+
+int LogicHEmoonbase::versionID() {
+	if (_vm->_game.features & GF_DEMO)
+		return -100;
+	else if (strcmp(_vm->_game.variant, "1.1") == 0)
+		return 110;
+	else
+		return 100;
+}
+
+#define OP_CREATE_MULTI_STATE_WIZ		100
+#define OP_LOAD_MULTI_CHANNEL_WIZ		101
+#define OP_WIZ_FROM_MULTI_CHANNEL_WIZ	102
+#define OP_DOS_COMMAND					103
+#define OP_SET_FOW_SENTINEL				104
+#define OP_SET_FOW_INFORMATION			105
+#define OP_SET_FOW_IMAGE				106
+
+#define OP_AI_TEST_KLUDGE				10000
+#define OP_AI_MASTER_CONTROL_PROGRAM	10001
+#define OP_AI_RESET						10002
+#define OP_AI_SET_TYPE					10003
+#define OP_AI_CLEAN_UP					10004
+
+#define OP_NET_REMOTE_START_SCRIPT			1492
+#define OP_NET_DO_INIT_ALL					1493
+#define OP_NET_DO_INIT_PROVIDER				1494
+#define OP_NET_DO_INIT_SESSION				1495
+#define OP_NET_DO_INIT_USER					1496
+#define OP_NET_QUERY_PROVIDERS				1497
+#define OP_NET_GET_PROVIDER_NAME			1498
+#define OP_NET_SET_PROVIDER					1499
+#define OP_NET_CLOSE_PROVIDER				1500
+#define OP_NET_QUERY_SESSIONS				1501
+#define OP_NET_GET_SESSION_NAME				1502
+#define OP_NET_CREATE_SESSION				1503
+#define OP_NET_JOIN_SESSION					1504
+#define OP_NET_END_SESSION					1505
+#define OP_NET_ADD_USER						1506
+#define OP_NET_REMOVE_USER					1507
+#define OP_NET_WHO_SENT_THIS				1508
+#define OP_NET_REMOTE_SEND_ARRAY			1509
+#define OP_NET_WHO_AM_I						1510
+#define OP_NET_REMOTE_START_FUNCTION		1511
+#define OP_NET_GET_PLAYER_LONG_NAME			1512
+#define OP_NET_GET_PLAYER_SHORT_NAME		1513
+#define OP_NET_SET_PROVIDER_BY_NAME			1516
+#define OP_NET_HOST_TCPIP_GAME				1517
+#define OP_NET_JOIN_TCPIP_GAME				1518
+#define OP_NET_SET_FAKE_LAG					1555
+#define OP_NET_SET_FAKE_LATENCY				1555 /* SET_FAKE_LAG is a valid alias for backwards compatibility */
+#define OP_NET_GET_HOST_NAME				1556
+#define OP_NET_GET_IP_FROM_NAME				1557
+#define OP_NET_GET_SESSION_PLAYER_COUNT		1558
+#define OP_NET_DISABLE_SESSION_PLAYER_JOIN	1559
+#define OP_NET_START_QUERY_SESSIONS			1560
+#define OP_NET_UPDATE_QUERY_SESSIONS		1561
+#define OP_NET_STOP_QUERY_SESSIONS			1562
+#define OP_NET_DESTROY_PLAYER				1563
+#define OP_NET_ENABLE_SESSION_PLAYER_JOIN	1564
+#define OP_NET_SET_AI_PLAYER_COUNT			1565
+
+int LogicHEmoonbase::startOfFrame() {
+#ifdef USE_ENET
+	_vm1->_net->doNetworkOnceAFrame(15); // Value should be passed in...
+#endif
+
+	return 0;
+}
+
+int32 LogicHEmoonbase::dispatch(int op, int numArgs, int32 *args) {
+	switch (op) {
+	// Development kludge commands which are called within a room
+	// which is not compiled into the final game files
+	case OP_CREATE_MULTI_STATE_WIZ:
+		return op_create_multi_state_wiz(op, numArgs, args);
+	case OP_LOAD_MULTI_CHANNEL_WIZ:
+		return op_load_multi_channel_wiz(op, numArgs, args);
+	case OP_WIZ_FROM_MULTI_CHANNEL_WIZ:
+		return op_wiz_from_multi_channel_wiz(op, numArgs, args);
+	case OP_DOS_COMMAND:
+		op_dos_command(op, numArgs, args);
+		break;
+
+	// "Fog of war" commands
+	case OP_SET_FOW_SENTINEL:
+		op_set_fow_sentinel(args);
+		break;
+	case OP_SET_FOW_INFORMATION:
+		op_set_fow_information(op, numArgs, args);
+		break;
+	case OP_SET_FOW_IMAGE:
+		return op_set_fow_image(op, numArgs, args);
+
+	// AI commands
+	case OP_AI_TEST_KLUDGE:
+		op_ai_test_kludge(op, numArgs, args);
+		break;
+	case OP_AI_MASTER_CONTROL_PROGRAM:
+		return op_ai_master_control_program(op, numArgs, args);
+	case OP_AI_RESET:
+		op_ai_reset(op, numArgs, args);
+		break;
+	case OP_AI_SET_TYPE:
+		op_ai_set_type(op, numArgs, args);
+		break;
+	case OP_AI_CLEAN_UP:
+		op_ai_clean_up(op, numArgs, args);
+		break;
+
+#ifdef USE_ENET
+	// Network commands
+	case OP_NET_REMOTE_START_SCRIPT:
+		op_net_remote_start_script(op, numArgs, args);
+		break;
+	case OP_NET_REMOTE_SEND_ARRAY:
+		op_net_remote_send_array(op, numArgs, args);
+		break;
+	case OP_NET_REMOTE_START_FUNCTION:
+		return op_net_remote_start_function(op, numArgs, args);
+	case OP_NET_DO_INIT_ALL:
+		return op_net_do_init_all(op, numArgs, args);
+	case OP_NET_DO_INIT_PROVIDER:
+		return op_net_do_init_provider(op, numArgs, args);
+	case OP_NET_DO_INIT_SESSION:
+		return op_net_do_init_session(op, numArgs, args);
+	case OP_NET_DO_INIT_USER:
+		return op_net_do_init_user(op, numArgs, args);
+	case OP_NET_QUERY_PROVIDERS:
+		return op_net_query_providers(op, numArgs, args);
+	case OP_NET_GET_PROVIDER_NAME:
+		return op_net_get_provider_name(op, numArgs, args);
+	case OP_NET_SET_PROVIDER:
+		return op_net_set_provider(op, numArgs, args);
+	case OP_NET_CLOSE_PROVIDER:
+		return op_net_close_provider(op, numArgs, args);
+	case OP_NET_START_QUERY_SESSIONS:
+		return op_net_start_query_sessions(op, numArgs, args);
+	case OP_NET_UPDATE_QUERY_SESSIONS:
+		return op_net_update_query_sessions(op, numArgs, args);
+	case OP_NET_STOP_QUERY_SESSIONS:
+		return op_net_stop_query_sessions(op, numArgs, args);
+	case OP_NET_QUERY_SESSIONS:
+		return op_net_query_sessions(op, numArgs, args);
+	case OP_NET_GET_SESSION_NAME:
+		return op_net_get_session_name(op, numArgs, args);
+	case OP_NET_GET_SESSION_PLAYER_COUNT:
+		return op_net_get_session_player_count(op, numArgs, args);
+	case OP_NET_DESTROY_PLAYER:
+		return op_net_destroy_player(op, numArgs, args);
+	case OP_NET_GET_PLAYER_LONG_NAME:
+		return op_net_get_player_long_name(op, numArgs, args);
+	case OP_NET_GET_PLAYER_SHORT_NAME:
+		return op_net_get_player_short_name(op, numArgs, args);
+	case OP_NET_CREATE_SESSION:
+		return op_net_create_session(op, numArgs, args);
+	case OP_NET_JOIN_SESSION:
+		return op_net_join_session(op, numArgs, args);
+	case OP_NET_END_SESSION:
+		return op_net_end_session(op, numArgs, args);
+	case OP_NET_DISABLE_SESSION_PLAYER_JOIN:
+		return op_net_disable_session_player_join(op, numArgs, args);
+	case OP_NET_ENABLE_SESSION_PLAYER_JOIN:
+		return op_net_enable_session_player_join(op, numArgs, args);
+	case OP_NET_SET_AI_PLAYER_COUNT:
+		return op_net_set_ai_player_count(op, numArgs, args);
+	case OP_NET_ADD_USER:
+		return op_net_add_user(op, numArgs, args);
+	case OP_NET_REMOVE_USER:
+		return op_net_remove_user(op, numArgs, args);
+	case OP_NET_WHO_SENT_THIS:
+		return op_net_who_sent_this(op, numArgs, args);
+	case OP_NET_WHO_AM_I:
+		return op_net_who_am_i(op, numArgs, args);
+	case OP_NET_SET_PROVIDER_BY_NAME:
+		return op_net_set_provider_by_name(op, numArgs, args);
+	case OP_NET_SET_FAKE_LATENCY: //  SET_FAKE_LAG is a valid alias for backwards compatibility
+		op_net_set_fake_latency(op, numArgs, args);
+		break;
+	case OP_NET_GET_HOST_NAME:
+		return op_net_get_host_name(op, numArgs, args);
+	case OP_NET_GET_IP_FROM_NAME:
+		return op_net_get_ip_from_name(op, numArgs, args);
+	case OP_NET_HOST_TCPIP_GAME:
+		return op_net_host_tcpip_game(op, numArgs, args);
+	case OP_NET_JOIN_TCPIP_GAME:
+		return op_net_join_tcpip_game(op, numArgs, args);
+#endif
+
+	default:
+		LogicHE::dispatch(op, numArgs, args);
+	}
+
+	return 0;
+}
+
+bool LogicHEmoonbase::userCodeProcessWizImageCmd(const WizImageCommand *params) {
+	// Make sure there is a imgcmd struct and it's a render operation
+	if (!params) {
+		return false;
+	}
+
+	if (params->actionType != kWADraw) {
+		return false;
+	}
+
+	// If there are special rendering bits bail
+	if (params->flags & kWRFSpecialRenderBitMask) {
+		return false;
+	}
+
+	// Check to see if the caller wants to use a source buffer
+	int sourceBufferImage = 0;
+
+	if (params->actionFlags & kWAFSourceImage) {
+		sourceBufferImage = params->sourceImage;
+	}
+
+	// Check to see if the caller wants to render into another image.
+	int destImage = 0;
+
+	if (params->actionFlags & kWAFDestImage) {
+		destImage = params->destImageNumber;
+	}
+
+	// Get the glob address and state number
+	byte *globPtr = _vm->getResourceAddress(rtImage, params->image);
+
+	if (!globPtr) {
+		error("LogicHEmoonbase::userCodeProcessWizImageCmd(): Image %d not on heap?", params->image);
+		return false;
+	}
+
+	int state = (params->actionFlags & kWAFState) ? params->state : 0;
+
+	// Make sure the dest buffer is one we can handle (Background or foreground)
+	WizMultiTypeBitmap mappedMultiBM;
+
+	bool drawIntoBackground = ((params->flags & kWRFBackground) == kWRFBackground);
+
+	if (destImage) {
+		if (!_vm->_wiz->dwGetMultiTypeBitmapFromImageState(destImage, 0, &mappedMultiBM)) {
+			return false;
+		}
+	} else {
+		if (!_vm->_wiz->pgGetMultiTypeBitmapFromDrawBuffer(&mappedMultiBM, drawIntoBackground)) {
+			return false;
+		}
+	}
+
+	Common::Rect clipRect, bitmapLimitsRect;
+
+	bitmapLimitsRect.left = 0;
+	bitmapLimitsRect.top = 0;
+	bitmapLimitsRect.right = (mappedMultiBM.width - 1);
+	bitmapLimitsRect.bottom = (mappedMultiBM.height - 1);
+
+	if (params->actionFlags & kWAFRect) {
+		clipRect.left = params->box.left;
+		clipRect.top = params->box.top;
+		clipRect.right = params->box.right;
+		clipRect.bottom = params->box.bottom;
+
+		if (!_vm->_wiz->findRectOverlap(&clipRect, &bitmapLimitsRect)) {
+			return true;
+		}
+	} else {
+		clipRect = bitmapLimitsRect;
+	}
+
+	// Validate source image if requested
+	byte *altSourceData = nullptr;
+
+	if (sourceBufferImage) {
+		WizMultiTypeBitmap sourceMultiBM;
+		
+		if (!_vm->_wiz->dwGetMultiTypeBitmapFromImageState(sourceBufferImage, 0, &sourceMultiBM)) {
+			return false;
+		}
+
+		if ((sourceMultiBM.width != mappedMultiBM.width) ||
+			(sourceMultiBM.height != mappedMultiBM.height) ||
+			(sourceMultiBM.stride != mappedMultiBM.stride) ||
+			(sourceMultiBM.format != mappedMultiBM.format) ||
+			(sourceMultiBM.bpp != mappedMultiBM.bpp)) {
+			return false;
+		}
+
+		altSourceData = sourceMultiBM.data;
+	}
+
+	// Convert the icmd struct to useful info for the renderer
+	int32 locationX, locationY;
+
+	if (params->actionFlags & kWAFSpot) {
+		locationX = params->xPos;
+		locationY = params->yPos;
+	} else {
+		locationX = 0;
+		locationY = 0;
+	}
+
+	int32 wizDrawFlags;
+
+	if (params->actionFlags & kWAFFlags) {
+		wizDrawFlags = params->flags;
+	} else {
+		wizDrawFlags = 0;
+	}
+
+	// Get any palette specified
+	byte *paletteData;
+
+	if (params->actionFlags & kWAFPalette) {
+		paletteData = _vm->getHEPaletteSlot(params->palette);
+	} else {
+		paletteData = _vm->getHEPaletteSlot(1);
+	}
+
+	// Finally call the renderer (returns false if not handled or error)
+	if ((_vm1->_moonbase->_fowSentinelImage != params->image) ||
+		(_vm1->_moonbase->_fowSentinelState != state) ||
+		(_vm1->_moonbase->_fowSentinelConditionBits != (uint32)params->extendedRenderInfo.conditionBits)) {
+
+		if (!_vm->_wiz->drawMoonbaseLayeredWiz(
+			mappedMultiBM.data,
+			mappedMultiBM.width, mappedMultiBM.height,
+			mappedMultiBM.stride, mappedMultiBM.format, mappedMultiBM.bpp,
+			globPtr, locationX, locationY, state,
+			clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
+			wizDrawFlags, params->extendedRenderInfo.conditionBits,
+			paletteData, altSourceData)) {
+		
+			return false;
+		}
+	} else {
+		_vm1->_moonbase->renderFOW(&mappedMultiBM);
+	}
+
+	if (destImage) {
+		_vm->_res->setModified(rtImage, destImage);
+	} else {
+		Common::Rect updateRectangle = clipRect; 
+
+		if (drawIntoBackground) {
+			_vm->backgroundToForegroundBlit(updateRectangle);
+		} else {
+			_vm->markRectAsDirty(kMainVirtScreen, updateRectangle);
+		}
+	}
+
+	return true;
+}
+
+bool LogicHEmoonbase::overrideImageHitTest(int *outValue, int globNum, int state, int x, int y, int32 flags) {
+	// Make sure this is a hit-test operation is a type we can handle
+	byte *globPtr = _vm->getResourceAddress(rtImage, globNum);
+
+	if (!globPtr) {
+		warning("LogicHEmoonbase::overrideImageHitTest(): Image %d not on heap", globNum);
+		return false;
+	}
+
+	int32 actualValue = 0;
+	int32 eatValue = 0;
+
+	if (!_vm->_wiz->moonbaseLayeredWizHitTest(&eatValue, &actualValue, globPtr, state, x, y, flags, (uint32)0)) {
+		return false;
+	}
+
+	*outValue = (int)eatValue;
+
+	return true;
+}
+
+bool LogicHEmoonbase::overrideImagePixelHitTest(int *outValue, int globNum, int state, int x, int y, int32 flags) {
+	// Make sure this is a hit-test operation is a type we can handle
+	byte *globPtr = _vm->getResourceAddress(rtImage, globNum);
+
+	if (!globPtr) {
+		warning("LogicHEmoonbase::overrideImagePixelHitTest(): Image %d not on heap", globNum);
+		return false;
+	}
+
+	int32 actualValue = ~0;
+	int32 eatValue = 0;
+
+	if (!_vm->_wiz->moonbaseLayeredWizHitTest(&eatValue, &actualValue, globPtr, state, x, y, flags, (uint32)0)) {
+		return false;
+	}
+
+	*outValue = (int)actualValue;
+
+	return true;
+}
+
+int LogicHEmoonbase::op_create_multi_state_wiz(int op, int numArgs, int32 *params) {
+	debug("LogicHEmoonbase::op_create_multi_state_wiz(): Unused development command called by a script non compiled in the final game files, ignoring");
+	LogicHE::dispatch(op, numArgs, params);
+
+	return 1;
+}
+
+int LogicHEmoonbase::op_load_multi_channel_wiz(int op, int numArgs, int32 *params) {
+	debug("LogicHEmoonbase::op_load_multi_channel_wiz(): Unused development command called by a script non compiled in the final game files, ignoring");
+	LogicHE::dispatch(op, numArgs, params);
+
+	return 1;
+}
+
+int LogicHEmoonbase::op_wiz_from_multi_channel_wiz(int op, int numArgs, int32 *params) {
+	debug("LogicHEmoonbase::op_wiz_from_multi_channel_wiz(): Unused development command called by a script non compiled in the final game files, ignoring");
+	LogicHE::dispatch(op, numArgs, params);
+
+	return 1;
+}
+
+void LogicHEmoonbase::op_dos_command(int op, int numArgs, int32 *params) {
+	debug("LogicHEmoonbase::op_dos_command(): Unused development command called by a script non compiled in the final game files, ignoring");
+	LogicHE::dispatch(op, numArgs, params);
+}
+
+void LogicHEmoonbase::op_set_fow_sentinel(int32 *args) {
+	debug(2, "op_set_fow_sentinel(%d, %d, %d)", args[0], args[1], args[2]);
+
+	_vm1->_moonbase->_fowSentinelImage = args[0];
+	_vm1->_moonbase->_fowSentinelState = args[1];
+	_vm1->_moonbase->_fowSentinelConditionBits = args[2];
+}
+
+void LogicHEmoonbase::op_set_fow_information(int op, int numArgs, int32 *args) {
+	Common::String str;
+
+	str = Common::String::format("op_set_fow_information(%d", args[0]);
+	for (int i = 1; i < numArgs; i++) {
+		str += Common::String::format(", %d", args[i]);
+	}
+	str += ")";
+
+	debug(2, "%s", str.c_str());
+
+	_vm1->_moonbase->setFOWInfo(
+		args[0], // array
+		args[1], // array down dimension
+		args[2], // array across dimension
+		args[3], // logical view X coordinate
+		args[4], // logical view Y coordinate
+		args[5], // screen draw clip rect x1
+		args[6], // screen draw clip rect y1
+		args[7], // screen draw clip rect x2
+		args[8], // screen draw clip rect y2
+		args[9], // techinque
+		args[10] // frame
+	);
+}
+
+int LogicHEmoonbase::op_set_fow_image(int op, int numArgs, int32 *args) {
+	debug(2, "op_set_fow_image(%d)", args[0]);
+	return _vm1->_moonbase->setFOWImage(args[0]) ? 1 : 0;
+}
+
+void LogicHEmoonbase::op_ai_test_kludge(int op, int numArgs, int32 *args) {
+	warning("STUB: op_ai_test_kludge()");
+	LogicHE::dispatch(op, numArgs, args);
+}
+
+int LogicHEmoonbase::op_ai_master_control_program(int op, int numArgs, int32 *args) {
+	debugC(DEBUG_MOONBASE_AI, "op_ai_master_control_program()");
+	return _vm1->_moonbase->_ai->masterControlProgram(numArgs, args);
+}
+
+void LogicHEmoonbase::op_ai_reset(int op, int numArgs, int32 *args) {
+	debugC(DEBUG_MOONBASE_AI, "op_ai_reset())");
+	_vm1->_moonbase->_ai->resetAI();
+}
+
+void LogicHEmoonbase::op_ai_set_type(int op, int numArgs, int32 *args) {
+	debugC(DEBUG_MOONBASE_AI, "op_ai_set_type()");
+	_vm1->_moonbase->_ai->setAIType(numArgs, args);
+}
+
+void LogicHEmoonbase::op_ai_clean_up(int op, int numArgs, int32 *args) {
+	debugC(DEBUG_MOONBASE_AI, "op_ai_clean_up()");
+	_vm1->_moonbase->_ai->cleanUpAI();
+}
+
+#ifdef USE_ENET
+void LogicHEmoonbase::op_net_remote_start_script(int op, int numArgs, int32 *args) {
+	_vm1->_net->remoteStartScript(args[0], args[1], args[2], numArgs - 3, &args[3]);
+}
+
+void LogicHEmoonbase::op_net_remote_send_array(int op, int numArgs, int32 *args) {
+	_vm1->_net->remoteSendArray(args[0], args[1], args[2], args[3]);
+}
+
+int LogicHEmoonbase::op_net_remote_start_function(int op, int numArgs, int32 *args) {
+	return _vm1->_net->remoteStartScriptFunction(args[0], args[1], args[2], args[3], numArgs - 4, &args[4]);
+}
+
+int LogicHEmoonbase::op_net_do_init_all(int op, int numArgs, int32 *args) {
+	return _vm1->_net->initAll();
+}
+
+int LogicHEmoonbase::op_net_do_init_provider(int op, int numArgs, int32 *args) {
+	return _vm1->_net->initProvider();
+}
+
+int LogicHEmoonbase::op_net_do_init_session(int op, int numArgs, int32 *args) {
+	return _vm1->_net->initSession();
+}
+
+int LogicHEmoonbase::op_net_do_init_user(int op, int numArgs, int32 *args) {
+	return _vm1->_net->initUser();
+}
+
+int LogicHEmoonbase::op_net_query_providers(int op, int numArgs, int32 *args) {
+	return _vm1->_net->queryProviders();
+}
+
+int LogicHEmoonbase::op_net_get_provider_name(int op, int numArgs, int32 *args) {
+	char name[MAX_PROVIDER_NAME];
+	_vm1->_net->getProviderName(args[0] - 1, name, sizeof(name));
+	return _vm1->setupStringArrayFromString(name);
+}
+
+int LogicHEmoonbase::op_net_set_provider(int op, int numArgs, int32 *args) {
+	return _vm1->_net->setProvider(args[0] - 1);
+}
+
+int LogicHEmoonbase::op_net_close_provider(int op, int numArgs, int32 *args) {
+	return _vm1->_net->closeProvider();
+}
+
+int LogicHEmoonbase::op_net_start_query_sessions(int op, int numArgs, int32 *args) {
+	return _vm1->_net->startQuerySessions();
+}
+
+int LogicHEmoonbase::op_net_update_query_sessions(int op, int numArgs, int32 *args) {
+	return _vm1->_net->updateQuerySessions();
+}
+
+int LogicHEmoonbase::op_net_stop_query_sessions(int op, int numArgs, int32 *args) {
+	_vm1->_net->stopQuerySessions();
+	return 1;
+}
+
+int LogicHEmoonbase::op_net_query_sessions(int op, int numArgs, int32 *args) {
+	return _vm1->_net->querySessions();
+}
+
+int LogicHEmoonbase::op_net_get_session_name(int op, int numArgs, int32 *args) {
+	char name[MAX_PROVIDER_NAME];
+	_vm1->_net->getSessionName(args[0] - 1, name, sizeof(name));
+	return _vm1->setupStringArrayFromString(name);
+}
+
+int LogicHEmoonbase::op_net_get_session_player_count(int op, int numArgs, int32 *args) {
+	return _vm1->_net->getSessionPlayerCount(args[0] - 1);
+}
+
+int LogicHEmoonbase::op_net_destroy_player(int op, int numArgs, int32 *args) {
+	return _vm1->_net->destroyPlayer(args[0]);
+}
+
+int LogicHEmoonbase::op_net_get_player_long_name(int op, int numArgs, int32 *args) {
+	return _vm1->setupStringArrayFromString("long name"); // TODO: gdefMultiPlay.playername1
+}
+
+int LogicHEmoonbase::op_net_get_player_short_name(int op, int numArgs, int32 *args) {
+	return _vm1->setupStringArrayFromString("short"); // TODO: gdefMultiPlay.playername2
+}
+
+int LogicHEmoonbase::op_net_create_session(int op, int numArgs, int32 *args) {
+	char name[MAX_SESSION_NAME];
+	_vm1->getStringFromArray(args[0], name, sizeof(name));
+	return _vm1->_net->createSession(name);
+}
+
+int LogicHEmoonbase::op_net_join_session(int op, int numArgs, int32 *args) {
+	return _vm1->_net->joinSession(args[0] - 1);
+}
+
+int LogicHEmoonbase::op_net_end_session(int op, int numArgs, int32 *args) {
+	return _vm1->_net->endSession();
+}
+
+int LogicHEmoonbase::op_net_disable_session_player_join(int op, int numArgs, int32 *args) {
+	_vm1->_net->disableSessionJoining();
+	return 1;
+}
+
+int LogicHEmoonbase::op_net_enable_session_player_join(int op, int numArgs, int32 *args) {
+	_vm1->_net->enableSessionJoining();
+	return 1;
+}
+
+int LogicHEmoonbase::op_net_set_ai_player_count(int op, int numArgs, int32 *args) {
+	_vm1->_net->setBotsCount(args[0]);
+	return 1;
+}
+
+int LogicHEmoonbase::op_net_add_user(int op, int numArgs, int32 *args) {
+	char userName[MAX_PLAYER_NAME];
+	_vm1->getStringFromArray(args[0], userName, sizeof(userName));
+	return _vm1->_net->addUser(userName, userName);
+}
+
+int LogicHEmoonbase::op_net_remove_user(int op, int numArgs, int32 *args) {
+	return _vm1->_net->removeUser();
+}
+
+int LogicHEmoonbase::op_net_who_sent_this(int op, int numArgs, int32 *args) {
+	return _vm1->_net->whoSentThis();
+}
+
+int LogicHEmoonbase::op_net_who_am_i(int op, int numArgs, int32 *args) {
+	return _vm1->_net->whoAmI();
+}
+
+int LogicHEmoonbase::op_net_set_provider_by_name(int op, int numArgs, int32 *args) {
+	// Parameter 1 is the provider name and
+	// Parameter 2 is the (optional) tcp/ip address
+	return _vm1->_net->setProviderByName(args[0], args[1]);
+}
+
+void LogicHEmoonbase::op_net_set_fake_latency(int op, int numArgs, int32 *args) {
+	_vm1->_net->setFakeLatency(args[0]);
+}
+
+int LogicHEmoonbase::op_net_get_host_name(int op, int numArgs, int32 *args) {
+	char name[MAX_HOSTNAME_SIZE];
+
+	if (_vm1->_net->getHostName(name, MAX_HOSTNAME_SIZE)) {
+		return _vm1->setupStringArrayFromString(name);
+	}
+
+	return 0;
+}
+
+int LogicHEmoonbase::op_net_get_ip_from_name(int op, int numArgs, int32 *args) {
+	char name[MAX_HOSTNAME_SIZE];
+	_vm1->getStringFromArray(args[0], name, sizeof(name));
+
+	char ip[MAX_IP_SIZE];
+
+	if (_vm1->_net->getIPfromName(ip, MAX_IP_SIZE, name)) {
+		return _vm1->setupStringArrayFromString(ip);
+	}
+
+	return 0;
+}
+
+int LogicHEmoonbase::op_net_host_tcpip_game(int op, int numArgs, int32 *args) {
+	char sessionName[MAX_SESSION_NAME];
+	char userName[MAX_PLAYER_NAME];
+
+	_vm1->getStringFromArray(args[0], sessionName, sizeof(sessionName));
+	_vm1->getStringFromArray(args[1], userName, sizeof(userName));
+
+	return _vm1->_net->hostGame(sessionName, userName);
+}
+
+int LogicHEmoonbase::op_net_join_tcpip_game(int op, int numArgs, int32 *args) {
+	char ip[MAX_IP_SIZE];
+	char userName[MAX_PLAYER_NAME];
+
+	_vm1->getStringFromArray(args[0], ip, sizeof(ip));
+	_vm1->getStringFromArray(args[1], userName, sizeof(userName));
+
+	return _vm1->_net->joinGame(ip, userName);
+}
+#endif
+
+LogicHE *makeLogicHEmoonbase(ScummEngine_v100he *vm) {
+	return new LogicHEmoonbase(vm);
+}
+
+} // End of namespace Scumm