[Scummvm-git-logs] scummvm master -> 0274540d479809fea093969ac6f7156256fce099

[dreammaster]

This automated email contains information about 4 new commits which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .

Summary:
3dce18afa5 AGS: Finished implementing the GlobalAPI plugin exports
75974c9d42 AGS: Added skeleton classes for other plugin interfaces
b18e00e721 AGS: Implementing the core classes
0274540d47 AGS: Implement remaining plugin core export classes


Commit: 3dce18afa54f9e27eb1526599f91e3b4bd634bff
    https://github.com/scummvm/scummvm/commit/3dce18afa54f9e27eb1526599f91e3b4bd634bff
Author: Paul Gilbert (dreammaster at scummvm.org)
Date: 2021-07-17T15:52:11-07:00

Commit Message:
AGS: Finished implementing the GlobalAPI plugin exports

Changed paths:
    engines/ags/plugins/core/global_api.cpp


diff --git a/engines/ags/plugins/core/global_api.cpp b/engines/ags/plugins/core/global_api.cpp
index 1ac646e1a4..bf5a97dcd1 100644
--- a/engines/ags/plugins/core/global_api.cpp
+++ b/engines/ags/plugins/core/global_api.cpp
@@ -25,27 +25,51 @@
 #include "ags/engine/ac/display.h"
 #include "ags/engine/ac/dynamic_sprite.h"
 #include "ags/engine/ac/event.h"
+#include "ags/engine/ac/game.h"
 #include "ags/engine/ac/global_audio.h"
 #include "ags/engine/ac/global_button.h"
 #include "ags/engine/ac/global_character.h"
+#include "ags/engine/ac/global_date_time.h"
 #include "ags/engine/ac/global_debug.h"
 #include "ags/engine/ac/global_dialog.h"
 #include "ags/engine/ac/global_display.h"
 #include "ags/engine/ac/global_drawing_surface.h"
+#include "ags/engine/ac/global_dynamic_sprite.h"
 #include "ags/engine/ac/global_file.h"
 #include "ags/engine/ac/global_game.h"
 #include "ags/engine/ac/global_gui.h"
 #include "ags/engine/ac/global_hotspot.h"
+#include "ags/engine/ac/global_inv_window.h"
 #include "ags/engine/ac/global_inventory_item.h"
+#include "ags/engine/ac/global_label.h"
+#include "ags/engine/ac/global_listbox.h"
+#include "ags/engine/ac/global_mouse.h"
 #include "ags/engine/ac/global_object.h"
 #include "ags/engine/ac/global_overlay.h"
 #include "ags/engine/ac/global_palette.h"
+#include "ags/engine/ac/global_parser.h"
+#include "ags/engine/ac/global_record.h"
 #include "ags/engine/ac/global_region.h"
 #include "ags/engine/ac/global_room.h"
 #include "ags/engine/ac/global_screen.h"
+#include "ags/engine/ac/global_slider.h"
 #include "ags/engine/ac/global_string.h"
+#include "ags/engine/ac/global_textbox.h"
+#include "ags/engine/ac/global_timer.h"
+#include "ags/engine/ac/global_translation.h"
+#include "ags/engine/ac/global_video.h"
+#include "ags/engine/ac/global_view_frame.h"
+#include "ags/engine/ac/global_viewport.h"
+#include "ags/engine/ac/global_walk_behind.h"
+#include "ags/engine/ac/global_walkable_area.h"
 #include "ags/engine/ac/math.h"
 #include "ags/engine/ac/mouse.h"
+#include "ags/engine/ac/parser.h"
+#include "ags/engine/ac/room.h"
+#include "ags/engine/ac/string.h"
+#include "ags/engine/media/audio/audio.h"
+#include "ags/engine/media/video/video.h"
+#include "ags/shared/util/string_compat.h"
 
 namespace AGS3 {
 namespace Plugins {
@@ -903,226 +927,539 @@ void GlobalAPI::GetLocationType(ScriptMethodParams &params) {
 	params._result = AGS3::GetLocationType(xx, yy);
 }
 
-// TODO: The rest
-void GlobalAPI::GetMessageText(ScriptMethodParams &params) {}
+void GlobalAPI::GetMessageText(ScriptMethodParams &params) {
+	PARAMS2(int, msg, char *, buffer);
+	AGS3::GetMessageText(msg, buffer);
+}
 
-void GlobalAPI::GetMIDIPosition(ScriptMethodParams &params) {}
+void GlobalAPI::GetMIDIPosition(ScriptMethodParams &params) {
+	params._result = AGS3::GetMIDIPosition();
+}
 
-void GlobalAPI::GetMP3PosMillis(ScriptMethodParams &params) {}
+void GlobalAPI::GetMP3PosMillis(ScriptMethodParams &params) {
+	params._result = AGS3::GetMP3PosMillis();
+}
 
-void GlobalAPI::GetObjectIDAtScreen(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectIDAtScreen(ScriptMethodParams &params) {
+	PARAMS2(int, scrx, int, scry);
+	params._result = AGS3::GetObjectIDAtScreen(scrx, scry);
+}
 
-void GlobalAPI::GetObjectBaseline(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectBaseline(ScriptMethodParams &params) {
+	PARAMS1(int, obn);
+	params._result = AGS3::GetObjectBaseline(obn);
+}
 
-void GlobalAPI::GetObjectGraphic(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectGraphic(ScriptMethodParams &params) {
+	PARAMS1(int, obn);
+	params._result = AGS3::GetObjectGraphic(obn);
+}
 
-void GlobalAPI::GetObjectName(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectName(ScriptMethodParams &params) {
+	PARAMS2(int, obj, char *, buffer);
+	AGS3::GetObjectName(obj, buffer);
+}
 
-void GlobalAPI::GetObjectProperty(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectProperty(ScriptMethodParams &params) {
+	PARAMS2(int, hss, const char *, property);
+	params._result = AGS3::GetObjectProperty(hss, property);
+}
 
-void GlobalAPI::GetObjectPropertyText(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectPropertyText(ScriptMethodParams &params) {
+	PARAMS3(int, item, const char *, property, char *, buffer);
+	AGS3::GetObjectPropertyText(item, property, buffer);
+}
 
-void GlobalAPI::GetObjectX(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectX(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	params._result = AGS3::GetObjectX(obj);
+}
 
-void GlobalAPI::GetObjectY(ScriptMethodParams &params) {}
+void GlobalAPI::GetObjectY(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	params._result = AGS3::GetObjectY(obj);
+}
 
-void GlobalAPI::GetPlayerCharacter(ScriptMethodParams &params) {}
+void GlobalAPI::GetPlayerCharacter(ScriptMethodParams &params) {
+	params._result = AGS3::GetPlayerCharacter();
+}
 
-void GlobalAPI::GetRawTime(ScriptMethodParams &params) {}
+void GlobalAPI::GetRawTime(ScriptMethodParams &params) {
+	params._result = AGS3::GetRawTime();
+}
 
-void GlobalAPI::GetRegionIDAtRoom(ScriptMethodParams &params) {}
+void GlobalAPI::GetRegionIDAtRoom(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetRegionIDAtRoom(xx, yy);
+}
 
-void GlobalAPI::Room_GetProperty(ScriptMethodParams &params) {}
+void GlobalAPI::Room_GetProperty(ScriptMethodParams &params) {
+	PARAMS1(const char *, property);
+	params._result = AGS3::Room_GetProperty(property);
+}
 
-void GlobalAPI::GetRoomPropertyText(ScriptMethodParams &params) {}
+void GlobalAPI::GetRoomPropertyText(ScriptMethodParams &params) {
+	PARAMS2(const char *, property, char *, buffer);
+	AGS3::GetRoomPropertyText(property, buffer);
+}
 
-void GlobalAPI::GetSaveSlotDescription(ScriptMethodParams &params) {}
+void GlobalAPI::GetSaveSlotDescription(ScriptMethodParams &params) {
+	PARAMS2(int, slnum, char *, desbuf);
+	params._result = AGS3::GetSaveSlotDescription(slnum, desbuf);
+}
 
-void GlobalAPI::GetScalingAt(ScriptMethodParams &params) {}
+void GlobalAPI::GetScalingAt(ScriptMethodParams &params) {
+	PARAMS2(int, x, int, y);
+	params._result = AGS3::GetScalingAt(x, y);
+}
 
-void GlobalAPI::GetSliderValue(ScriptMethodParams &params) {}
+void GlobalAPI::GetSliderValue(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, objn);
+	params._result = AGS3::GetSliderValue(guin, objn);
+}
 
-void GlobalAPI::GetTextBoxText(ScriptMethodParams &params) {}
+void GlobalAPI::GetTextBoxText(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, char *, txbuf);
+	AGS3::GetTextBoxText(guin, objn, txbuf);
+}
 
-void GlobalAPI::GetTextHeight(ScriptMethodParams &params) {}
+void GlobalAPI::GetTextHeight(ScriptMethodParams &params) {
+	PARAMS3(const char *, text, int, fontnum, int, width);
+	params._result = AGS3::GetTextHeight(text, fontnum, width);
+}
 
-void GlobalAPI::GetTextWidth(ScriptMethodParams &params) {}
+void GlobalAPI::GetTextWidth(ScriptMethodParams &params) {
+	PARAMS2(const char *, text, int, fontnum);
+	params._result = AGS3::GetTextWidth(text, fontnum);
+}
 
-void GlobalAPI::sc_GetTime(ScriptMethodParams &params) {}
+void GlobalAPI::sc_GetTime(ScriptMethodParams &params) {
+	PARAMS1(int, whatti);
+	params._result = AGS3::sc_GetTime(whatti);
+}
 
-void GlobalAPI::get_translation(ScriptMethodParams &params) {}
+void GlobalAPI::get_translation(ScriptMethodParams &params) {
+	PARAMS1(const char *, text);
+	params._result = AGS3::get_translation(text);
+}
 
-void GlobalAPI::GetTranslationName(ScriptMethodParams &params) {}
+void GlobalAPI::GetTranslationName(ScriptMethodParams &params) {
+	PARAMS1(char *, buffer);
+	params._result = AGS3::GetTranslationName(buffer);
+}
 
-void GlobalAPI::GetViewportX(ScriptMethodParams &params) {}
+void GlobalAPI::GetViewportX(ScriptMethodParams &params) {
+	params._result = AGS3::GetViewportX();
+}
 
-void GlobalAPI::GetViewportY(ScriptMethodParams &params) {}
+void GlobalAPI::GetViewportY(ScriptMethodParams &params) {
+	params._result = AGS3::GetViewportY();
+}
 
-void GlobalAPI::GetWalkableAreaAtRoom(ScriptMethodParams &params) {}
+void GlobalAPI::GetWalkableAreaAtRoom(ScriptMethodParams &params) {
+	PARAMS2(int, x, int, y);
+	params._result = AGS3::GetWalkableAreaAtRoom(x, y);
+}
 
-void GlobalAPI::GetWalkableAreaAtScreen(ScriptMethodParams &params) {}
+void GlobalAPI::GetWalkableAreaAtScreen(ScriptMethodParams &params) {
+	PARAMS2(int, x, int, y);
+	params._result = AGS3::GetWalkableAreaAtScreen(x, y);
+}
 
-void GlobalAPI::GiveScore(ScriptMethodParams &params) {}
+void GlobalAPI::GiveScore(ScriptMethodParams &params) {
+	PARAMS1(int, amount);
+	AGS3::GiveScore(amount);
+}
 
-void GlobalAPI::HasPlayerBeenInRoom(ScriptMethodParams &params) {}
+void GlobalAPI::HasPlayerBeenInRoom(ScriptMethodParams &params) {
+	PARAMS1(int, roomnum);
+	params._result = AGS3::HasPlayerBeenInRoom(roomnum);
+}
 
-void GlobalAPI::HideMouseCursor(ScriptMethodParams &params) {}
+void GlobalAPI::HideMouseCursor(ScriptMethodParams &params) {
+	AGS3::HideMouseCursor();
+}
 
-void GlobalAPI::sc_inputbox(ScriptMethodParams &params) {}
+void GlobalAPI::sc_inputbox(ScriptMethodParams &params) {
+	PARAMS2(const char *, msg, char *, bufr);
+	AGS3::sc_inputbox(msg, bufr);
+}
 
-void GlobalAPI::InterfaceOff(ScriptMethodParams &params) {}
+void GlobalAPI::InterfaceOff(ScriptMethodParams &params) {
+	PARAMS1(int, ifn);
+	AGS3::InterfaceOff(ifn);
+}
 
-void GlobalAPI::InterfaceOn(ScriptMethodParams &params) {}
+void GlobalAPI::InterfaceOn(ScriptMethodParams &params) {
+	PARAMS1(int, ifn);
+	AGS3::InterfaceOn(ifn);
+}
 
-void GlobalAPI::IntToFloat(ScriptMethodParams &params) {}
+void GlobalAPI::IntToFloat(ScriptMethodParams &params) {
+	PARAMS1(int, value);
+	params._result = AGS3::IntToFloat(value);
+}
 
-void GlobalAPI::sc_invscreen(ScriptMethodParams &params) {}
+void GlobalAPI::sc_invscreen(ScriptMethodParams &params) {
+	AGS3::sc_invscreen();
+}
 
-void GlobalAPI::IsButtonDown(ScriptMethodParams &params) {}
+void GlobalAPI::IsButtonDown(ScriptMethodParams &params) {
+	PARAMS1(int, which);
+	params._result = AGS3::IsButtonDown(which);
+}
 
-void GlobalAPI::IsChannelPlaying(ScriptMethodParams &params) {}
+void GlobalAPI::IsChannelPlaying(ScriptMethodParams &params) {
+	PARAMS1(int, chan);
+	params._result = AGS3::IsChannelPlaying(chan);
+}
 
-void GlobalAPI::IsGamePaused(ScriptMethodParams &params) {}
+void GlobalAPI::IsGamePaused(ScriptMethodParams &params) {
+	params._result = AGS3::IsGamePaused();
+}
 
-void GlobalAPI::IsGUIOn(ScriptMethodParams &params) {}
+void GlobalAPI::IsGUIOn(ScriptMethodParams &params) {
+	PARAMS1(int, guinum);
+	params._result = AGS3::IsGUIOn(guinum);
+}
 
-void GlobalAPI::IsInteractionAvailable(ScriptMethodParams &params) {}
+void GlobalAPI::IsInteractionAvailable(ScriptMethodParams &params) {
+	PARAMS3(int, xx, int, yy, int, mood);
+	params._result = AGS3::IsInteractionAvailable(xx, yy, mood);
+}
 
-void GlobalAPI::IsInventoryInteractionAvailable(ScriptMethodParams &params) {}
+void GlobalAPI::IsInventoryInteractionAvailable(ScriptMethodParams &params) {
+	PARAMS2(int, item, int, mood);
+	params._result = AGS3::IsInventoryInteractionAvailable(item, mood);
+}
 
-void GlobalAPI::IsInterfaceEnabled(ScriptMethodParams &params) {}
+void GlobalAPI::IsInterfaceEnabled(ScriptMethodParams &params) {
+	params._result = AGS3::IsInterfaceEnabled();
+}
 
-void GlobalAPI::IsKeyPressed(ScriptMethodParams &params) {}
+void GlobalAPI::IsKeyPressed(ScriptMethodParams &params) {
+	PARAMS1(int, keycode);
+	params._result = AGS3::IsKeyPressed(keycode);
+}
 
-void GlobalAPI::IsMusicPlaying(ScriptMethodParams &params) {}
+void GlobalAPI::IsMusicPlaying(ScriptMethodParams &params) {
+	params._result = AGS3::IsMusicPlaying();
+}
 
-void GlobalAPI::IsMusicVoxAvailable(ScriptMethodParams &params) {}
+void GlobalAPI::IsMusicVoxAvailable(ScriptMethodParams &params) {
+	params._result = AGS3::IsMusicVoxAvailable();
+}
 
-void GlobalAPI::IsObjectAnimating(ScriptMethodParams &params) {}
+void GlobalAPI::IsObjectAnimating(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	params._result = AGS3::IsObjectAnimating(obj);
+}
 
-void GlobalAPI::IsObjectMoving(ScriptMethodParams &params) {}
+void GlobalAPI::IsObjectMoving(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	params._result = AGS3::IsObjectMoving(obj);
+}
 
-void GlobalAPI::IsObjectOn(ScriptMethodParams &params) {}
+void GlobalAPI::IsObjectOn(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	params._result = AGS3::IsObjectOn(obj);
+}
 
-void GlobalAPI::IsOverlayValid(ScriptMethodParams &params) {}
+void GlobalAPI::IsOverlayValid(ScriptMethodParams &params) {
+	PARAMS1(int, ovrid);
+	params._result = AGS3::IsOverlayValid(ovrid);
+}
 
-void GlobalAPI::IsSoundPlaying(ScriptMethodParams &params) {}
+void GlobalAPI::IsSoundPlaying(ScriptMethodParams &params) {
+	params._result = AGS3::IsSoundPlaying();
+}
 
-void GlobalAPI::IsTimerExpired(ScriptMethodParams &params) {}
+void GlobalAPI::IsTimerExpired(ScriptMethodParams &params) {
+	PARAMS1(int, tnum);
+	params._result = AGS3::IsTimerExpired(tnum);
+}
 
-void GlobalAPI::IsTranslationAvailable(ScriptMethodParams &params) {}
+void GlobalAPI::IsTranslationAvailable(ScriptMethodParams &params) {
+	params._result = AGS3::IsTranslationAvailable();
+}
 
-void GlobalAPI::IsVoxAvailable(ScriptMethodParams &params) {}
+void GlobalAPI::IsVoxAvailable(ScriptMethodParams &params) {
+	params._result = AGS3::IsVoxAvailable();
+}
 
-void GlobalAPI::ListBoxAdd(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxAdd(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, const char *, newitem);
+	AGS3::ListBoxAdd(guin, objn, newitem);
+}
 
-void GlobalAPI::ListBoxClear(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxClear(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, objn);
+	AGS3::ListBoxClear(guin, objn);
+}
 
-void GlobalAPI::ListBoxDirList(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxDirList(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, const char *, filemask);
+	AGS3::ListBoxDirList(guin, objn, filemask);
+}
 
-void GlobalAPI::ListBoxGetItemText(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxGetItemText(ScriptMethodParams &params) {
+	PARAMS4(int, guin, int, objn, int, item, char *, buffer);
+	params._result = AGS3::ListBoxGetItemText(guin, objn, item, buffer);
+}
 
-void GlobalAPI::ListBoxGetNumItems(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxGetNumItems(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, objn);
+	params._result = AGS3::ListBoxGetNumItems(guin, objn);
+}
 
-void GlobalAPI::ListBoxGetSelected(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxGetSelected(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, objn);
+	params._result = AGS3::ListBoxGetSelected(guin, objn);
+}
 
-void GlobalAPI::ListBoxRemove(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxRemove(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, itemIndex);
+	AGS3::ListBoxRemove(guin, objn, itemIndex);
+}
 
-void GlobalAPI::ListBoxSaveGameList(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxSaveGameList(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, objn);
+	params._result = AGS3::ListBoxSaveGameList(guin, objn);
+}
 
-void GlobalAPI::ListBoxSetSelected(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxSetSelected(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, newsel);
+	AGS3::ListBoxSetSelected(guin, objn, newsel);
+}
 
-void GlobalAPI::ListBoxSetTopItem(ScriptMethodParams &params) {}
+void GlobalAPI::ListBoxSetTopItem(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, item);
+	AGS3::ListBoxSetTopItem(guin, objn, item);
+}
 
-void GlobalAPI::LoadImageFile(ScriptMethodParams &params) {}
+void GlobalAPI::LoadImageFile(ScriptMethodParams &params) {
+	PARAMS1(const char *, filename);
+	params._result = AGS3::LoadImageFile(filename);
+}
 
-void GlobalAPI::LoadSaveSlotScreenshot(ScriptMethodParams &params) {}
+void GlobalAPI::LoadSaveSlotScreenshot(ScriptMethodParams &params) {
+	PARAMS3(int, slnum, int, width, int, height);
+	params._result = AGS3::LoadSaveSlotScreenshot(slnum, width, height);
+}
 
-void GlobalAPI::lose_inventory(ScriptMethodParams &params) {}
+void GlobalAPI::lose_inventory(ScriptMethodParams &params) {
+	PARAMS1(int, inum);
+	AGS3::lose_inventory(inum);
+}
 
-void GlobalAPI::LoseInventoryFromCharacter(ScriptMethodParams &params) {}
+void GlobalAPI::LoseInventoryFromCharacter(ScriptMethodParams &params) {
+	PARAMS2(int, charid, int, inum);
+	AGS3::LoseInventoryFromCharacter(charid, inum);
+}
 
-void GlobalAPI::MergeObject(ScriptMethodParams &params) {}
+void GlobalAPI::MergeObject(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	AGS3::MergeObject(obj);
+}
 
-void GlobalAPI::MoveCharacter(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacter(ScriptMethodParams &params) {
+	PARAMS3(int, cc, int, xx, int, yy);
+	AGS3::MoveCharacter(cc, xx, yy);
+}
 
-void GlobalAPI::MoveCharacterBlocking(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacterBlocking(ScriptMethodParams &params) {
+	PARAMS4(int, chaa, int, xx, int, yy, int, direct);
+	params._result = AGS3::MoveCharacterBlocking(chaa, xx, yy, direct);
+}
 
-void GlobalAPI::MoveCharacterDirect(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacterDirect(ScriptMethodParams &params) {
+	PARAMS3(int, cc, int, xx, int, yy);
+	AGS3::MoveCharacterDirect(cc, xx, yy);
+}
 
-void GlobalAPI::MoveCharacterPath(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacterPath(ScriptMethodParams &params) {
+	PARAMS3(int, chac, int, tox, int, toy);
+	AGS3::MoveCharacterPath(chac, tox, toy);
+}
 
-void GlobalAPI::MoveCharacterStraight(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacterStraight(ScriptMethodParams &params) {
+	PARAMS3(int, cc, int, xx, int, yy);
+	AGS3::MoveCharacterStraight(cc, xx, yy);
+}
 
-void GlobalAPI::MoveCharacterToHotspot(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacterToHotspot(ScriptMethodParams &params) {
+	PARAMS2(int, chaa, int, hotsp);
+	AGS3::MoveCharacterToHotspot(chaa, hotsp);
+}
 
-void GlobalAPI::MoveCharacterToObject(ScriptMethodParams &params) {}
+void GlobalAPI::MoveCharacterToObject(ScriptMethodParams &params) {
+	PARAMS2(int, chaa, int, obbj);
+	AGS3::MoveCharacterToObject(chaa, obbj);
+}
 
-void GlobalAPI::MoveObject(ScriptMethodParams &params) {}
+void GlobalAPI::MoveObject(ScriptMethodParams &params) {
+	PARAMS4(int, obj, int, xx, int, yy, int, spp);
+	AGS3::MoveObject(obj, xx, yy, spp);
+}
 
-void GlobalAPI::MoveObjectDirect(ScriptMethodParams &params) {}
+void GlobalAPI::MoveObjectDirect(ScriptMethodParams &params) {
+	PARAMS4(int, obj, int, xx, int, yy, int, spp);
+	AGS3::MoveObjectDirect(obj, xx, yy, spp);
+}
 
-void GlobalAPI::MoveOverlay(ScriptMethodParams &params) {}
+void GlobalAPI::MoveOverlay(ScriptMethodParams &params) {
+	PARAMS3(int, ovrid, int, newx, int, newy);
+	AGS3::MoveOverlay(ovrid, newx, newy);
+}
 
-void GlobalAPI::MoveToWalkableArea(ScriptMethodParams &params) {}
+void GlobalAPI::MoveToWalkableArea(ScriptMethodParams &params) {
+	PARAMS1(int, charid);
+	AGS3::MoveToWalkableArea(charid);
+}
 
-void GlobalAPI::NewRoom(ScriptMethodParams &params) {}
+void GlobalAPI::NewRoom(ScriptMethodParams &params) {
+	PARAMS1(int, nrnum);
+	AGS3::NewRoom(nrnum);
+}
 
-void GlobalAPI::NewRoomEx(ScriptMethodParams &params) {}
+void GlobalAPI::NewRoomEx(ScriptMethodParams &params) {
+	PARAMS3(int, nrnum, int, newx, int, newy);
+	AGS3::NewRoomEx(nrnum, newx, newy);
+}
 
-void GlobalAPI::NewRoomNPC(ScriptMethodParams &params) {}
+void GlobalAPI::NewRoomNPC(ScriptMethodParams &params) {
+	PARAMS4(int, charid, int, nrnum, int, newx, int, newy);
+	AGS3::NewRoomNPC(charid, nrnum, newx, newy);
+}
 
-void GlobalAPI::ObjectOff(ScriptMethodParams &params) {}
+void GlobalAPI::ObjectOff(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	AGS3::ObjectOff(obj);
+}
 
-void GlobalAPI::ObjectOn(ScriptMethodParams &params) {}
+void GlobalAPI::ObjectOn(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	AGS3::ObjectOn(obj);
+}
 
-void GlobalAPI::ParseText(ScriptMethodParams &params) {}
+void GlobalAPI::ParseText(ScriptMethodParams &params) {
+	PARAMS1(const char *, text);
+	AGS3::ParseText(text);
+}
 
-void GlobalAPI::PauseGame(ScriptMethodParams &params) {}
+void GlobalAPI::PauseGame(ScriptMethodParams &params) {
+	AGS3::PauseGame();
+}
 
-void GlobalAPI::PlayAmbientSound(ScriptMethodParams &params) {}
+void GlobalAPI::PlayAmbientSound(ScriptMethodParams &params) {
+	PARAMS5(int, channel, int, sndnum, int, vol, int, x, int, y);
+	AGS3::PlayAmbientSound(channel, sndnum, vol, x, y);
+}
 
-void GlobalAPI::play_flc_file(ScriptMethodParams &params) {}
+void GlobalAPI::play_flc_file(ScriptMethodParams &params) {
+	PARAMS2(int, numb, int, playflags);
+	params._result = AGS3::play_flc_file(numb, playflags);
+}
 
-void GlobalAPI::PlayMP3File(ScriptMethodParams &params) {}
+void GlobalAPI::PlayMP3File(ScriptMethodParams &params) {
+	PARAMS1(const char *, filename);
+	AGS3::PlayMP3File(filename);
+}
 
-void GlobalAPI::PlayMusicResetQueue(ScriptMethodParams &params) {}
+void GlobalAPI::PlayMusicResetQueue(ScriptMethodParams &params) {
+	PARAMS1(int, newmus);
+	AGS3::PlayMusicResetQueue(newmus);
+}
 
-void GlobalAPI::PlayMusicQueued(ScriptMethodParams &params) {}
+void GlobalAPI::PlayMusicQueued(ScriptMethodParams &params) {
+	PARAMS1(int, musnum);
+	AGS3::PlayMusicQueued(musnum);
+}
 
-void GlobalAPI::PlaySilentMIDI(ScriptMethodParams &params) {}
+void GlobalAPI::PlaySilentMIDI(ScriptMethodParams &params) {
+	PARAMS1(int, musnum);
+	AGS3::PlaySilentMIDI(musnum);
+}
 
-void GlobalAPI::play_sound(ScriptMethodParams &params) {}
+void GlobalAPI::play_sound(ScriptMethodParams &params) {
+	PARAMS1(int, sndnum);
+	params._result = AGS3::play_sound(sndnum);
+}
 
-void GlobalAPI::PlaySoundEx(ScriptMethodParams &params) {}
+void GlobalAPI::PlaySoundEx(ScriptMethodParams &params) {
+	PARAMS2(int, sndnum, int, channel);
+	params._result = AGS3::PlaySoundEx(sndnum, channel);
+}
 
-void GlobalAPI::scrPlayVideo(ScriptMethodParams &params) {}
+void GlobalAPI::scrPlayVideo(ScriptMethodParams &params) {
+	PARAMS3(const char *, name, int, skip, int, flags);
+	AGS3::scrPlayVideo(name, skip, flags);
+}
 
-void GlobalAPI::RoomProcessClick(ScriptMethodParams &params) {}
+void GlobalAPI::RoomProcessClick(ScriptMethodParams &params) {
+	PARAMS3(int, xx, int, yy, int, mood);
+	AGS3::RoomProcessClick(xx, yy, mood);
+}
 
-void GlobalAPI::QuitGame(ScriptMethodParams &params) {}
+void GlobalAPI::QuitGame(ScriptMethodParams &params) {
+	PARAMS1(int, dialog);
+	AGS3::QuitGame(dialog);
+}
 
-void GlobalAPI::__Rand(ScriptMethodParams &params) {}
+void GlobalAPI::__Rand(ScriptMethodParams &params) {
+	PARAMS1(int, upto);
+	params._result = AGS3::__Rand(upto);
+}
 
-void GlobalAPI::RawClear(ScriptMethodParams &params) {}
+void GlobalAPI::RawClear(ScriptMethodParams &params) {
+	PARAMS1(int, clr);
+	AGS3::RawClear(clr);
+}
 
-void GlobalAPI::RawDrawCircle(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawCircle(ScriptMethodParams &params) {
+	PARAMS3(int, xx, int, yy, int, rad);
+	AGS3::RawDrawCircle(xx, yy, rad);
+}
 
-void GlobalAPI::RawDrawFrameTransparent(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawFrameTransparent(ScriptMethodParams &params) {
+	PARAMS2(int, frame, int, translev);
+	AGS3::RawDrawFrameTransparent(frame, translev);
+}
 
-void GlobalAPI::RawDrawImage(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawImage(ScriptMethodParams &params) {
+	PARAMS3(int, xx, int, yy, int, slot);
+	AGS3::RawDrawImage(xx, yy, slot);
+}
 
-void GlobalAPI::RawDrawImageOffset(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawImageOffset(ScriptMethodParams &params) {
+	PARAMS3(int, xx, int, yy, int, slot);
+	AGS3::RawDrawImageOffset(xx, yy, slot);
+}
 
-void GlobalAPI::RawDrawImageResized(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawImageResized(ScriptMethodParams &params) {
+	PARAMS5(int, xx, int, yy, int, gotSlot, int, width, int, height);
+	AGS3::RawDrawImageResized(xx, yy, gotSlot, width, height);
+}
 
-void GlobalAPI::RawDrawImageTransparent(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawImageTransparent(ScriptMethodParams &params) {
+	PARAMS4(int, xx, int, yy, int, slot, int, opacity);
+	AGS3::RawDrawImageTransparent(xx, yy, slot, opacity);
+}
 
-void GlobalAPI::RawDrawLine(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawLine(ScriptMethodParams &params) {
+	PARAMS4(int, fromx, int, fromy, int, tox, int, toy);
+	AGS3::RawDrawLine(fromx, fromy, tox, toy);
+}
 
-void GlobalAPI::RawDrawRectangle(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawRectangle(ScriptMethodParams &params) {
+	PARAMS4(int, x1, int, y1, int, x2, int, y2);
+	AGS3::RawDrawRectangle(x1, y1, x2, y2);
+}
 
-void GlobalAPI::RawDrawTriangle(ScriptMethodParams &params) {}
+void GlobalAPI::RawDrawTriangle(ScriptMethodParams &params) {
+	PARAMS6(int, x1, int, y1, int, x2, int, y2, int, x3, int, y3);
+	AGS3::RawDrawTriangle(x1, y1, x2, y2, x3, y3);
+}
 
 void GlobalAPI::ScPl_RawPrint(ScriptMethodParams &params) {
 	PARAMS2(int, xx, int, yy);
@@ -1131,238 +1468,572 @@ void GlobalAPI::ScPl_RawPrint(ScriptMethodParams &params) {
 	AGS3::RawPrint(xx, yy, texx.c_str());
 }
 
-void GlobalAPI::RawPrintMessageWrapped(ScriptMethodParams &params) {}
+void GlobalAPI::RawPrintMessageWrapped(ScriptMethodParams &params) {
+	PARAMS5(int, xx, int, yy, int, wid, int, font, int, msgm);
+	AGS3::RawPrintMessageWrapped(xx, yy, wid, font, msgm);
+}
 
-void GlobalAPI::RawRestoreScreen(ScriptMethodParams &params) {}
+void GlobalAPI::RawRestoreScreen(ScriptMethodParams &params) {
+	AGS3::RawRestoreScreen();
+}
 
-void GlobalAPI::RawRestoreScreenTinted(ScriptMethodParams &params) {}
+void GlobalAPI::RawRestoreScreenTinted(ScriptMethodParams &params) {
+	PARAMS4(int, red, int, green, int, blue, int, opacity);
+	AGS3::RawRestoreScreenTinted(red, green, blue, opacity);
+}
 
-void GlobalAPI::RawSaveScreen(ScriptMethodParams &params) {}
+void GlobalAPI::RawSaveScreen(ScriptMethodParams &params) {
+	AGS3::RawSaveScreen();
+}
 
-void GlobalAPI::RawSetColor(ScriptMethodParams &params) {}
+void GlobalAPI::RawSetColor(ScriptMethodParams &params) {
+	PARAMS1(int, clr);
+	AGS3::RawSetColor(clr);
+}
 
-void GlobalAPI::RawSetColorRGB(ScriptMethodParams &params) {}
+void GlobalAPI::RawSetColorRGB(ScriptMethodParams &params) {
+	PARAMS3(int, red, int, grn, int, blu);
+	AGS3::RawSetColorRGB(red, grn, blu);
+}
 
-void GlobalAPI::RefreshMouse(ScriptMethodParams &params) {}
+void GlobalAPI::RefreshMouse(ScriptMethodParams &params) {
+	AGS3::RefreshMouse();
+}
 
-void GlobalAPI::ReleaseCharacterView(ScriptMethodParams &params) {}
+void GlobalAPI::ReleaseCharacterView(ScriptMethodParams &params) {
+	PARAMS1(int, chat);
+	AGS3::ReleaseCharacterView(chat);
+}
 
-void GlobalAPI::ReleaseViewport(ScriptMethodParams &params) {}
+void GlobalAPI::ReleaseViewport(ScriptMethodParams &params) {
+	AGS3::ReleaseViewport();
+}
 
-void GlobalAPI::RemoveObjectTint(ScriptMethodParams &params) {}
+void GlobalAPI::RemoveObjectTint(ScriptMethodParams &params) {
+	PARAMS1(int, obj);
+	AGS3::RemoveObjectTint(obj);
+}
 
-void GlobalAPI::RemoveOverlay(ScriptMethodParams &params) {}
+void GlobalAPI::RemoveOverlay(ScriptMethodParams &params) {
+	PARAMS1(int, ovrid);
+	AGS3::RemoveOverlay(ovrid);
+}
 
-void GlobalAPI::RemoveWalkableArea(ScriptMethodParams &params) {}
+void GlobalAPI::RemoveWalkableArea(ScriptMethodParams &params) {
+	PARAMS1(int, areanum);
+	AGS3::RemoveWalkableArea(areanum);
+}
 
-void GlobalAPI::ResetRoom(ScriptMethodParams &params) {}
+void GlobalAPI::ResetRoom(ScriptMethodParams &params) {
+	PARAMS1(int, nrnum);
+	AGS3::ResetRoom(nrnum);
+}
 
-void GlobalAPI::restart_game(ScriptMethodParams &params) {}
+void GlobalAPI::restart_game(ScriptMethodParams &params) {
+	AGS3::restart_game();
+}
 
-void GlobalAPI::restore_game_dialog(ScriptMethodParams &params) {}
+void GlobalAPI::restore_game_dialog(ScriptMethodParams &params) {
+	AGS3::restore_game_dialog();
+}
 
-void GlobalAPI::RestoreGameSlot(ScriptMethodParams &params) {}
+void GlobalAPI::RestoreGameSlot(ScriptMethodParams &params) {
+	PARAMS1(int, slnum);
+	AGS3::RestoreGameSlot(slnum);
+}
 
-void GlobalAPI::RestoreWalkableArea(ScriptMethodParams &params) {}
+void GlobalAPI::RestoreWalkableArea(ScriptMethodParams &params) {
+	PARAMS1(int, areanum);
+	AGS3::RestoreWalkableArea(areanum);
+}
 
-void GlobalAPI::RunAGSGame(ScriptMethodParams &params) {}
+void GlobalAPI::RunAGSGame(ScriptMethodParams &params) {
+	PARAMS3(const char *, newgame, unsigned int, mode, int, data);
+	params._result = AGS3::RunAGSGame(newgame, mode, data);
+}
 
-void GlobalAPI::RunCharacterInteraction(ScriptMethodParams &params) {}
+void GlobalAPI::RunCharacterInteraction(ScriptMethodParams &params) {
+	PARAMS2(int, cc, int, mood);
+	AGS3::RunCharacterInteraction(cc, mood);
+}
 
-void GlobalAPI::RunDialog(ScriptMethodParams &params) {}
+void GlobalAPI::RunDialog(ScriptMethodParams &params) {
+	PARAMS1(int, tum);
+	AGS3::RunDialog(tum);
+}
 
-void GlobalAPI::RunHotspotInteraction(ScriptMethodParams &params) {}
+void GlobalAPI::RunHotspotInteraction(ScriptMethodParams &params) {
+	PARAMS2(int, hotspothere, int, mood);
+	AGS3::RunHotspotInteraction(hotspothere, mood);
+}
 
-void GlobalAPI::RunInventoryInteraction(ScriptMethodParams &params) {}
+void GlobalAPI::RunInventoryInteraction(ScriptMethodParams &params) {
+	PARAMS2(int, iit, int, modd);
+	AGS3::RunInventoryInteraction(iit, modd);
+}
 
-void GlobalAPI::RunObjectInteraction(ScriptMethodParams &params) {}
+void GlobalAPI::RunObjectInteraction(ScriptMethodParams &params) {
+	PARAMS2(int, aa, int, mood);
+	AGS3::RunObjectInteraction(aa, mood);
+}
 
-void GlobalAPI::RunRegionInteraction(ScriptMethodParams &params) {}
+void GlobalAPI::RunRegionInteraction(ScriptMethodParams &params) {
+	PARAMS2(int, regnum, int, mood);
+	AGS3::RunRegionInteraction(regnum, mood);
+}
 
-void GlobalAPI::Said(ScriptMethodParams &params) {}
+void GlobalAPI::Said(ScriptMethodParams &params) {
+	PARAMS1(const char *, checkwords);
+	params._result = AGS3::Said(checkwords);
+}
 
-void GlobalAPI::SaidUnknownWord(ScriptMethodParams &params) {}
+void GlobalAPI::SaidUnknownWord(ScriptMethodParams &params) {
+	PARAMS1(char *, buffer);
+	params._result = AGS3::SaidUnknownWord(buffer);
+}
 
-void GlobalAPI::SaveCursorForLocationChange(ScriptMethodParams &params) {}
+void GlobalAPI::SaveCursorForLocationChange(ScriptMethodParams &params) {
+	AGS3::SaveCursorForLocationChange();
+}
 
-void GlobalAPI::save_game_dialog(ScriptMethodParams &params) {}
+void GlobalAPI::save_game_dialog(ScriptMethodParams &params) {
+	AGS3::save_game_dialog();
+}
 
-void GlobalAPI::save_game(ScriptMethodParams &params) {}
+void GlobalAPI::save_game(ScriptMethodParams &params) {
+	PARAMS2(int, slotn, const char *, descript);
+	AGS3::save_game(slotn, descript);
+}
 
-void GlobalAPI::SaveScreenShot(ScriptMethodParams &params) {}
+void GlobalAPI::SaveScreenShot(ScriptMethodParams &params) {
+	PARAMS1(const char *, namm);
+	params._result = AGS3::SaveScreenShot(namm);
+}
 
-void GlobalAPI::SeekMIDIPosition(ScriptMethodParams &params) {}
+void GlobalAPI::SeekMIDIPosition(ScriptMethodParams &params) {
+	PARAMS1(int, position);
+	AGS3::SeekMIDIPosition(position);
+}
 
-void GlobalAPI::SeekMODPattern(ScriptMethodParams &params) {}
+void GlobalAPI::SeekMODPattern(ScriptMethodParams &params) {
+	PARAMS1(int, patnum);
+	AGS3::SeekMODPattern(patnum);
+}
 
-void GlobalAPI::SeekMP3PosMillis(ScriptMethodParams &params) {}
+void GlobalAPI::SeekMP3PosMillis(ScriptMethodParams &params) {
+	PARAMS1(int, position);
+	AGS3::SeekMP3PosMillis(position);
+}
 
-void GlobalAPI::SetActiveInventory(ScriptMethodParams &params) {}
+void GlobalAPI::SetActiveInventory(ScriptMethodParams &params) {
+	PARAMS1(int, iit);
+	AGS3::SetActiveInventory(iit);
+}
 
-void GlobalAPI::SetAmbientTint(ScriptMethodParams &params) {}
+void GlobalAPI::SetAmbientTint(ScriptMethodParams &params) {
+	PARAMS5(int, red, int, green, int, blue, int, opacity, int, luminance);
+	AGS3::SetAmbientTint(red, green, blue, opacity, luminance);
+}
 
-void GlobalAPI::SetAreaLightLevel(ScriptMethodParams &params) {}
+void GlobalAPI::SetAreaLightLevel(ScriptMethodParams &params) {
+	PARAMS2(int, area, int, brightness);
+	AGS3::SetAreaLightLevel(area, brightness);
+}
 
-void GlobalAPI::SetAreaScaling(ScriptMethodParams &params) {}
+void GlobalAPI::SetAreaScaling(ScriptMethodParams &params) {
+	PARAMS3(int, area, int, min, int, max);
+	AGS3::SetAreaScaling(area, min, max);
+}
 
-void GlobalAPI::SetBackgroundFrame(ScriptMethodParams &params) {}
+void GlobalAPI::SetBackgroundFrame(ScriptMethodParams &params) {
+	PARAMS1(int, frnum);
+	AGS3::SetBackgroundFrame(frnum);
+}
 
-void GlobalAPI::SetButtonPic(ScriptMethodParams &params) {}
+void GlobalAPI::SetButtonPic(ScriptMethodParams &params) {
+	PARAMS4(int, guin, int, objn, int, ptype, int, slotn);
+	AGS3::SetButtonPic(guin, objn, ptype, slotn);
+}
 
-void GlobalAPI::SetButtonText(ScriptMethodParams &params) {}
+void GlobalAPI::SetButtonText(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, const char *, newtx);
+	AGS3::SetButtonText(guin, objn, newtx);
+}
 
-void GlobalAPI::SetChannelVolume(ScriptMethodParams &params) {}
+void GlobalAPI::SetChannelVolume(ScriptMethodParams &params) {
+	PARAMS2(int, chan, int, newvol);
+	AGS3::SetChannelVolume(chan, newvol);
+}
 
-void GlobalAPI::SetCharacterBaseline(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterBaseline(ScriptMethodParams &params) {
+	PARAMS2(int, obn, int, basel);
+	AGS3::SetCharacterBaseline(obn, basel);
+}
 
-void GlobalAPI::SetCharacterClickable(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterClickable(ScriptMethodParams &params) {
+	PARAMS2(int, cha, int, clik);
+	AGS3::SetCharacterClickable(cha, clik);
+}
 
-void GlobalAPI::SetCharacterFrame(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterFrame(ScriptMethodParams &params) {
+	PARAMS4(int, chaa, int, view, int, loop, int, frame);
+	AGS3::SetCharacterFrame(chaa, view, loop, frame);
+}
 
-void GlobalAPI::SetCharacterIdle(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterIdle(ScriptMethodParams &params) {
+	PARAMS3(int, who, int, iview, int, itime);
+	AGS3::SetCharacterIdle(who, iview, itime);
+}
+
+void GlobalAPI::SetCharacterIgnoreLight(ScriptMethodParams &params) {
+	PARAMS2(int, who, int, yesorno);
+	AGS3::SetCharacterIgnoreLight(who, yesorno);
+}
+
+void GlobalAPI::SetCharacterIgnoreWalkbehinds(ScriptMethodParams &params) {
+	PARAMS2(int, cha, int, clik);
+	AGS3::SetCharacterIgnoreWalkbehinds(cha, clik);
+}
 
-void GlobalAPI::SetCharacterIgnoreLight(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterProperty(ScriptMethodParams &params) {
+	PARAMS3(int, who, int, flag, int, yesorno);
+	AGS3::SetCharacterProperty(who, flag, yesorno);
+}
 
-void GlobalAPI::SetCharacterIgnoreWalkbehinds(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterBlinkView(ScriptMethodParams &params) {
+	PARAMS3(int, chaa, int, vii, int, intrv);
+	AGS3::SetCharacterBlinkView(chaa, vii, intrv);
+}
 
-void GlobalAPI::SetCharacterProperty(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterSpeechView(ScriptMethodParams &params) {
+	PARAMS2(int, chaa, int, vii);
+	AGS3::SetCharacterSpeechView(chaa, vii);
+}
 
-void GlobalAPI::SetCharacterBlinkView(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterSpeed(ScriptMethodParams &params) {
+	PARAMS2(int, chaa, int, nspeed);
+	AGS3::SetCharacterSpeed(chaa, nspeed);
+}
 
-void GlobalAPI::SetCharacterSpeechView(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterSpeedEx(ScriptMethodParams &params) {
+	PARAMS3(int, chaa, int, xspeed, int, yspeed);
+	AGS3::SetCharacterSpeedEx(chaa, xspeed, yspeed);
+}
 
-void GlobalAPI::SetCharacterSpeed(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterTransparency(ScriptMethodParams &params) {
+	PARAMS2(int, obn, int, trans);
+	AGS3::SetCharacterTransparency(obn, trans);
+}
 
-void GlobalAPI::SetCharacterSpeedEx(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterView(ScriptMethodParams &params) {
+	PARAMS2(int, chaa, int, vii);
+	AGS3::SetCharacterView(chaa, vii);
+}
 
-void GlobalAPI::SetCharacterTransparency(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterViewEx(ScriptMethodParams &params) {
+	PARAMS4(int, chaa, int, vii, int, loop, int, align);
+	AGS3::SetCharacterViewEx(chaa, vii, loop, align);
+}
 
-void GlobalAPI::SetCharacterView(ScriptMethodParams &params) {}
+void GlobalAPI::SetCharacterViewOffset(ScriptMethodParams &params) {
+	PARAMS4(int, chaa, int, vii, int, xoffs, int, yoffs);
+	AGS3::SetCharacterViewOffset(chaa, vii, xoffs, yoffs);
+}
 
-void GlobalAPI::SetCharacterViewEx(ScriptMethodParams &params) {}
+void GlobalAPI::set_cursor_mode(ScriptMethodParams &params) {
+	PARAMS1(int, mode);
+	AGS3::set_cursor_mode(mode);
+}
 
-void GlobalAPI::SetCharacterViewOffset(ScriptMethodParams &params) {}
+void GlobalAPI::set_default_cursor(ScriptMethodParams &params) {
+	AGS3::set_default_cursor();
+}
 
-void GlobalAPI::set_cursor_mode(ScriptMethodParams &params) {}
+void GlobalAPI::SetDialogOption(ScriptMethodParams &params) {
+	PARAMS3(int, dlg, int, opt, int, onoroff);
+	bool dlg_script = params.size() == 3 ? false : params[3];
 
-void GlobalAPI::set_default_cursor(ScriptMethodParams &params) {}
+	AGS3::SetDialogOption(dlg, opt, onoroff, dlg_script);
+}
 
-void GlobalAPI::SetDialogOption(ScriptMethodParams &params) {}
+void GlobalAPI::SetDigitalMasterVolume(ScriptMethodParams &params) {
+	PARAMS1(int, newvol);
+	AGS3::SetDigitalMasterVolume(newvol);
+}
 
-void GlobalAPI::SetDigitalMasterVolume(ScriptMethodParams &params) {}
+void GlobalAPI::SetFadeColor(ScriptMethodParams &params) {
+	PARAMS3(int, red, int, green, int, blue);
+	AGS3::SetFadeColor(red, green, blue);
+}
 
-void GlobalAPI::SetFadeColor(ScriptMethodParams &params) {}
+void GlobalAPI::SetFrameSound(ScriptMethodParams &params) {
+	PARAMS4(int, vii, int, loop, int, frame, int, sound);
+	AGS3::SetFrameSound(vii, loop, frame, sound);
+}
 
-void GlobalAPI::SetFrameSound(ScriptMethodParams &params) {}
+void GlobalAPI::SetGameOption(ScriptMethodParams &params) {
+	PARAMS2(int, opt, int, setting);
+	AGS3::SetGameOption(opt, setting);
+}
 
-void GlobalAPI::SetGameOption(ScriptMethodParams &params) {}
+void GlobalAPI::SetGameSpeed(ScriptMethodParams &params) {
+	PARAMS1(int, newSpeed);
+	AGS3::SetGameSpeed(newSpeed);
+}
 
-void GlobalAPI::SetGameSpeed(ScriptMethodParams &params) {}
+void GlobalAPI::SetGlobalInt(ScriptMethodParams &params) {
+	PARAMS2(int, index, int, newval);
+	AGS3::SetGlobalInt(index, newval);
+}
 
-void GlobalAPI::SetGlobalInt(ScriptMethodParams &params) {}
+void GlobalAPI::SetGlobalString(ScriptMethodParams &params) {
+	PARAMS2(int, index, const char *, newval);
+	AGS3::SetGlobalString(index, newval);
+}
 
-void GlobalAPI::SetGlobalString(ScriptMethodParams &params) {}
+void GlobalAPI::SetGraphicalVariable(ScriptMethodParams &params) {
+	PARAMS2(const char *, varName, int, p_value);
+	AGS3::SetGraphicalVariable(varName, p_value);
+}
 
-void GlobalAPI::SetGraphicalVariable(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIBackgroundPic(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, slotn);
+	AGS3::SetGUIBackgroundPic(guin, slotn);
+}
 
-void GlobalAPI::SetGUIBackgroundPic(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIClickable(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, clickable);
+	AGS3::SetGUIClickable(guin, clickable);
+}
 
-void GlobalAPI::SetGUIClickable(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIObjectEnabled(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, enabled);
+	AGS3::SetGUIObjectEnabled(guin, objn, enabled);
+}
 
-void GlobalAPI::SetGUIObjectEnabled(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIObjectPosition(ScriptMethodParams &params) {
+	PARAMS4(int, guin, int, objn, int, xx, int, yy);
+	AGS3::SetGUIObjectPosition(guin, objn, xx, yy);
+}
 
-void GlobalAPI::SetGUIObjectPosition(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIObjectSize(ScriptMethodParams &params) {
+	PARAMS4(int, ifn, int, objn, int, newwid, int, newhit);
+	AGS3::SetGUIObjectSize(ifn, objn, newwid, newhit);
+}
 
-void GlobalAPI::SetGUIObjectSize(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIPosition(ScriptMethodParams &params) {
+	PARAMS3(int, ifn, int, xx, int, yy);
+	AGS3::SetGUIPosition(ifn, xx, yy);
+}
 
-void GlobalAPI::SetGUIPosition(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUISize(ScriptMethodParams &params) {
+	PARAMS3(int, ifn, int, widd, int, hitt);
+	AGS3::SetGUISize(ifn, widd, hitt);
+}
 
-void GlobalAPI::SetGUISize(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUITransparency(ScriptMethodParams &params) {
+	PARAMS2(int, ifn, int, trans);
+	AGS3::SetGUITransparency(ifn, trans);
+}
 
-void GlobalAPI::SetGUITransparency(ScriptMethodParams &params) {}
+void GlobalAPI::SetGUIZOrder(ScriptMethodParams &params) {
+	PARAMS2(int, guin, int, z);
+	AGS3::SetGUIZOrder(guin, z);
+}
 
-void GlobalAPI::SetGUIZOrder(ScriptMethodParams &params) {}
+void GlobalAPI::SetInvItemName(ScriptMethodParams &params) {
+	PARAMS2(int, invi, const char *, newName);
+	AGS3::SetInvItemName(invi, newName);
+}
 
-void GlobalAPI::SetInvItemName(ScriptMethodParams &params) {}
+void GlobalAPI::set_inv_item_pic(ScriptMethodParams &params) {
+	PARAMS2(int, invi, int, piccy);
+	AGS3::set_inv_item_pic(invi, piccy);
+}
 
-void GlobalAPI::set_inv_item_pic(ScriptMethodParams &params) {}
+void GlobalAPI::SetInvDimensions(ScriptMethodParams &params) {
+	PARAMS2(int, ww, int, hh);
+	AGS3::SetInvDimensions(ww, hh);
+}
 
-void GlobalAPI::SetInvDimensions(ScriptMethodParams &params) {}
+void GlobalAPI::SetLabelColor(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, colr);
+	AGS3::SetLabelColor(guin, objn, colr);
+}
 
-void GlobalAPI::SetLabelColor(ScriptMethodParams &params) {}
+void GlobalAPI::SetLabelFont(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, fontnum);
+	AGS3::SetLabelFont(guin, objn, fontnum);
+}
 
-void GlobalAPI::SetLabelFont(ScriptMethodParams &params) {}
+void GlobalAPI::SetLabelText(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, const char *, newtx);
+	AGS3::SetLabelText(guin, objn, newtx);
+}
 
-void GlobalAPI::SetLabelText(ScriptMethodParams &params) {}
+void GlobalAPI::SetMouseBounds(ScriptMethodParams &params) {
+	PARAMS4(int, x1, int, y1, int, x2, int, y2);
+	AGS3::SetMouseBounds(x1, y1, x2, y2);
+}
 
-void GlobalAPI::SetMouseBounds(ScriptMethodParams &params) {}
+void GlobalAPI::set_mouse_cursor(ScriptMethodParams &params) {
+	PARAMS1(int, newcurs);
+	AGS3::set_mouse_cursor(newcurs);
+}
 
-void GlobalAPI::set_mouse_cursor(ScriptMethodParams &params) {}
+void GlobalAPI::SetMousePosition(ScriptMethodParams &params) {
+	PARAMS2(int, newx, int, newy);
+	AGS3::SetMousePosition(newx, newy);
+}
 
-void GlobalAPI::SetMousePosition(ScriptMethodParams &params) {}
+void GlobalAPI::SetMultitasking(ScriptMethodParams &params) {
+	PARAMS1(int, mode);
+	AGS3::SetMultitasking(mode);
+}
 
-void GlobalAPI::SetMultitasking(ScriptMethodParams &params) {}
+void GlobalAPI::SetMusicMasterVolume(ScriptMethodParams &params) {
+	PARAMS1(int, newvol);
+	AGS3::SetMusicMasterVolume(newvol);
+}
 
-void GlobalAPI::SetMusicMasterVolume(ScriptMethodParams &params) {}
+void GlobalAPI::SetMusicRepeat(ScriptMethodParams &params) {
+	PARAMS1(int, loopflag);
+	AGS3::SetMusicRepeat(loopflag);
+}
 
-void GlobalAPI::SetMusicRepeat(ScriptMethodParams &params) {}
+void GlobalAPI::SetMusicVolume(ScriptMethodParams &params) {
+	PARAMS1(int, newvol);
+	AGS3::SetMusicVolume(newvol);
+}
 
-void GlobalAPI::SetMusicVolume(ScriptMethodParams &params) {}
+void GlobalAPI::SetNextCursor(ScriptMethodParams &params) {
+	AGS3::SetNextCursor();
+}
 
-void GlobalAPI::SetNextCursor(ScriptMethodParams &params) {}
+void GlobalAPI::SetNextScreenTransition(ScriptMethodParams &params) {
+	PARAMS1(int, newtrans);
+	AGS3::SetNextScreenTransition(newtrans);
+}
 
-void GlobalAPI::SetNextScreenTransition(ScriptMethodParams &params) {}
+void GlobalAPI::SetNormalFont(ScriptMethodParams &params) {
+	PARAMS1(int, fontnum);
+	AGS3::SetNormalFont(fontnum);
+}
 
-void GlobalAPI::SetNormalFont(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectBaseline(ScriptMethodParams &params) {
+	PARAMS2(int, obn, int, basel);
+	AGS3::SetObjectBaseline(obn, basel);
+}
 
-void GlobalAPI::SetObjectBaseline(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectClickable(ScriptMethodParams &params) {
+	PARAMS2(int, cha, int, clik);
+	AGS3::SetObjectClickable(cha, clik);
+}
 
-void GlobalAPI::SetObjectClickable(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectFrame(ScriptMethodParams &params) {
+	PARAMS4(int, obn, int, viw, int, lop, int, fra);
+	AGS3::SetObjectFrame(obn, viw, lop, fra);
+}
 
-void GlobalAPI::SetObjectFrame(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectGraphic(ScriptMethodParams &params) {
+	PARAMS2(int, obn, int, slott);
+	AGS3::SetObjectGraphic(obn, slott);
+}
 
-void GlobalAPI::SetObjectGraphic(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectIgnoreWalkbehinds(ScriptMethodParams &params) {
+	PARAMS2(int, cha, int, clik);
+	AGS3::SetObjectIgnoreWalkbehinds(cha, clik);
+}
 
-void GlobalAPI::SetObjectIgnoreWalkbehinds(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectPosition(ScriptMethodParams &params) {
+	PARAMS3(int, objj, int, tox, int, toy);
+	AGS3::SetObjectPosition(objj, tox, toy);
+}
 
-void GlobalAPI::SetObjectPosition(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectTint(ScriptMethodParams &params) {
+	PARAMS6(int, obj, int, red, int, green, int, blue, int, opacity, int, luminance);
+	AGS3::SetObjectTint(obj, red, green, blue, opacity, luminance);
+}
 
-void GlobalAPI::SetObjectTint(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectTransparency(ScriptMethodParams &params) {
+	PARAMS2(int, obn, int, trans);
+	AGS3::SetObjectTransparency(obn, trans);
+}
 
-void GlobalAPI::SetObjectTransparency(ScriptMethodParams &params) {}
+void GlobalAPI::SetObjectView(ScriptMethodParams &params) {
+	PARAMS2(int, obn, int, vii);
+	AGS3::SetObjectView(obn, vii);
+}
 
-void GlobalAPI::SetObjectView(ScriptMethodParams &params) {}
+void GlobalAPI::SetPalRGB(ScriptMethodParams &params) {
+	PARAMS4(int, inndx, int, rr, int, gg, int, bb);
+	AGS3::SetPalRGB(inndx, rr, gg, bb);
+}
 
-void GlobalAPI::SetPalRGB(ScriptMethodParams &params) {}
+void GlobalAPI::SetPlayerCharacter(ScriptMethodParams &params) {
+	PARAMS1(int, newchar);
+	AGS3::SetPlayerCharacter(newchar);
+}
 
-void GlobalAPI::SetPlayerCharacter(ScriptMethodParams &params) {}
+void GlobalAPI::SetRegionTint(ScriptMethodParams &params) {
+	PARAMS5(int, area, int, red, int, green, int, blue, int, amount);
+	int luminance = params.size() == 5 ? 100 : params[5];
 
-void GlobalAPI::SetRegionTint(ScriptMethodParams &params) {}
+	AGS3::SetRegionTint(area, red, green, blue, amount, luminance);
+}
 
-void GlobalAPI::SetRestartPoint(ScriptMethodParams &params) {}
+void GlobalAPI::SetRestartPoint(ScriptMethodParams &params) {
+	AGS3::SetRestartPoint();
+}
 
-void GlobalAPI::SetScreenTransition(ScriptMethodParams &params) {}
+void GlobalAPI::SetScreenTransition(ScriptMethodParams &params) {
+	PARAMS1(int, newtrans);
+	AGS3::SetScreenTransition(newtrans);
+}
 
-void GlobalAPI::SetSkipSpeech(ScriptMethodParams &params) {}
+void GlobalAPI::SetSkipSpeech(ScriptMethodParams &params) {
+	PARAMS1(SkipSpeechStyle, newval);
+	AGS3::SetSkipSpeech(newval);
+}
 
-void GlobalAPI::SetSliderValue(ScriptMethodParams &params) {}
+void GlobalAPI::SetSliderValue(ScriptMethodParams &params) {
+	PARAMS3(int, guin, int, objn, int, valn);
+	AGS3::SetSliderValue(guin, objn, valn);
+}
 
-void GlobalAPI::SetSoundVolume(ScriptMethodParams &params) {}
+void GlobalAPI::SetSoundVolume(ScriptMethodParams &params) {
+	PARAMS1(int, newvol);
+	AGS3::SetSoundVolume(newvol);
+}
 
-void GlobalAPI::SetSpeechFont(ScriptMethodParams &params) {}
+void GlobalAPI::SetSpeechFont(ScriptMethodParams &params) {
+	PARAMS1(int, fontnum);
+	AGS3::SetSpeechFont(fontnum);
+}
 
-void GlobalAPI::SetSpeechStyle(ScriptMethodParams &params) {}
+void GlobalAPI::SetSpeechStyle(ScriptMethodParams &params) {
+	PARAMS1(int, newstyle);
+	AGS3::SetSpeechStyle(newstyle);
+}
 
-void GlobalAPI::SetSpeechVolume(ScriptMethodParams &params) {}
+void GlobalAPI::SetSpeechVolume(ScriptMethodParams &params) {
+	PARAMS1(int, newvol);
+	AGS3::SetSpeechVolume(newvol);
+}
 
-void GlobalAPI::SetTalkingColor(ScriptMethodParams &params) {}
+void GlobalAPI::SetTalkingColor(ScriptMethodParams &params) {
+	PARAMS2(int, chaa, int, ncol);
+	AGS3::SetTalkingColor(chaa, ncol);
+}
 
 void GlobalAPI::SetTextBoxFont(ScriptMethodParams &params) {
-
+	PARAMS3(int, guin, int, objn, int, fontnum);
+	AGS3::SetTextBoxFont(guin, objn, fontnum);
 }
 
 void GlobalAPI::SetTextBoxText(ScriptMethodParams &params) {
-
+	PARAMS3(int, guin, int, objn, const char *, txbuf);
+	AGS3::SetTextBoxText(guin, objn, txbuf);
 }
 
 void GlobalAPI::ScPl_SetTextOverlay(ScriptMethodParams &params) {
@@ -1373,91 +2044,110 @@ void GlobalAPI::ScPl_SetTextOverlay(ScriptMethodParams &params) {
 }
 
 void GlobalAPI::SetTextWindowGUI(ScriptMethodParams &params) {
-
+	PARAMS1(int, guinum);
+	AGS3::SetTextWindowGUI(guinum);
 }
 
 void GlobalAPI::script_SetTimer(ScriptMethodParams &params) {
-
+	PARAMS2(int, tnum, int, timeout);
+	AGS3::script_SetTimer(tnum, timeout);
 }
 
 void GlobalAPI::SetViewport(ScriptMethodParams &params) {
-
+	PARAMS2(int, offsx, int, offsy);
+	AGS3::SetViewport(offsx, offsy);
 }
 
 void GlobalAPI::SetVoiceMode(ScriptMethodParams &params) {
-
+	PARAMS1(int, newmod);
+	AGS3::SetVoiceMode(newmod);
 }
 
 void GlobalAPI::SetWalkBehindBase(ScriptMethodParams &params) {
-
+	PARAMS2(int, wa, int, bl);
+	AGS3::SetWalkBehindBase(wa, bl);
 }
 
 void GlobalAPI::ShakeScreen(ScriptMethodParams &params) {
-
+	PARAMS1(int, severe);
+	AGS3::ShakeScreen(severe);
 }
 
 void GlobalAPI::ShakeScreenBackground(ScriptMethodParams &params) {
-
+	PARAMS3(int, delay, int, amount, int, length);
+	AGS3::ShakeScreenBackground(delay, amount, length);
 }
 
 void GlobalAPI::ShowMouseCursor(ScriptMethodParams &params) {
-
+	AGS3::ShowMouseCursor();
 }
 
 void GlobalAPI::SkipUntilCharacterStops(ScriptMethodParams &params) {
-
+	PARAMS1(int, cc);
+	AGS3::SkipUntilCharacterStops(cc);
 }
 
 void GlobalAPI::StartCutscene(ScriptMethodParams &params) {
-
+	PARAMS1(int, skipwith);
+	AGS3::StartCutscene(skipwith);
 }
 
 void GlobalAPI::scStartRecording(ScriptMethodParams &params) {
-
+	PARAMS1(int, keyToStop);
+	AGS3::scStartRecording(keyToStop);
 }
 
 void GlobalAPI::StopAmbientSound(ScriptMethodParams &params) {
-
+	PARAMS1(int, channel);
+	AGS3::StopAmbientSound(channel);
 }
 
 void GlobalAPI::stop_and_destroy_channel(ScriptMethodParams &params) {
-
+	PARAMS1(int, channel);
+	AGS3::stop_and_destroy_channel(channel);
 }
 
 void GlobalAPI::StopDialog(ScriptMethodParams &params) {
-
+	AGS3::StopDialog();
 }
 
 void GlobalAPI::StopMoving(ScriptMethodParams &params) {
-
+	PARAMS1(int, chaa);
+	AGS3::StopMoving(chaa);
 }
 
 void GlobalAPI::scr_StopMusic(ScriptMethodParams &params) {
-
+	AGS3::scr_StopMusic();
 }
 
 void GlobalAPI::StopObjectMoving(ScriptMethodParams &params) {
-
+	PARAMS1(int, obj);
+	AGS3::StopObjectMoving(obj);
 }
 
 void GlobalAPI::_sc_strcat(ScriptMethodParams &params) {
-
+	PARAMS2(char *, s1, const char *, s2);
+	AGS3::_sc_strcat(s1, s2);
 }
 
 void GlobalAPI::ags_stricmp(ScriptMethodParams &params) {
-
+	PARAMS2(const char *, s1, const char *, s2);
+	params._result = AGS3::ags_stricmp(s1, s2);
 }
 
 void GlobalAPI::strcmp(ScriptMethodParams &params) {
-
+	PARAMS2(const char *, s1, const char *, s2);
+	params._result = ::strcmp(s1, s2);
 }
 
 void GlobalAPI::StrContains(ScriptMethodParams &params) {
-
+	PARAMS2(const char *, s1, const char *, s2);
+	params._result = AGS3::StrContains(s1, s2);
 }
 
 void GlobalAPI::_sc_strcpy(ScriptMethodParams &params) {
-
+	PARAMS2(char *, destt, const char *, text);
+	AGS3::_sc_strcpy(destt, text);
 }
 
 void GlobalAPI::ScPl_sc_sprintf(ScriptMethodParams &params) {
@@ -1468,42 +2158,65 @@ void GlobalAPI::ScPl_sc_sprintf(ScriptMethodParams &params) {
 }
 
 void GlobalAPI::StrGetCharAt(ScriptMethodParams &params) {
+	PARAMS2(const char *, strin, int, posn);
+	params._result = AGS3::StrGetCharAt(strin, posn);
 }
 
 void GlobalAPI::StringToInt(ScriptMethodParams &params) {
+	PARAMS1(const char *, val);
+	params._result = AGS3::StringToInt(val);
 }
 
 void GlobalAPI::strlen(ScriptMethodParams &params) {
+	PARAMS1(const char *, val);
+	params._result = ::strlen(val);
 }
 
 void GlobalAPI::StrSetCharAt(ScriptMethodParams &params) {
+	PARAMS3(char *, strin, int, posn, int, nchar);
+	AGS3::StrSetCharAt(strin, posn, nchar);
 }
 
 void GlobalAPI::_sc_strlower(ScriptMethodParams &params) {
+	PARAMS1(char *, desbuf);
+	AGS3::_sc_strlower(desbuf);
 }
 
 void GlobalAPI::_sc_strupper(ScriptMethodParams &params) {
+	PARAMS1(char *, desbuf);
+	AGS3::_sc_strupper(desbuf);
 }
 
 void GlobalAPI::TintScreen(ScriptMethodParams &params) {
+	PARAMS3(int, red, int, grn, int, blu);
+	AGS3::TintScreen(red, grn, blu);
 }
 
 void GlobalAPI::UnPauseGame(ScriptMethodParams &params) {
+	AGS3::UnPauseGame();
 }
 
 void GlobalAPI::update_invorder(ScriptMethodParams &params) {
+	AGS3::update_invorder();
 }
 
 void GlobalAPI::UpdatePalette(ScriptMethodParams &params) {
+	AGS3::UpdatePalette();
 }
 
 void GlobalAPI::scrWait(ScriptMethodParams &params) {
+	PARAMS1(int, nloops);
+	AGS3::scrWait(nloops);
 }
 
 void GlobalAPI::WaitKey(ScriptMethodParams &params) {
+	PARAMS1(int, nloops);
+	params._result = AGS3::WaitKey(nloops);
 }
 
 void GlobalAPI::WaitMouseKey(ScriptMethodParams &params) {
+	PARAMS1(int, nloops);
+	params._result = AGS3::WaitMouseKey(nloops);
 }
 
 } // namespace Core


Commit: 75974c9d42db3c2f41f0fff526b6e6fa45d0250b
    https://github.com/scummvm/scummvm/commit/75974c9d42db3c2f41f0fff526b6e6fa45d0250b
Author: Paul Gilbert (dreammaster at scummvm.org)
Date: 2021-07-17T15:52:11-07:00

Commit Message:
AGS: Added skeleton classes for other plugin interfaces

Changed paths:
  A engines/ags/plugins/core/gui.cpp
  A engines/ags/plugins/core/gui.h
  A engines/ags/plugins/core/gui_control.cpp
  A engines/ags/plugins/core/gui_control.h
  A engines/ags/plugins/core/hotspot.cpp
  A engines/ags/plugins/core/hotspot.h
  A engines/ags/plugins/core/inv_window.cpp
  A engines/ags/plugins/core/inv_window.h
  A engines/ags/plugins/core/inventory_item.cpp
  A engines/ags/plugins/core/inventory_item.h
  A engines/ags/plugins/core/label.cpp
  A engines/ags/plugins/core/label.h
  A engines/ags/plugins/core/listbox.cpp
  A engines/ags/plugins/core/listbox.h
  A engines/ags/plugins/core/math.cpp
  A engines/ags/plugins/core/math.h
  A engines/ags/plugins/core/mouse.cpp
  A engines/ags/plugins/core/mouse.h
  A engines/ags/plugins/core/object.cpp
  A engines/ags/plugins/core/object.h
  A engines/ags/plugins/core/overlay.cpp
  A engines/ags/plugins/core/overlay.h
  A engines/ags/plugins/core/parser.cpp
  A engines/ags/plugins/core/parser.h
  A engines/ags/plugins/core/region.cpp
  A engines/ags/plugins/core/region.h
  A engines/ags/plugins/core/room.cpp
  A engines/ags/plugins/core/room.h
  A engines/ags/plugins/core/slider.cpp
  A engines/ags/plugins/core/slider.h
  A engines/ags/plugins/core/string.cpp
  A engines/ags/plugins/core/string.h
  A engines/ags/plugins/core/system.cpp
  A engines/ags/plugins/core/system.h
  A engines/ags/plugins/core/textbox.cpp
  A engines/ags/plugins/core/textbox.h
  A engines/ags/plugins/core/view_frame.cpp
  A engines/ags/plugins/core/view_frame.h
    engines/ags/module.mk
    engines/ags/plugins/core/core.cpp
    engines/ags/plugins/core/core.h


diff --git a/engines/ags/module.mk b/engines/ags/module.mk
index 3232c38b91..ee391c5917 100644
--- a/engines/ags/module.mk
+++ b/engines/ags/module.mk
@@ -299,6 +299,25 @@ MODULE_OBJS = \
 	plugins/core/file.o \
 	plugins/core/game.o \
 	plugins/core/global_api.o \
+	plugins/core/gui.o \
+	plugins/core/gui_control.o \
+	plugins/core/hotspot.o \
+	plugins/core/inventory_item.o \
+	plugins/core/inv_window.o \
+	plugins/core/label.o \
+	plugins/core/listbox.o \
+	plugins/core/math.o \
+	plugins/core/mouse.o \
+	plugins/core/object.o \
+	plugins/core/overlay.o \
+	plugins/core/parser.o \
+	plugins/core/region.o \
+	plugins/core/room.o \
+	plugins/core/slider.o \
+	plugins/core/string.o \
+	plugins/core/system.o \
+	plugins/core/textbox.o \
+	plugins/core/view_frame.o \
 	plugins/ags_agi/ags_agi.o \
 	plugins/ags_blend/ags_blend.o \
 	plugins/ags_clipboard/ags_clipboard.o \
diff --git a/engines/ags/plugins/core/core.cpp b/engines/ags/plugins/core/core.cpp
index 856b0c444c..9749ae1821 100644
--- a/engines/ags/plugins/core/core.cpp
+++ b/engines/ags/plugins/core/core.cpp
@@ -39,6 +39,25 @@ void EngineExports::AGS_EngineStartup(IAGSEngine *engine) {
 	_file.AGS_EngineStartup(engine);
 	_game.AGS_EngineStartup(engine);
 	_globalAPI.AGS_EngineStartup(engine);
+	_gui.AGS_EngineStartup(engine);
+	_guiControl.AGS_EngineStartup(engine);
+	_hotspot.AGS_EngineStartup(engine);
+	_invWindow.AGS_EngineStartup(engine);
+	_inventoryItem.AGS_EngineStartup(engine);
+	_label.AGS_EngineStartup(engine);
+	_listbox.AGS_EngineStartup(engine);
+	_math.AGS_EngineStartup(engine);
+	_mouse.AGS_EngineStartup(engine);
+	_object.AGS_EngineStartup(engine);
+	_overlay.AGS_EngineStartup(engine);
+	_parser.AGS_EngineStartup(engine);
+	_region.AGS_EngineStartup(engine);
+	_room.AGS_EngineStartup(engine);
+	_slider.AGS_EngineStartup(engine);
+	_string.AGS_EngineStartup(engine);
+	_system.AGS_EngineStartup(engine);
+	_textbox.AGS_EngineStartup(engine);
+	_viewFrame.AGS_EngineStartup(engine);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/core.h b/engines/ags/plugins/core/core.h
index b06a1947e4..3f6ff51c85 100644
--- a/engines/ags/plugins/core/core.h
+++ b/engines/ags/plugins/core/core.h
@@ -35,6 +35,25 @@
 #include "ags/plugins/core/file.h"
 #include "ags/plugins/core/game.h"
 #include "ags/plugins/core/global_api.h"
+#include "ags/plugins/core/gui.h"
+#include "ags/plugins/core/gui_control.h"
+#include "ags/plugins/core/hotspot.h"
+#include "ags/plugins/core/inventory_item.h"
+#include "ags/plugins/core/inv_window.h"
+#include "ags/plugins/core/label.h"
+#include "ags/plugins/core/listbox.h"
+#include "ags/plugins/core/math.h"
+#include "ags/plugins/core/mouse.h"
+#include "ags/plugins/core/object.h"
+#include "ags/plugins/core/overlay.h"
+#include "ags/plugins/core/parser.h"
+#include "ags/plugins/core/region.h"
+#include "ags/plugins/core/room.h"
+#include "ags/plugins/core/slider.h"
+#include "ags/plugins/core/string.h"
+#include "ags/plugins/core/system.h"
+#include "ags/plugins/core/textbox.h"
+#include "ags/plugins/core/view_frame.h"
 
 namespace AGS3 {
 namespace Plugins {
@@ -54,6 +73,25 @@ private:
 	File _file;
 	Game _game;
 	GlobalAPI _globalAPI;
+	GUI _gui;
+	GUIControl _guiControl;
+	Hotspot _hotspot;
+	InvWindow _invWindow;
+	InventoryItem _inventoryItem;
+	Label _label;
+	Listbox _listbox;
+	Math _math;
+	Mouse _mouse;
+	Object _object;
+	Overlay _overlay;
+	Parser _parser;
+	Region _region;
+	Room _room;
+	Slider _slider;
+	String _string;
+	System _system;
+	Textbox _textbox;
+	ViewFrame _viewFrame;
 
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
diff --git a/engines/ags/plugins/core/gui.cpp b/engines/ags/plugins/core/gui.cpp
new file mode 100644
index 0000000000..10f5637b3b
--- /dev/null
+++ b/engines/ags/plugins/core/gui.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/gui.h"
+#include "ags/engine/ac/gui.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void GUI::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/gui.h b/engines/ags/plugins/core/gui.h
new file mode 100644
index 0000000000..9e491fdc6b
--- /dev/null
+++ b/engines/ags/plugins/core/gui.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_GUI_H
+#define AGS_PLUGINS_CORE_GUI_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class GUI : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/gui_control.cpp b/engines/ags/plugins/core/gui_control.cpp
new file mode 100644
index 0000000000..d9ba20fcd4
--- /dev/null
+++ b/engines/ags/plugins/core/gui_control.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/gui_control.h"
+#include "ags/engine/ac/gui_control.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void GUIControl::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/gui_control.h b/engines/ags/plugins/core/gui_control.h
new file mode 100644
index 0000000000..4eb393b002
--- /dev/null
+++ b/engines/ags/plugins/core/gui_control.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_GUI_CONTROL_H
+#define AGS_PLUGINS_CORE_GUI_CONTROL_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class GUIControl : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/hotspot.cpp b/engines/ags/plugins/core/hotspot.cpp
new file mode 100644
index 0000000000..a100c441a8
--- /dev/null
+++ b/engines/ags/plugins/core/hotspot.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/hotspot.h"
+#include "ags/engine/ac/hotspot.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Hotspot::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/hotspot.h b/engines/ags/plugins/core/hotspot.h
new file mode 100644
index 0000000000..2b4379dd7c
--- /dev/null
+++ b/engines/ags/plugins/core/hotspot.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_HOTSPOT_H
+#define AGS_PLUGINS_CORE_HOTSPOT_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Hotspot : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/inv_window.cpp b/engines/ags/plugins/core/inv_window.cpp
new file mode 100644
index 0000000000..d1e60d3e93
--- /dev/null
+++ b/engines/ags/plugins/core/inv_window.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/inv_window.h"
+#include "ags/engine/ac/inv_window.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void InvWindow::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/inv_window.h b/engines/ags/plugins/core/inv_window.h
new file mode 100644
index 0000000000..b1d46f8817
--- /dev/null
+++ b/engines/ags/plugins/core/inv_window.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_INV_WINDOW_H
+#define AGS_PLUGINS_CORE_INV_WINDOW_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class InvWindow : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/inventory_item.cpp b/engines/ags/plugins/core/inventory_item.cpp
new file mode 100644
index 0000000000..c8ba81b533
--- /dev/null
+++ b/engines/ags/plugins/core/inventory_item.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/inventory_item.h"
+#include "ags/engine/ac/inventory_item.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void InventoryItem::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/inventory_item.h b/engines/ags/plugins/core/inventory_item.h
new file mode 100644
index 0000000000..e0f9620338
--- /dev/null
+++ b/engines/ags/plugins/core/inventory_item.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_INVENTORY_ITEM_H
+#define AGS_PLUGINS_CORE_INVENTORY_ITEM_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class InventoryItem : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/label.cpp b/engines/ags/plugins/core/label.cpp
new file mode 100644
index 0000000000..b0cb609185
--- /dev/null
+++ b/engines/ags/plugins/core/label.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/label.h"
+#include "ags/engine/ac/label.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Label::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/label.h b/engines/ags/plugins/core/label.h
new file mode 100644
index 0000000000..772e25fc70
--- /dev/null
+++ b/engines/ags/plugins/core/label.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_LABEL_H
+#define AGS_PLUGINS_CORE_LABEL_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Label : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/listbox.cpp b/engines/ags/plugins/core/listbox.cpp
new file mode 100644
index 0000000000..a7a4b63e89
--- /dev/null
+++ b/engines/ags/plugins/core/listbox.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/listbox.h"
+#include "ags/engine/ac/listbox.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Listbox::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/listbox.h b/engines/ags/plugins/core/listbox.h
new file mode 100644
index 0000000000..cea698ecf6
--- /dev/null
+++ b/engines/ags/plugins/core/listbox.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_LISTBOX_H
+#define AGS_PLUGINS_CORE_LISTBOX_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Listbox : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/math.cpp b/engines/ags/plugins/core/math.cpp
new file mode 100644
index 0000000000..d11cb0fa45
--- /dev/null
+++ b/engines/ags/plugins/core/math.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/math.h"
+#include "ags/engine/ac/math.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Math::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/math.h b/engines/ags/plugins/core/math.h
new file mode 100644
index 0000000000..da09ab87c0
--- /dev/null
+++ b/engines/ags/plugins/core/math.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_MATH_H
+#define AGS_PLUGINS_CORE_MATH_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Math : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/mouse.cpp b/engines/ags/plugins/core/mouse.cpp
new file mode 100644
index 0000000000..ce57ae0804
--- /dev/null
+++ b/engines/ags/plugins/core/mouse.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/mouse.h"
+#include "ags/engine/ac/mouse.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Mouse::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/mouse.h b/engines/ags/plugins/core/mouse.h
new file mode 100644
index 0000000000..41534c0d7a
--- /dev/null
+++ b/engines/ags/plugins/core/mouse.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_MOUSE_H
+#define AGS_PLUGINS_CORE_MOUSE_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Mouse : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/object.cpp b/engines/ags/plugins/core/object.cpp
new file mode 100644
index 0000000000..676eef5e38
--- /dev/null
+++ b/engines/ags/plugins/core/object.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/object.h"
+#include "ags/engine/ac/object.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Object::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/object.h b/engines/ags/plugins/core/object.h
new file mode 100644
index 0000000000..0affc577a3
--- /dev/null
+++ b/engines/ags/plugins/core/object.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_OBJECT_H
+#define AGS_PLUGINS_CORE_OBJECT_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Object : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/overlay.cpp b/engines/ags/plugins/core/overlay.cpp
new file mode 100644
index 0000000000..81ac4aeec8
--- /dev/null
+++ b/engines/ags/plugins/core/overlay.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/overlay.h"
+#include "ags/engine/ac/overlay.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Overlay::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/overlay.h b/engines/ags/plugins/core/overlay.h
new file mode 100644
index 0000000000..9a75a50d6c
--- /dev/null
+++ b/engines/ags/plugins/core/overlay.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_OVERLAY_H
+#define AGS_PLUGINS_CORE_OVERLAY_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Overlay : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/parser.cpp b/engines/ags/plugins/core/parser.cpp
new file mode 100644
index 0000000000..d4fab3c343
--- /dev/null
+++ b/engines/ags/plugins/core/parser.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/parser.h"
+#include "ags/engine/ac/parser.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Parser::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/parser.h b/engines/ags/plugins/core/parser.h
new file mode 100644
index 0000000000..f0f593e820
--- /dev/null
+++ b/engines/ags/plugins/core/parser.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_PARSER_H
+#define AGS_PLUGINS_CORE_PARSER_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Parser : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/region.cpp b/engines/ags/plugins/core/region.cpp
new file mode 100644
index 0000000000..4a25508ebb
--- /dev/null
+++ b/engines/ags/plugins/core/region.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/region.h"
+#include "ags/engine/ac/region.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Region::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/region.h b/engines/ags/plugins/core/region.h
new file mode 100644
index 0000000000..af95509b9c
--- /dev/null
+++ b/engines/ags/plugins/core/region.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_REGION_H
+#define AGS_PLUGINS_CORE_REGION_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Region : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/room.cpp b/engines/ags/plugins/core/room.cpp
new file mode 100644
index 0000000000..c07a262a83
--- /dev/null
+++ b/engines/ags/plugins/core/room.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/room.h"
+#include "ags/engine/ac/room.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Room::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/room.h b/engines/ags/plugins/core/room.h
new file mode 100644
index 0000000000..0487da9c8d
--- /dev/null
+++ b/engines/ags/plugins/core/room.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_ROOM_H
+#define AGS_PLUGINS_CORE_ROOM_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Room : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/slider.cpp b/engines/ags/plugins/core/slider.cpp
new file mode 100644
index 0000000000..527c24431e
--- /dev/null
+++ b/engines/ags/plugins/core/slider.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/slider.h"
+#include "ags/engine/ac/slider.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Slider::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/slider.h b/engines/ags/plugins/core/slider.h
new file mode 100644
index 0000000000..9f4f66c7bd
--- /dev/null
+++ b/engines/ags/plugins/core/slider.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_SLIDER_H
+#define AGS_PLUGINS_CORE_SLIDER_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Slider : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/string.cpp b/engines/ags/plugins/core/string.cpp
new file mode 100644
index 0000000000..ffd2fda3b3
--- /dev/null
+++ b/engines/ags/plugins/core/string.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/string.h"
+#include "ags/engine/ac/string.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void String::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/string.h b/engines/ags/plugins/core/string.h
new file mode 100644
index 0000000000..1ed32b9e2c
--- /dev/null
+++ b/engines/ags/plugins/core/string.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_STRING_H
+#define AGS_PLUGINS_CORE_STRING_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class String : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/system.cpp b/engines/ags/plugins/core/system.cpp
new file mode 100644
index 0000000000..3136cee8dc
--- /dev/null
+++ b/engines/ags/plugins/core/system.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/system.h"
+#include "ags/engine/ac/system.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void System::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/system.h b/engines/ags/plugins/core/system.h
new file mode 100644
index 0000000000..3c18593eef
--- /dev/null
+++ b/engines/ags/plugins/core/system.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_SYSTEM_H
+#define AGS_PLUGINS_CORE_SYSTEM_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class System : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/textbox.cpp b/engines/ags/plugins/core/textbox.cpp
new file mode 100644
index 0000000000..c8de4f7774
--- /dev/null
+++ b/engines/ags/plugins/core/textbox.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/textbox.h"
+#include "ags/engine/ac/textbox.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void Textbox::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/textbox.h b/engines/ags/plugins/core/textbox.h
new file mode 100644
index 0000000000..093e67c1c2
--- /dev/null
+++ b/engines/ags/plugins/core/textbox.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_TEXTBOX_H
+#define AGS_PLUGINS_CORE_TEXTBOX_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class Textbox : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif
diff --git a/engines/ags/plugins/core/view_frame.cpp b/engines/ags/plugins/core/view_frame.cpp
new file mode 100644
index 0000000000..6d043d3250
--- /dev/null
+++ b/engines/ags/plugins/core/view_frame.cpp
@@ -0,0 +1,35 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "ags/plugins/core/view_frame.h"
+#include "ags/engine/ac/view_frame.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+void ViewFrame::AGS_EngineStartup(IAGSEngine *engine) {
+}
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
diff --git a/engines/ags/plugins/core/view_frame.h b/engines/ags/plugins/core/view_frame.h
new file mode 100644
index 0000000000..99fe44876a
--- /dev/null
+++ b/engines/ags/plugins/core/view_frame.h
@@ -0,0 +1,43 @@
+/* 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 2
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef AGS_PLUGINS_CORE_VIEW_FRAME_H
+#define AGS_PLUGINS_CORE_VIEW_FRAME_H
+
+#include "ags/plugins/plugin_base.h"
+
+namespace AGS3 {
+namespace Plugins {
+namespace Core {
+
+class ViewFrame : public ScriptContainer {
+public:
+	void AGS_EngineStartup(IAGSEngine *engine);
+
+//	static void Now(ScriptMethodParams &params);
+};
+
+} // namespace Core
+} // namespace Plugins
+} // namespace AGS3
+
+#endif


Commit: b18e00e7218940b51b61343914f006368bc80e44
    https://github.com/scummvm/scummvm/commit/b18e00e7218940b51b61343914f006368bc80e44
Author: Paul Gilbert (dreammaster at scummvm.org)
Date: 2021-07-17T15:52:11-07:00

Commit Message:
AGS: Implementing the core classes

Changed paths:
    engines/ags/engine/ac/gui.cpp
    engines/ags/engine/ac/gui_control.cpp
    engines/ags/engine/ac/hotspot.cpp
    engines/ags/engine/ac/hotspot.h
    engines/ags/engine/ac/inv_window.cpp
    engines/ags/engine/ac/inventory_item.cpp
    engines/ags/engine/ac/label.cpp
    engines/ags/engine/ac/listbox.cpp
    engines/ags/plugins/core/gui.cpp
    engines/ags/plugins/core/gui.h
    engines/ags/plugins/core/gui_control.cpp
    engines/ags/plugins/core/gui_control.h
    engines/ags/plugins/core/hotspot.cpp
    engines/ags/plugins/core/hotspot.h
    engines/ags/plugins/core/inv_window.cpp
    engines/ags/plugins/core/inv_window.h
    engines/ags/plugins/core/inventory_item.cpp
    engines/ags/plugins/core/inventory_item.h
    engines/ags/plugins/core/label.cpp
    engines/ags/plugins/core/label.h
    engines/ags/plugins/core/listbox.cpp
    engines/ags/plugins/core/listbox.h


diff --git a/engines/ags/engine/ac/gui.cpp b/engines/ags/engine/ac/gui.cpp
index cc286a8de0..4c55450547 100644
--- a/engines/ags/engine/ac/gui.cpp
+++ b/engines/ags/engine/ac/gui.cpp
@@ -897,34 +897,6 @@ void RegisterGUIAPI() {
 	ccAddExternalObjectFunction("GUI::get_ZOrder", Sc_GUI_GetZOrder);
 	ccAddExternalObjectFunction("GUI::set_ZOrder", Sc_GUI_SetZOrder);
 	ccAddExternalObjectFunction("GUI::get_Shown", Sc_GUI_GetShown);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("GUI::Centre^0", (void *)GUI_Centre);
-	ccAddExternalFunctionForPlugin("GUI::GetAtScreenXY^2", (void *)GetGUIAtLocation);
-	ccAddExternalFunctionForPlugin("GUI::SetPosition^2", (void *)GUI_SetPosition);
-	ccAddExternalFunctionForPlugin("GUI::SetSize^2", (void *)GUI_SetSize);
-	ccAddExternalFunctionForPlugin("GUI::get_BackgroundGraphic", (void *)GUI_GetBackgroundGraphic);
-	ccAddExternalFunctionForPlugin("GUI::set_BackgroundGraphic", (void *)GUI_SetBackgroundGraphic);
-	ccAddExternalFunctionForPlugin("GUI::get_Clickable", (void *)GUI_GetClickable);
-	ccAddExternalFunctionForPlugin("GUI::set_Clickable", (void *)GUI_SetClickable);
-	ccAddExternalFunctionForPlugin("GUI::get_ControlCount", (void *)GUI_GetControlCount);
-	ccAddExternalFunctionForPlugin("GUI::geti_Controls", (void *)GUI_GetiControls);
-	ccAddExternalFunctionForPlugin("GUI::get_Height", (void *)GUI_GetHeight);
-	ccAddExternalFunctionForPlugin("GUI::set_Height", (void *)GUI_SetHeight);
-	ccAddExternalFunctionForPlugin("GUI::get_ID", (void *)GUI_GetID);
-	ccAddExternalFunctionForPlugin("GUI::get_Transparency", (void *)GUI_GetTransparency);
-	ccAddExternalFunctionForPlugin("GUI::set_Transparency", (void *)GUI_SetTransparency);
-	ccAddExternalFunctionForPlugin("GUI::get_Visible", (void *)GUI_GetVisible);
-	ccAddExternalFunctionForPlugin("GUI::set_Visible", (void *)GUI_SetVisible);
-	ccAddExternalFunctionForPlugin("GUI::get_Width", (void *)GUI_GetWidth);
-	ccAddExternalFunctionForPlugin("GUI::set_Width", (void *)GUI_SetWidth);
-	ccAddExternalFunctionForPlugin("GUI::get_X", (void *)GUI_GetX);
-	ccAddExternalFunctionForPlugin("GUI::set_X", (void *)GUI_SetX);
-	ccAddExternalFunctionForPlugin("GUI::get_Y", (void *)GUI_GetY);
-	ccAddExternalFunctionForPlugin("GUI::set_Y", (void *)GUI_SetY);
-	ccAddExternalFunctionForPlugin("GUI::get_ZOrder", (void *)GUI_GetZOrder);
-	ccAddExternalFunctionForPlugin("GUI::set_ZOrder", (void *)GUI_SetZOrder);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/gui_control.cpp b/engines/ags/engine/ac/gui_control.cpp
index d53501cbc7..342f674889 100644
--- a/engines/ags/engine/ac/gui_control.cpp
+++ b/engines/ags/engine/ac/gui_control.cpp
@@ -402,36 +402,6 @@ void RegisterGUIControlAPI() {
 	ccAddExternalObjectFunction("GUIControl::set_Y", Sc_GUIControl_SetY);
 	ccAddExternalObjectFunction("GUIControl::get_ZOrder", Sc_GUIControl_GetZOrder);
 	ccAddExternalObjectFunction("GUIControl::set_ZOrder", Sc_GUIControl_SetZOrder);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("GUIControl::BringToFront^0", (void *)GUIControl_BringToFront);
-	ccAddExternalFunctionForPlugin("GUIControl::GetAtScreenXY^2", (void *)GetGUIControlAtLocation);
-	ccAddExternalFunctionForPlugin("GUIControl::SendToBack^0", (void *)GUIControl_SendToBack);
-	ccAddExternalFunctionForPlugin("GUIControl::SetPosition^2", (void *)GUIControl_SetPosition);
-	ccAddExternalFunctionForPlugin("GUIControl::SetSize^2", (void *)GUIControl_SetSize);
-	ccAddExternalFunctionForPlugin("GUIControl::get_AsButton", (void *)GUIControl_GetAsButton);
-	ccAddExternalFunctionForPlugin("GUIControl::get_AsInvWindow", (void *)GUIControl_GetAsInvWindow);
-	ccAddExternalFunctionForPlugin("GUIControl::get_AsLabel", (void *)GUIControl_GetAsLabel);
-	ccAddExternalFunctionForPlugin("GUIControl::get_AsListBox", (void *)GUIControl_GetAsListBox);
-	ccAddExternalFunctionForPlugin("GUIControl::get_AsSlider", (void *)GUIControl_GetAsSlider);
-	ccAddExternalFunctionForPlugin("GUIControl::get_AsTextBox", (void *)GUIControl_GetAsTextBox);
-	ccAddExternalFunctionForPlugin("GUIControl::get_Clickable", (void *)GUIControl_GetClickable);
-	ccAddExternalFunctionForPlugin("GUIControl::set_Clickable", (void *)GUIControl_SetClickable);
-	ccAddExternalFunctionForPlugin("GUIControl::get_Enabled", (void *)GUIControl_GetEnabled);
-	ccAddExternalFunctionForPlugin("GUIControl::set_Enabled", (void *)GUIControl_SetEnabled);
-	ccAddExternalFunctionForPlugin("GUIControl::get_Height", (void *)GUIControl_GetHeight);
-	ccAddExternalFunctionForPlugin("GUIControl::set_Height", (void *)GUIControl_SetHeight);
-	ccAddExternalFunctionForPlugin("GUIControl::get_ID", (void *)GUIControl_GetID);
-	ccAddExternalFunctionForPlugin("GUIControl::get_OwningGUI", (void *)GUIControl_GetOwningGUI);
-	ccAddExternalFunctionForPlugin("GUIControl::get_Visible", (void *)GUIControl_GetVisible);
-	ccAddExternalFunctionForPlugin("GUIControl::set_Visible", (void *)GUIControl_SetVisible);
-	ccAddExternalFunctionForPlugin("GUIControl::get_Width", (void *)GUIControl_GetWidth);
-	ccAddExternalFunctionForPlugin("GUIControl::set_Width", (void *)GUIControl_SetWidth);
-	ccAddExternalFunctionForPlugin("GUIControl::get_X", (void *)GUIControl_GetX);
-	ccAddExternalFunctionForPlugin("GUIControl::set_X", (void *)GUIControl_SetX);
-	ccAddExternalFunctionForPlugin("GUIControl::get_Y", (void *)GUIControl_GetY);
-	ccAddExternalFunctionForPlugin("GUIControl::set_Y", (void *)GUIControl_SetY);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/hotspot.cpp b/engines/ags/engine/ac/hotspot.cpp
index 0526ec2c5b..e45ed105f0 100644
--- a/engines/ags/engine/ac/hotspot.cpp
+++ b/engines/ags/engine/ac/hotspot.cpp
@@ -240,22 +240,6 @@ void RegisterHotspotAPI() {
 	ccAddExternalObjectFunction("Hotspot::get_Name", Sc_Hotspot_GetName_New);
 	ccAddExternalObjectFunction("Hotspot::get_WalkToX", Sc_Hotspot_GetWalkToX);
 	ccAddExternalObjectFunction("Hotspot::get_WalkToY", Sc_Hotspot_GetWalkToY);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Hotspot::GetAtRoomXY^2", (void *)GetHotspotAtRoom);
-	ccAddExternalFunctionForPlugin("Hotspot::GetAtScreenXY^2", (void *)GetHotspotAtScreen);
-	ccAddExternalFunctionForPlugin("Hotspot::GetName^1", (void *)Hotspot_GetName);
-	ccAddExternalFunctionForPlugin("Hotspot::GetProperty^1", (void *)Hotspot_GetProperty);
-	ccAddExternalFunctionForPlugin("Hotspot::GetPropertyText^2", (void *)Hotspot_GetPropertyText);
-	ccAddExternalFunctionForPlugin("Hotspot::GetTextProperty^1", (void *)Hotspot_GetTextProperty);
-	ccAddExternalFunctionForPlugin("Hotspot::RunInteraction^1", (void *)Hotspot_RunInteraction);
-	ccAddExternalFunctionForPlugin("Hotspot::get_Enabled", (void *)Hotspot_GetEnabled);
-	ccAddExternalFunctionForPlugin("Hotspot::set_Enabled", (void *)Hotspot_SetEnabled);
-	ccAddExternalFunctionForPlugin("Hotspot::get_ID", (void *)Hotspot_GetID);
-	ccAddExternalFunctionForPlugin("Hotspot::get_Name", (void *)Hotspot_GetName_New);
-	ccAddExternalFunctionForPlugin("Hotspot::get_WalkToX", (void *)Hotspot_GetWalkToX);
-	ccAddExternalFunctionForPlugin("Hotspot::get_WalkToY", (void *)Hotspot_GetWalkToY);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/hotspot.h b/engines/ags/engine/ac/hotspot.h
index 5091972f46..b9a0067d71 100644
--- a/engines/ags/engine/ac/hotspot.h
+++ b/engines/ags/engine/ac/hotspot.h
@@ -30,6 +30,7 @@ namespace AGS3 {
 void    Hotspot_SetEnabled(ScriptHotspot *hss, int newval);
 int     Hotspot_GetEnabled(ScriptHotspot *hss);
 int     Hotspot_GetID(ScriptHotspot *hss);
+ScriptHotspot *GetHotspotAtRoom(int x, int y);
 ScriptHotspot *GetHotspotAtScreen(int xx, int yy);
 int     Hotspot_GetWalkToX(ScriptHotspot *hss);
 int     Hotspot_GetWalkToY(ScriptHotspot *hss);
diff --git a/engines/ags/engine/ac/inv_window.cpp b/engines/ags/engine/ac/inv_window.cpp
index 8794f8ab49..407f216ec0 100644
--- a/engines/ags/engine/ac/inv_window.cpp
+++ b/engines/ags/engine/ac/inv_window.cpp
@@ -607,23 +607,6 @@ void RegisterInventoryWindowAPI() {
 	ccAddExternalObjectFunction("InvWindow::get_RowCount", Sc_InvWindow_GetRowCount);
 	ccAddExternalObjectFunction("InvWindow::get_TopItem", Sc_InvWindow_GetTopItem);
 	ccAddExternalObjectFunction("InvWindow::set_TopItem", Sc_InvWindow_SetTopItem);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("InvWindow::ScrollDown^0", (void *)InvWindow_ScrollDown);
-	ccAddExternalFunctionForPlugin("InvWindow::ScrollUp^0", (void *)InvWindow_ScrollUp);
-	ccAddExternalFunctionForPlugin("InvWindow::get_CharacterToUse", (void *)InvWindow_GetCharacterToUse);
-	ccAddExternalFunctionForPlugin("InvWindow::set_CharacterToUse", (void *)InvWindow_SetCharacterToUse);
-	ccAddExternalFunctionForPlugin("InvWindow::geti_ItemAtIndex", (void *)InvWindow_GetItemAtIndex);
-	ccAddExternalFunctionForPlugin("InvWindow::get_ItemCount", (void *)InvWindow_GetItemCount);
-	ccAddExternalFunctionForPlugin("InvWindow::get_ItemHeight", (void *)InvWindow_GetItemHeight);
-	ccAddExternalFunctionForPlugin("InvWindow::set_ItemHeight", (void *)InvWindow_SetItemHeight);
-	ccAddExternalFunctionForPlugin("InvWindow::get_ItemWidth", (void *)InvWindow_GetItemWidth);
-	ccAddExternalFunctionForPlugin("InvWindow::set_ItemWidth", (void *)InvWindow_SetItemWidth);
-	ccAddExternalFunctionForPlugin("InvWindow::get_ItemsPerRow", (void *)InvWindow_GetItemsPerRow);
-	ccAddExternalFunctionForPlugin("InvWindow::get_RowCount", (void *)InvWindow_GetRowCount);
-	ccAddExternalFunctionForPlugin("InvWindow::get_TopItem", (void *)InvWindow_GetTopItem);
-	ccAddExternalFunctionForPlugin("InvWindow::set_TopItem", (void *)InvWindow_SetTopItem);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/inventory_item.cpp b/engines/ags/engine/ac/inventory_item.cpp
index 1325b50b47..fc974ac6bb 100644
--- a/engines/ags/engine/ac/inventory_item.cpp
+++ b/engines/ags/engine/ac/inventory_item.cpp
@@ -222,24 +222,6 @@ void RegisterInventoryItemAPI() {
 	ccAddExternalObjectFunction("InventoryItem::get_ID", Sc_InventoryItem_GetID);
 	ccAddExternalObjectFunction("InventoryItem::get_Name", Sc_InventoryItem_GetName_New);
 	ccAddExternalObjectFunction("InventoryItem::set_Name", Sc_InventoryItem_SetName);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("InventoryItem::GetAtScreenXY^2", (void *)GetInvAtLocation);
-	ccAddExternalFunctionForPlugin("InventoryItem::IsInteractionAvailable^1", (void *)InventoryItem_CheckInteractionAvailable);
-	ccAddExternalFunctionForPlugin("InventoryItem::GetName^1", (void *)InventoryItem_GetName);
-	ccAddExternalFunctionForPlugin("InventoryItem::GetProperty^1", (void *)InventoryItem_GetProperty);
-	ccAddExternalFunctionForPlugin("InventoryItem::GetPropertyText^2", (void *)InventoryItem_GetPropertyText);
-	ccAddExternalFunctionForPlugin("InventoryItem::GetTextProperty^1", (void *)InventoryItem_GetTextProperty);
-	ccAddExternalFunctionForPlugin("InventoryItem::RunInteraction^1", (void *)InventoryItem_RunInteraction);
-	ccAddExternalFunctionForPlugin("InventoryItem::SetName^1", (void *)InventoryItem_SetName);
-	ccAddExternalFunctionForPlugin("InventoryItem::get_CursorGraphic", (void *)InventoryItem_GetCursorGraphic);
-	ccAddExternalFunctionForPlugin("InventoryItem::set_CursorGraphic", (void *)InventoryItem_SetCursorGraphic);
-	ccAddExternalFunctionForPlugin("InventoryItem::get_Graphic", (void *)InventoryItem_GetGraphic);
-	ccAddExternalFunctionForPlugin("InventoryItem::set_Graphic", (void *)InventoryItem_SetGraphic);
-	ccAddExternalFunctionForPlugin("InventoryItem::get_ID", (void *)InventoryItem_GetID);
-	ccAddExternalFunctionForPlugin("InventoryItem::get_Name", (void *)InventoryItem_GetName_New);
-	ccAddExternalFunctionForPlugin("InventoryItem::set_Name", (void *)InventoryItem_SetName);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/label.cpp b/engines/ags/engine/ac/label.cpp
index 25e5c1a04d..881ec051e2 100644
--- a/engines/ags/engine/ac/label.cpp
+++ b/engines/ags/engine/ac/label.cpp
@@ -150,17 +150,6 @@ void RegisterLabelAPI() {
 	ccAddExternalObjectFunction("Label::set_Text", Sc_Label_SetText);
 	ccAddExternalObjectFunction("Label::get_TextColor", Sc_Label_GetColor);
 	ccAddExternalObjectFunction("Label::set_TextColor", Sc_Label_SetColor);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Label::GetText^1", (void *)Label_GetText);
-	ccAddExternalFunctionForPlugin("Label::SetText^1", (void *)Label_SetText);
-	ccAddExternalFunctionForPlugin("Label::get_Font", (void *)Label_GetFont);
-	ccAddExternalFunctionForPlugin("Label::set_Font", (void *)Label_SetFont);
-	ccAddExternalFunctionForPlugin("Label::get_Text", (void *)Label_GetText_New);
-	ccAddExternalFunctionForPlugin("Label::set_Text", (void *)Label_SetText);
-	ccAddExternalFunctionForPlugin("Label::get_TextColor", (void *)Label_GetColor);
-	ccAddExternalFunctionForPlugin("Label::set_TextColor", (void *)Label_SetColor);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/listbox.cpp b/engines/ags/engine/ac/listbox.cpp
index 83fc92e78f..46a54d65f8 100644
--- a/engines/ags/engine/ac/listbox.cpp
+++ b/engines/ags/engine/ac/listbox.cpp
@@ -587,35 +587,6 @@ void RegisterListBoxAPI() {
 	ccAddExternalObjectFunction("ListBox::set_TextColor", Sc_ListBox_SetTextColor);
 	ccAddExternalObjectFunction("ListBox::get_TopItem", Sc_ListBox_GetTopItem);
 	ccAddExternalObjectFunction("ListBox::set_TopItem", Sc_ListBox_SetTopItem);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("ListBox::AddItem^1", (void *)ListBox_AddItem);
-	ccAddExternalFunctionForPlugin("ListBox::Clear^0", (void *)ListBox_Clear);
-	ccAddExternalFunctionForPlugin("ListBox::FillDirList^1", (void *)ListBox_FillDirList);
-	ccAddExternalFunctionForPlugin("ListBox::FillSaveGameList^0", (void *)ListBox_FillSaveGameList);
-	ccAddExternalFunctionForPlugin("ListBox::GetItemAtLocation^2", (void *)ListBox_GetItemAtLocation);
-	ccAddExternalFunctionForPlugin("ListBox::GetItemText^2", (void *)ListBox_GetItemText);
-	ccAddExternalFunctionForPlugin("ListBox::InsertItemAt^2", (void *)ListBox_InsertItemAt);
-	ccAddExternalFunctionForPlugin("ListBox::RemoveItem^1", (void *)ListBox_RemoveItem);
-	ccAddExternalFunctionForPlugin("ListBox::ScrollDown^0", (void *)ListBox_ScrollDown);
-	ccAddExternalFunctionForPlugin("ListBox::ScrollUp^0", (void *)ListBox_ScrollUp);
-	ccAddExternalFunctionForPlugin("ListBox::SetItemText^2", (void *)ListBox_SetItemText);
-	ccAddExternalFunctionForPlugin("ListBox::get_Font", (void *)ListBox_GetFont);
-	ccAddExternalFunctionForPlugin("ListBox::set_Font", (void *)ListBox_SetFont);
-	ccAddExternalFunctionForPlugin("ListBox::get_HideBorder", (void *)ListBox_GetHideBorder);
-	ccAddExternalFunctionForPlugin("ListBox::set_HideBorder", (void *)ListBox_SetHideBorder);
-	ccAddExternalFunctionForPlugin("ListBox::get_HideScrollArrows", (void *)ListBox_GetHideScrollArrows);
-	ccAddExternalFunctionForPlugin("ListBox::set_HideScrollArrows", (void *)ListBox_SetHideScrollArrows);
-	ccAddExternalFunctionForPlugin("ListBox::get_ItemCount", (void *)ListBox_GetItemCount);
-	ccAddExternalFunctionForPlugin("ListBox::geti_Items", (void *)ListBox_GetItems);
-	ccAddExternalFunctionForPlugin("ListBox::seti_Items", (void *)ListBox_SetItemText);
-	ccAddExternalFunctionForPlugin("ListBox::get_RowCount", (void *)ListBox_GetRowCount);
-	ccAddExternalFunctionForPlugin("ListBox::geti_SaveGameSlots", (void *)ListBox_GetSaveGameSlots);
-	ccAddExternalFunctionForPlugin("ListBox::get_SelectedIndex", (void *)ListBox_GetSelectedIndex);
-	ccAddExternalFunctionForPlugin("ListBox::set_SelectedIndex", (void *)ListBox_SetSelectedIndex);
-	ccAddExternalFunctionForPlugin("ListBox::get_TopItem", (void *)ListBox_GetTopItem);
-	ccAddExternalFunctionForPlugin("ListBox::set_TopItem", (void *)ListBox_SetTopItem);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/plugins/core/gui.cpp b/engines/ags/plugins/core/gui.cpp
index 10f5637b3b..3ec2d4fdc1 100644
--- a/engines/ags/plugins/core/gui.cpp
+++ b/engines/ags/plugins/core/gui.cpp
@@ -28,6 +28,159 @@ namespace Plugins {
 namespace Core {
 
 void GUI::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(GUI::Centre^0, Centre);
+	SCRIPT_METHOD_EXT(GUI::GetAtScreenXY^2, GetGUIAtLocation);
+	SCRIPT_METHOD_EXT(GUI::SetPosition^2, SetPosition);
+	SCRIPT_METHOD_EXT(GUI::SetSize^2, SetSize);
+	SCRIPT_METHOD_EXT(GUI::get_BackgroundGraphic, GetBackgroundGraphic);
+	SCRIPT_METHOD_EXT(GUI::set_BackgroundGraphic, SetBackgroundGraphic);
+	SCRIPT_METHOD_EXT(GUI::get_Clickable, GetClickable);
+	SCRIPT_METHOD_EXT(GUI::set_Clickable, SetClickable);
+	SCRIPT_METHOD_EXT(GUI::get_ControlCount, GetControlCount);
+	SCRIPT_METHOD_EXT(GUI::geti_Controls, GetiControls);
+	SCRIPT_METHOD_EXT(GUI::get_Height, GetHeight);
+	SCRIPT_METHOD_EXT(GUI::set_Height, SetHeight);
+	SCRIPT_METHOD_EXT(GUI::get_ID, GetID);
+	SCRIPT_METHOD_EXT(GUI::get_Transparency, GetTransparency);
+	SCRIPT_METHOD_EXT(GUI::set_Transparency, SetTransparency);
+	SCRIPT_METHOD_EXT(GUI::get_Visible, GetVisible);
+	SCRIPT_METHOD_EXT(GUI::set_Visible, SetVisible);
+	SCRIPT_METHOD_EXT(GUI::get_Width, GetWidth);
+	SCRIPT_METHOD_EXT(GUI::set_Width, SetWidth);
+	SCRIPT_METHOD_EXT(GUI::get_X, GetX);
+	SCRIPT_METHOD_EXT(GUI::set_X, SetX);
+	SCRIPT_METHOD_EXT(GUI::get_Y, GetY);
+	SCRIPT_METHOD_EXT(GUI::set_Y, SetY);
+	SCRIPT_METHOD_EXT(GUI::get_ZOrder, GetZOrder);
+	SCRIPT_METHOD_EXT(GUI::set_ZOrder, SetZOrder);
+}
+
+void GUI::Centre(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	AGS3::GUI_Centre(sgui);
+}
+
+void GUI::GetGUIAtLocation(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetGUIAtLocation(xx, yy);
+}
+
+void GUI::SetPosition(ScriptMethodParams &params) {
+	PARAMS3(ScriptGUI *, tehgui, int, xx, int, yy);
+	AGS3::GUI_SetPosition(tehgui, xx, yy);
+}
+
+void GUI::SetSize(ScriptMethodParams &params) {
+	PARAMS3(ScriptGUI *, sgui, int, widd, int, hitt);
+	AGS3::GUI_SetSize(sgui, widd, hitt);
+}
+
+void GUI::GetBackgroundGraphic(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetBackgroundGraphic(sgui);
+
+}
+
+void GUI::SetBackgroundGraphic(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, slotn);
+	AGS3::GUI_SetBackgroundGraphic(tehgui, slotn);
+}
+
+void GUI::GetClickable(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetClickable(sgui);
+}
+
+void GUI::SetClickable(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, clickable);
+	AGS3::GUI_SetClickable(tehgui, clickable);
+}
+
+void GUI::GetControlCount(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetControlCount(sgui);
+}
+
+void GUI::GetiControls(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, sgui, int, idx);
+	params._result = AGS3::GUI_GetiControls(sgui, idx);
+}
+
+void GUI::GetHeight(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetHeight(sgui);
+}
+
+void GUI::SetHeight(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, sgui, int, newhit);
+	AGS3::GUI_SetHeight(sgui, newhit);
+}
+
+void GUI::GetID(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetID(sgui);
+}
+
+void GUI::GetTransparency(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetTransparency(sgui);
+}
+
+void GUI::SetTransparency(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, trans);
+	AGS3::GUI_SetTransparency(tehgui, trans);
+}
+
+void GUI::GetVisible(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetVisible(sgui);
+}
+
+void GUI::SetVisible(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, isvisible);
+	AGS3::GUI_SetVisible(tehgui, isvisible);
+}
+
+void GUI::GetWidth(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetWidth(sgui);
+
+}
+
+void GUI::SetWidth(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, sgui, int, newwid);
+	AGS3::GUI_SetWidth(sgui, newwid);
+}
+
+void GUI::GetX(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetX(sgui);
+}
+
+void GUI::SetX(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, xx);
+	AGS3::GUI_SetX(tehgui, xx);
+}
+
+void GUI::GetY(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetY(sgui);
+
+}
+
+void GUI::SetY(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, yy);
+	AGS3::GUI_SetY(tehgui, yy);
+}
+
+void GUI::GetZOrder(ScriptMethodParams &params) {
+	PARAMS1(ScriptGUI *, sgui);
+	params._result = AGS3::GUI_GetZOrder(sgui);
+}
+
+void GUI::SetZOrder(ScriptMethodParams &params) {
+	PARAMS2(ScriptGUI *, tehgui, int, z);
+	AGS3::GUI_SetZOrder(tehgui, z);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/gui.h b/engines/ags/plugins/core/gui.h
index 9e491fdc6b..2663167f79 100644
--- a/engines/ags/plugins/core/gui.h
+++ b/engines/ags/plugins/core/gui.h
@@ -33,7 +33,31 @@ class GUI : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void Centre(ScriptMethodParams &params);
+	static void GetGUIAtLocation(ScriptMethodParams &params);
+	static void SetPosition(ScriptMethodParams &params);
+	static void SetSize(ScriptMethodParams &params);
+	static void GetBackgroundGraphic(ScriptMethodParams &params);
+	static void SetBackgroundGraphic(ScriptMethodParams &params);
+	static void GetClickable(ScriptMethodParams &params);
+	static void SetClickable(ScriptMethodParams &params);
+	static void GetControlCount(ScriptMethodParams &params);
+	static void GetiControls(ScriptMethodParams &params);
+	static void GetHeight(ScriptMethodParams &params);
+	static void SetHeight(ScriptMethodParams &params);
+	static void GetID(ScriptMethodParams &params);
+	static void GetTransparency(ScriptMethodParams &params);
+	static void SetTransparency(ScriptMethodParams &params);
+	static void GetVisible(ScriptMethodParams &params);
+	static void SetVisible(ScriptMethodParams &params);
+	static void GetWidth(ScriptMethodParams &params);
+	static void SetWidth(ScriptMethodParams &params);
+	static void GetX(ScriptMethodParams &params);
+	static void SetX(ScriptMethodParams &params);
+	static void GetY(ScriptMethodParams &params);
+	static void SetY(ScriptMethodParams &params);
+	static void GetZOrder(ScriptMethodParams &params);
+	static void SetZOrder(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/gui_control.cpp b/engines/ags/plugins/core/gui_control.cpp
index d9ba20fcd4..bca335d680 100644
--- a/engines/ags/plugins/core/gui_control.cpp
+++ b/engines/ags/plugins/core/gui_control.cpp
@@ -28,8 +28,173 @@ namespace Plugins {
 namespace Core {
 
 void GUIControl::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(GUIControl::BringToFront^0, BringToFront);
+	SCRIPT_METHOD_EXT(GUIControl::GetAtScreenXY^2, GetGUIControlAtLocation);
+	SCRIPT_METHOD_EXT(GUIControl::SendToBack^0, SendToBack);
+	SCRIPT_METHOD_EXT(GUIControl::SetPosition^2, SetPosition);
+	SCRIPT_METHOD_EXT(GUIControl::SetSize^2, SetSize);
+	SCRIPT_METHOD_EXT(GUIControl::get_AsButton, GetAsButton);
+	SCRIPT_METHOD_EXT(GUIControl::get_AsInvWindow, GetAsInvWindow);
+	SCRIPT_METHOD_EXT(GUIControl::get_AsLabel, GetAsLabel);
+	SCRIPT_METHOD_EXT(GUIControl::get_AsListBox, GetAsListBox);
+	SCRIPT_METHOD_EXT(GUIControl::get_AsSlider, GetAsSlider);
+	SCRIPT_METHOD_EXT(GUIControl::get_AsTextBox, GetAsTextBox);
+	SCRIPT_METHOD_EXT(GUIControl::get_Clickable, GetClickable);
+	SCRIPT_METHOD_EXT(GUIControl::set_Clickable, SetClickable);
+	SCRIPT_METHOD_EXT(GUIControl::get_Enabled, GetEnabled);
+	SCRIPT_METHOD_EXT(GUIControl::set_Enabled, SetEnabled);
+	SCRIPT_METHOD_EXT(GUIControl::get_Height, GetHeight);
+	SCRIPT_METHOD_EXT(GUIControl::set_Height, SetHeight);
+	SCRIPT_METHOD_EXT(GUIControl::get_ID, GetID);
+	SCRIPT_METHOD_EXT(GUIControl::get_OwningGUI, GetOwningGUI);
+	SCRIPT_METHOD_EXT(GUIControl::get_Visible, GetVisible);
+	SCRIPT_METHOD_EXT(GUIControl::set_Visible, SetVisible);
+	SCRIPT_METHOD_EXT(GUIControl::get_Width, GetWidth);
+	SCRIPT_METHOD_EXT(GUIControl::set_Width, SetWidth);
+	SCRIPT_METHOD_EXT(GUIControl::get_X, GetX);
+	SCRIPT_METHOD_EXT(GUIControl::set_X, SetX);
+	SCRIPT_METHOD_EXT(GUIControl::get_Y, GetY);
+	SCRIPT_METHOD_EXT(GUIControl::set_Y, SetY);
 }
 
+void GUIControl::BringToFront(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	AGS3::GUIControl_BringToFront(guio);
+}
+
+void GUIControl::GetGUIControlAtLocation(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetGUIControlAtLocation(xx, yy);
+}
+
+void GUIControl::SendToBack(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	AGS3::GUIControl_SendToBack(guio);
+}
+
+void GUIControl::SetPosition(ScriptMethodParams &params) {
+	PARAMS3(GUIObject *, guio, int, xx, int, yy);
+	AGS3::GUIControl_SetPosition(guio, xx, yy);
+}
+
+void GUIControl::SetSize(ScriptMethodParams &params) {
+	PARAMS3(GUIObject *, guio, int, newwid, int, newhit);
+	AGS3::GUIControl_SetSize(guio, newwid, newhit);
+}
+
+void GUIControl::GetAsButton(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetAsButton(guio);
+}
+
+void GUIControl::GetAsInvWindow(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetAsInvWindow(guio);
+}
+
+void GUIControl::GetAsLabel(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetAsLabel(guio);
+}
+
+void GUIControl::GetAsListBox(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetAsListBox(guio);
+}
+
+void GUIControl::GetAsSlider(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetAsSlider(guio);
+}
+
+void GUIControl::GetAsTextBox(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetAsTextBox(guio);
+}
+
+void GUIControl::GetClickable(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetClickable(guio);
+}
+
+void GUIControl::SetClickable(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, enabled);
+	AGS3::GUIControl_SetClickable(guio, enabled);
+}
+
+void GUIControl::GetEnabled(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetEnabled(guio);
+}
+
+void GUIControl::SetEnabled(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, enabled);
+	AGS3::GUIControl_SetEnabled(guio, enabled);
+}
+
+void GUIControl::GetHeight(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetHeight(guio);
+}
+
+void GUIControl::SetHeight(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, newhit);
+	AGS3::GUIControl_SetHeight(guio, newhit);
+}
+
+void GUIControl::GetID(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetID(guio);
+
+}
+
+void GUIControl::GetOwningGUI(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetOwningGUI(guio);
+}
+
+void GUIControl::GetVisible(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetVisible(guio);
+
+}
+
+void GUIControl::SetVisible(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, visible);
+	AGS3::GUIControl_SetVisible(guio, visible);
+}
+
+void GUIControl::GetWidth(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetWidth(guio);
+}
+
+void GUIControl::SetWidth(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, newwid);
+	AGS3::GUIControl_SetWidth(guio, newwid);
+}
+
+void GUIControl::GetX(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetX(guio);
+}
+
+void GUIControl::SetX(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, xx);
+	AGS3::GUIControl_SetX(guio, xx);
+}
+
+void GUIControl::GetY(ScriptMethodParams &params) {
+	PARAMS1(GUIObject *, guio);
+	params._result = AGS3::GUIControl_GetY(guio);
+}
+
+void GUIControl::SetY(ScriptMethodParams &params) {
+	PARAMS2(GUIObject *, guio, int, yy);
+	AGS3::GUIControl_SetY(guio, yy);
+}
+
+
 } // namespace Core
 } // namespace Plugins
 } // namespace AGS3
diff --git a/engines/ags/plugins/core/gui_control.h b/engines/ags/plugins/core/gui_control.h
index 4eb393b002..efbe5a60a5 100644
--- a/engines/ags/plugins/core/gui_control.h
+++ b/engines/ags/plugins/core/gui_control.h
@@ -33,7 +33,33 @@ class GUIControl : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void BringToFront(ScriptMethodParams &params);
+	static void GetGUIControlAtLocation(ScriptMethodParams &params);
+	static void SendToBack(ScriptMethodParams &params);
+	static void SetPosition(ScriptMethodParams &params);
+	static void SetSize(ScriptMethodParams &params);
+	static void GetAsButton(ScriptMethodParams &params);
+	static void GetAsInvWindow(ScriptMethodParams &params);
+	static void GetAsLabel(ScriptMethodParams &params);
+	static void GetAsListBox(ScriptMethodParams &params);
+	static void GetAsSlider(ScriptMethodParams &params);
+	static void GetAsTextBox(ScriptMethodParams &params);
+	static void GetClickable(ScriptMethodParams &params);
+	static void SetClickable(ScriptMethodParams &params);
+	static void GetEnabled(ScriptMethodParams &params);
+	static void SetEnabled(ScriptMethodParams &params);
+	static void GetHeight(ScriptMethodParams &params);
+	static void SetHeight(ScriptMethodParams &params);
+	static void GetID(ScriptMethodParams &params);
+	static void GetOwningGUI(ScriptMethodParams &params);
+	static void GetVisible(ScriptMethodParams &params);
+	static void SetVisible(ScriptMethodParams &params);
+	static void GetWidth(ScriptMethodParams &params);
+	static void SetWidth(ScriptMethodParams &params);
+	static void GetX(ScriptMethodParams &params);
+	static void SetX(ScriptMethodParams &params);
+	static void GetY(ScriptMethodParams &params);
+	static void SetY(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/hotspot.cpp b/engines/ags/plugins/core/hotspot.cpp
index a100c441a8..c7fcc90844 100644
--- a/engines/ags/plugins/core/hotspot.cpp
+++ b/engines/ags/plugins/core/hotspot.cpp
@@ -28,6 +28,84 @@ namespace Plugins {
 namespace Core {
 
 void Hotspot::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Hotspot::GetAtRoomXY^2, GetHotspotAtRoom);
+	SCRIPT_METHOD_EXT(Hotspot::GetAtScreenXY^2, GetHotspotAtScreen);
+	SCRIPT_METHOD_EXT(Hotspot::GetName^1, GetName);
+	SCRIPT_METHOD_EXT(Hotspot::GetProperty^1, GetProperty);
+	SCRIPT_METHOD_EXT(Hotspot::GetPropertyText^2, GetPropertyText);
+	SCRIPT_METHOD_EXT(Hotspot::GetTextProperty^1, GetTextProperty);
+	SCRIPT_METHOD_EXT(Hotspot::RunInteraction^1, RunInteraction);
+	SCRIPT_METHOD_EXT(Hotspot::get_Enabled, GetEnabled);
+	SCRIPT_METHOD_EXT(Hotspot::set_Enabled, SetEnabled);
+	SCRIPT_METHOD_EXT(Hotspot::get_ID, GetID);
+	SCRIPT_METHOD_EXT(Hotspot::get_Name, GetName_New);
+	SCRIPT_METHOD_EXT(Hotspot::get_WalkToX, GetWalkToX);
+	SCRIPT_METHOD_EXT(Hotspot::get_WalkToY, GetWalkToY);
+}
+
+void Hotspot::GetHotspotAtRoom(ScriptMethodParams &params) {
+	PARAMS2(int, x, int, y);
+	params._result = AGS3::GetHotspotAtRoom(x, y);
+}
+
+void Hotspot::GetHotspotAtScreen(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetHotspotAtScreen(xx, yy);
+}
+
+void Hotspot::GetName(ScriptMethodParams &params) {
+	PARAMS2(ScriptHotspot *, hss, char *, buffer);
+	AGS3::Hotspot_GetName(hss, buffer);
+}
+
+void Hotspot::GetProperty(ScriptMethodParams &params) {
+	PARAMS2(ScriptHotspot *, hss, const char *, property);
+	params._result = AGS3::Hotspot_GetProperty(hss, property);
+}
+
+void Hotspot::GetPropertyText(ScriptMethodParams &params) {
+	PARAMS3(ScriptHotspot *, hss, const char *, property, char *, bufer);
+	AGS3::Hotspot_GetPropertyText(hss, property, bufer);
+}
+
+void Hotspot::GetTextProperty(ScriptMethodParams &params) {
+	PARAMS2(ScriptHotspot *, hss, const char *, property);
+	params._result = AGS3::Hotspot_GetTextProperty(hss, property);
+}
+
+void Hotspot::RunInteraction(ScriptMethodParams &params) {
+	PARAMS2(ScriptHotspot *, hss, int, mood);
+	AGS3::Hotspot_RunInteraction(hss, mood);
+}
+
+void Hotspot::GetEnabled(ScriptMethodParams &params) {
+	PARAMS1(ScriptHotspot *, hss);
+	params._result = AGS3::Hotspot_GetEnabled(hss);
+}
+
+void Hotspot::SetEnabled(ScriptMethodParams &params) {
+	PARAMS2(ScriptHotspot *, hss, int, newval);
+	AGS3::Hotspot_SetEnabled(hss, newval);
+}
+
+void Hotspot::GetID(ScriptMethodParams &params) {
+	PARAMS1(ScriptHotspot *, hss);
+	params._result = AGS3::Hotspot_GetID(hss);
+}
+
+void Hotspot::GetName_New(ScriptMethodParams &params) {
+	PARAMS1(ScriptHotspot *, hss);
+	params._result = AGS3::Hotspot_GetName_New(hss);
+}
+
+void Hotspot::GetWalkToX(ScriptMethodParams &params) {
+	PARAMS1(ScriptHotspot *, hss);
+	params._result = AGS3::Hotspot_GetWalkToX(hss);
+}
+
+void Hotspot::GetWalkToY(ScriptMethodParams &params) {
+	PARAMS1(ScriptHotspot *, hss);
+	params._result = AGS3::Hotspot_GetWalkToY(hss);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/hotspot.h b/engines/ags/plugins/core/hotspot.h
index 2b4379dd7c..da9ef4b126 100644
--- a/engines/ags/plugins/core/hotspot.h
+++ b/engines/ags/plugins/core/hotspot.h
@@ -33,7 +33,19 @@ class Hotspot : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetHotspotAtRoom(ScriptMethodParams &params);
+	static void GetHotspotAtScreen(ScriptMethodParams &params);
+	static void GetName(ScriptMethodParams &params);
+	static void GetProperty(ScriptMethodParams &params);
+	static void GetPropertyText(ScriptMethodParams &params);
+	static void GetTextProperty(ScriptMethodParams &params);
+	static void RunInteraction(ScriptMethodParams &params);
+	static void GetEnabled(ScriptMethodParams &params);
+	static void SetEnabled(ScriptMethodParams &params);
+	static void GetID(ScriptMethodParams &params);
+	static void GetName_New(ScriptMethodParams &params);
+	static void GetWalkToX(ScriptMethodParams &params);
+	static void GetWalkToY(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/inv_window.cpp b/engines/ags/plugins/core/inv_window.cpp
index d1e60d3e93..fc91656a60 100644
--- a/engines/ags/plugins/core/inv_window.cpp
+++ b/engines/ags/plugins/core/inv_window.cpp
@@ -28,6 +28,90 @@ namespace Plugins {
 namespace Core {
 
 void InvWindow::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(InvWindow::ScrollDown^0, ScrollDown);
+	SCRIPT_METHOD_EXT(InvWindow::ScrollUp^0, ScrollUp);
+	SCRIPT_METHOD_EXT(InvWindow::get_CharacterToUse, GetCharacterToUse);
+	SCRIPT_METHOD_EXT(InvWindow::set_CharacterToUse, SetCharacterToUse);
+	SCRIPT_METHOD_EXT(InvWindow::geti_ItemAtIndex, GetItemAtIndex);
+	SCRIPT_METHOD_EXT(InvWindow::get_ItemCount, GetItemCount);
+	SCRIPT_METHOD_EXT(InvWindow::get_ItemHeight, GetItemHeight);
+	SCRIPT_METHOD_EXT(InvWindow::set_ItemHeight, SetItemHeight);
+	SCRIPT_METHOD_EXT(InvWindow::get_ItemWidth, GetItemWidth);
+	SCRIPT_METHOD_EXT(InvWindow::set_ItemWidth, SetItemWidth);
+	SCRIPT_METHOD_EXT(InvWindow::get_ItemsPerRow, GetItemsPerRow);
+	SCRIPT_METHOD_EXT(InvWindow::get_RowCount, GetRowCount);
+	SCRIPT_METHOD_EXT(InvWindow::get_TopItem, GetTopItem);
+	SCRIPT_METHOD_EXT(InvWindow::set_TopItem, SetTopItem);
+}
+
+void InvWindow::ScrollDown(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	AGS3::InvWindow_ScrollDown(guii);
+}
+
+void InvWindow::ScrollUp(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	AGS3::InvWindow_ScrollUp(guii);
+}
+
+void InvWindow::GetCharacterToUse(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetCharacterToUse(guii);
+}
+
+void InvWindow::SetCharacterToUse(ScriptMethodParams &params) {
+	PARAMS2(GUIInvWindow *, guii, CharacterInfo *, chaa);
+	AGS3::InvWindow_SetCharacterToUse(guii, chaa);
+}
+
+void InvWindow::GetItemAtIndex(ScriptMethodParams &params) {
+	PARAMS2(GUIInvWindow *, guii, int, index);
+	params._result = AGS3::InvWindow_GetItemAtIndex(guii, index);
+}
+
+void InvWindow::GetItemCount(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetItemCount(guii);
+}
+
+void InvWindow::GetItemHeight(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetItemHeight(guii);
+}
+
+void InvWindow::SetItemHeight(ScriptMethodParams &params) {
+	PARAMS2(GUIInvWindow *, guii, int, newhit);
+	AGS3::InvWindow_SetItemHeight(guii, newhit);
+}
+
+void InvWindow::GetItemWidth(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetItemWidth(guii);
+}
+
+void InvWindow::SetItemWidth(ScriptMethodParams &params) {
+	PARAMS2(GUIInvWindow *, guii, int, newwidth);
+	AGS3::InvWindow_SetItemWidth(guii, newwidth);
+}
+
+void InvWindow::GetItemsPerRow(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetItemsPerRow(guii);
+}
+
+void InvWindow::GetRowCount(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetRowCount(guii);
+}
+
+void InvWindow::GetTopItem(ScriptMethodParams &params) {
+	PARAMS1(GUIInvWindow *, guii);
+	params._result = AGS3::InvWindow_GetTopItem(guii);
+}
+
+void InvWindow::SetTopItem(ScriptMethodParams &params) {
+	PARAMS2(GUIInvWindow *, guii, int, topitem);
+	AGS3::InvWindow_SetTopItem(guii, topitem);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/inv_window.h b/engines/ags/plugins/core/inv_window.h
index b1d46f8817..b86ae3bcc6 100644
--- a/engines/ags/plugins/core/inv_window.h
+++ b/engines/ags/plugins/core/inv_window.h
@@ -33,7 +33,20 @@ class InvWindow : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void ScrollDown(ScriptMethodParams &params);
+	static void ScrollUp(ScriptMethodParams &params);
+	static void GetCharacterToUse(ScriptMethodParams &params);
+	static void SetCharacterToUse(ScriptMethodParams &params);
+	static void GetItemAtIndex(ScriptMethodParams &params);
+	static void GetItemCount(ScriptMethodParams &params);
+	static void GetItemHeight(ScriptMethodParams &params);
+	static void SetItemHeight(ScriptMethodParams &params);
+	static void GetItemWidth(ScriptMethodParams &params);
+	static void SetItemWidth(ScriptMethodParams &params);
+	static void GetItemsPerRow(ScriptMethodParams &params);
+	static void GetRowCount(ScriptMethodParams &params);
+	static void GetTopItem(ScriptMethodParams &params);
+	static void SetTopItem(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/inventory_item.cpp b/engines/ags/plugins/core/inventory_item.cpp
index c8ba81b533..643347ca88 100644
--- a/engines/ags/plugins/core/inventory_item.cpp
+++ b/engines/ags/plugins/core/inventory_item.cpp
@@ -28,6 +28,91 @@ namespace Plugins {
 namespace Core {
 
 void InventoryItem::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(InventoryItem::GetAtScreenXY ^ 2, GetInvAtLocation);
+	SCRIPT_METHOD_EXT(InventoryItem::IsInteractionAvailable ^ 1, CheckInteractionAvailable);
+	SCRIPT_METHOD_EXT(InventoryItem::GetName ^ 1, GetName);
+	SCRIPT_METHOD_EXT(InventoryItem::GetProperty ^ 1, GetProperty);
+	SCRIPT_METHOD_EXT(InventoryItem::GetPropertyText ^ 2, GetPropertyText);
+	SCRIPT_METHOD_EXT(InventoryItem::GetTextProperty ^ 1, GetTextProperty);
+	SCRIPT_METHOD_EXT(InventoryItem::RunInteraction ^ 1, RunInteraction);
+	SCRIPT_METHOD_EXT(InventoryItem::SetName ^ 1, SetName);
+	SCRIPT_METHOD_EXT(InventoryItem::get_CursorGraphic, GetCursorGraphic);
+	SCRIPT_METHOD_EXT(InventoryItem::set_CursorGraphic, SetCursorGraphic);
+	SCRIPT_METHOD_EXT(InventoryItem::get_Graphic, GetGraphic);
+	SCRIPT_METHOD_EXT(InventoryItem::set_Graphic, SetGraphic);
+	SCRIPT_METHOD_EXT(InventoryItem::get_ID, GetID);
+	SCRIPT_METHOD_EXT(InventoryItem::get_Name, GetName_New);
+	SCRIPT_METHOD_EXT(InventoryItem::set_Name, SetName);
+}
+
+void InventoryItem::GetInvAtLocation(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetInvAtLocation(xx, yy);
+}
+
+void InventoryItem::CheckInteractionAvailable(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, iitem, int, mood);
+	params._result = AGS3::InventoryItem_CheckInteractionAvailable(iitem, mood);
+}
+
+void InventoryItem::GetName(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, iitem, char *, buff);
+	AGS3::InventoryItem_GetName(iitem, buff);
+}
+
+void InventoryItem::GetProperty(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, scii, const char *, property);
+	params._result = AGS3::InventoryItem_GetProperty(scii, property);
+}
+
+void InventoryItem::GetPropertyText(ScriptMethodParams &params) {
+	PARAMS3(ScriptInvItem *, scii, const char *, property, char *, bufer);
+	AGS3::InventoryItem_GetPropertyText(scii, property, bufer);
+}
+
+void InventoryItem::GetTextProperty(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, scii, const char *, property);
+	params._result = AGS3::InventoryItem_GetTextProperty(scii, property);
+}
+
+void InventoryItem::RunInteraction(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, iitem, int, mood);
+	AGS3::InventoryItem_RunInteraction(iitem, mood);
+}
+
+void InventoryItem::SetName(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, scii, const char *, newname);
+	AGS3::InventoryItem_SetName(scii, newname);
+}
+
+void InventoryItem::GetCursorGraphic(ScriptMethodParams &params) {
+	PARAMS1(ScriptInvItem *, iitem);
+	params._result = AGS3::InventoryItem_GetCursorGraphic(iitem);
+}
+
+void InventoryItem::SetCursorGraphic(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, iitem, int, newSprite);
+	AGS3::InventoryItem_SetCursorGraphic(iitem, newSprite);
+}
+
+void InventoryItem::GetGraphic(ScriptMethodParams &params) {
+	PARAMS1(ScriptInvItem *, iitem);
+	params._result = AGS3::InventoryItem_GetGraphic(iitem);
+}
+
+void InventoryItem::SetGraphic(ScriptMethodParams &params) {
+	PARAMS2(ScriptInvItem *, iitem, int, piccy);
+	AGS3::InventoryItem_SetGraphic(iitem, piccy);
+}
+
+void InventoryItem::GetID(ScriptMethodParams &params) {
+	PARAMS1(ScriptInvItem *, iitem);
+	params._result = AGS3::InventoryItem_GetID(iitem);
+}
+
+void InventoryItem::GetName_New(ScriptMethodParams &params) {
+	PARAMS1(ScriptInvItem *, iitem);
+	params._result = AGS3::InventoryItem_GetName_New(iitem);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/inventory_item.h b/engines/ags/plugins/core/inventory_item.h
index e0f9620338..cd85094203 100644
--- a/engines/ags/plugins/core/inventory_item.h
+++ b/engines/ags/plugins/core/inventory_item.h
@@ -33,7 +33,20 @@ class InventoryItem : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetInvAtLocation(ScriptMethodParams &params);
+	static void CheckInteractionAvailable(ScriptMethodParams &params);
+	static void GetName(ScriptMethodParams &params);
+	static void GetProperty(ScriptMethodParams &params);
+	static void GetPropertyText(ScriptMethodParams &params);
+	static void GetTextProperty(ScriptMethodParams &params);
+	static void RunInteraction(ScriptMethodParams &params);
+	static void SetName(ScriptMethodParams &params);
+	static void GetCursorGraphic(ScriptMethodParams &params);
+	static void SetCursorGraphic(ScriptMethodParams &params);
+	static void GetGraphic(ScriptMethodParams &params);
+	static void SetGraphic(ScriptMethodParams &params);
+	static void GetID(ScriptMethodParams &params);
+	static void GetName_New(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/label.cpp b/engines/ags/plugins/core/label.cpp
index b0cb609185..ecfdb42f25 100644
--- a/engines/ags/plugins/core/label.cpp
+++ b/engines/ags/plugins/core/label.cpp
@@ -28,6 +28,49 @@ namespace Plugins {
 namespace Core {
 
 void Label::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Label::GetText^1, GetText);
+	SCRIPT_METHOD_EXT(Label::SetText^1, SetText);
+	SCRIPT_METHOD_EXT(Label::get_Font, GetFont);
+	SCRIPT_METHOD_EXT(Label::set_Font, SetFont);
+	SCRIPT_METHOD_EXT(Label::get_Text, GetText_New);
+	SCRIPT_METHOD_EXT(Label::set_Text, SetText);
+	SCRIPT_METHOD_EXT(Label::get_TextColor, GetColor);
+	SCRIPT_METHOD_EXT(Label::set_TextColor, SetColor);
+}
+
+void Label::GetText(ScriptMethodParams &params) {
+	PARAMS2(GUILabel *, labl, char *, buffer);
+	AGS3::Label_GetText(labl, buffer);
+}
+
+void Label::SetText(ScriptMethodParams &params) {
+	PARAMS2(GUILabel *, labl, const char *, newtx);
+	AGS3::Label_SetText(labl, newtx);
+}
+
+void Label::GetFont(ScriptMethodParams &params) {
+	PARAMS1(GUILabel *, labl);
+	params._result = AGS3::Label_GetFont(labl);
+}
+
+void Label::SetFont(ScriptMethodParams &params) {
+	PARAMS2(GUILabel *, guil, int, fontnum);
+	AGS3::Label_SetFont(guil, fontnum);
+}
+
+void Label::GetText_New(ScriptMethodParams &params) {
+	PARAMS1(GUILabel *, labl);
+	params._result = AGS3::Label_GetText_New(labl);
+}
+
+void Label::GetColor(ScriptMethodParams &params) {
+	PARAMS1(GUILabel *, labl);
+	params._result = AGS3::Label_GetColor(labl);
+}
+
+void Label::SetColor(ScriptMethodParams &params) {
+	PARAMS2(GUILabel *, labl, int, colr);
+	AGS3::Label_SetColor(labl, colr);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/label.h b/engines/ags/plugins/core/label.h
index 772e25fc70..26dfe6838a 100644
--- a/engines/ags/plugins/core/label.h
+++ b/engines/ags/plugins/core/label.h
@@ -33,7 +33,13 @@ class Label : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetText(ScriptMethodParams &params);
+	static void SetText(ScriptMethodParams &params);
+	static void GetFont(ScriptMethodParams &params);
+	static void SetFont(ScriptMethodParams &params);
+	static void GetText_New(ScriptMethodParams &params);
+	static void GetColor(ScriptMethodParams &params);
+	static void SetColor(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/listbox.cpp b/engines/ags/plugins/core/listbox.cpp
index a7a4b63e89..8da3ab7463 100644
--- a/engines/ags/plugins/core/listbox.cpp
+++ b/engines/ags/plugins/core/listbox.cpp
@@ -28,6 +28,157 @@ namespace Plugins {
 namespace Core {
 
 void Listbox::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(ListBox::AddItem^1, AddItem);
+	SCRIPT_METHOD_EXT(ListBox::Clear^0, Clear);
+	SCRIPT_METHOD_EXT(ListBox::FillDirList^1, FillDirList);
+	SCRIPT_METHOD_EXT(ListBox::FillSaveGameList^0, FillSaveGameList);
+	SCRIPT_METHOD_EXT(ListBox::GetItemAtLocation^2, GetItemAtLocation);
+	SCRIPT_METHOD_EXT(ListBox::GetItemText^2, GetItemText);
+	SCRIPT_METHOD_EXT(ListBox::InsertItemAt^2, InsertItemAt);
+	SCRIPT_METHOD_EXT(ListBox::RemoveItem^1, RemoveItem);
+	SCRIPT_METHOD_EXT(ListBox::ScrollDown^0, ScrollDown);
+	SCRIPT_METHOD_EXT(ListBox::ScrollUp^0, ScrollUp);
+	SCRIPT_METHOD_EXT(ListBox::SetItemText^2, SetItemText);
+	SCRIPT_METHOD_EXT(ListBox::get_Font, GetFont);
+	SCRIPT_METHOD_EXT(ListBox::set_Font, SetFont);
+	SCRIPT_METHOD_EXT(ListBox::get_HideBorder, GetHideBorder);
+	SCRIPT_METHOD_EXT(ListBox::set_HideBorder, SetHideBorder);
+	SCRIPT_METHOD_EXT(ListBox::get_HideScrollArrows, GetHideScrollArrows);
+	SCRIPT_METHOD_EXT(ListBox::set_HideScrollArrows, SetHideScrollArrows);
+	SCRIPT_METHOD_EXT(ListBox::get_ItemCount, GetItemCount);
+	SCRIPT_METHOD_EXT(ListBox::geti_Items, GetItems);
+	SCRIPT_METHOD_EXT(ListBox::seti_Items, SetItemText);
+	SCRIPT_METHOD_EXT(ListBox::get_RowCount, GetRowCount);
+	SCRIPT_METHOD_EXT(ListBox::geti_SaveGameSlots, GetSaveGameSlots);
+	SCRIPT_METHOD_EXT(ListBox::get_SelectedIndex, GetSelectedIndex);
+	SCRIPT_METHOD_EXT(ListBox::set_SelectedIndex, SetSelectedIndex);
+	SCRIPT_METHOD_EXT(ListBox::get_TopItem, GetTopItem);
+	SCRIPT_METHOD_EXT(ListBox::set_TopItem, SetTopItem);
+}
+
+void Listbox::AddItem(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, lbb, const char *, text);
+	params._result = AGS3::ListBox_AddItem(lbb, text);
+}
+
+void Listbox::Clear(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	AGS3::ListBox_Clear(listbox);
+}
+
+void Listbox::FillDirList(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, const char *, filemask);
+	AGS3::ListBox_FillDirList(listbox, filemask);
+}
+
+void Listbox::FillSaveGameList(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_FillSaveGameList(listbox);
+}
+
+void Listbox::GetItemAtLocation(ScriptMethodParams &params) {
+	PARAMS3(GUIListBox *, listbox, int, x, int, y);
+	params._result = AGS3::ListBox_GetItemAtLocation(listbox, x, y);
+}
+
+void Listbox::GetItemText(ScriptMethodParams &params) {
+	PARAMS3(GUIListBox *, listbox, int, index, char *, buffer);
+	params._result = AGS3::ListBox_GetItemText(listbox, index, buffer);
+}
+
+void Listbox::InsertItemAt(ScriptMethodParams &params) {
+	PARAMS3(GUIListBox *, lbb, int, index, const char *, text);
+	params._result = AGS3::ListBox_InsertItemAt(lbb, index, text);
+}
+
+void Listbox::RemoveItem(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, int, itemIndex);
+	AGS3::ListBox_RemoveItem(listbox, itemIndex);
+}
+
+void Listbox::ScrollDown(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	AGS3::ListBox_ScrollDown(listbox);
+}
+
+void Listbox::ScrollUp(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	AGS3::ListBox_ScrollUp(listbox);
+}
+
+void Listbox::SetItemText(ScriptMethodParams &params) {
+	PARAMS3(GUIListBox *, listbox, int, index, const char *, newtext);
+	AGS3::ListBox_SetItemText(listbox, index, newtext);
+}
+
+void Listbox::GetFont(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetFont(listbox);
+}
+
+void Listbox::SetFont(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, int, newfont);
+	AGS3::ListBox_SetFont(listbox, newfont);
+}
+
+void Listbox::GetHideBorder(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetHideBorder(listbox);
+}
+
+void Listbox::SetHideBorder(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, int, newValue);
+	AGS3::ListBox_SetHideBorder(listbox, newValue);
+}
+
+void Listbox::GetHideScrollArrows(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetHideScrollArrows(listbox);
+}
+
+void Listbox::SetHideScrollArrows(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, int, newValue);
+	AGS3::ListBox_SetHideScrollArrows(listbox, newValue);
+}
+
+void Listbox::GetItemCount(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetItemCount(listbox);
+}
+
+void Listbox::GetItems(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, int, index);
+	params._result = AGS3::ListBox_GetItems(listbox, index);
+}
+
+void Listbox::GetRowCount(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetRowCount(listbox);
+}
+
+void Listbox::GetSaveGameSlots(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, listbox, int, index);
+	params._result = AGS3::ListBox_GetSaveGameSlots(listbox, index);
+}
+
+void Listbox::GetSelectedIndex(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetSelectedIndex(listbox);
+}
+
+void Listbox::SetSelectedIndex(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, guisl, int, newsel);
+	AGS3::ListBox_SetSelectedIndex(guisl, newsel);
+}
+
+void Listbox::GetTopItem(ScriptMethodParams &params) {
+	PARAMS1(GUIListBox *, listbox);
+	params._result = AGS3::ListBox_GetTopItem(listbox);
+}
+
+void Listbox::SetTopItem(ScriptMethodParams &params) {
+	PARAMS2(GUIListBox *, guisl, int, item);
+	AGS3::ListBox_SetTopItem(guisl, item);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/listbox.h b/engines/ags/plugins/core/listbox.h
index cea698ecf6..f00c6c424c 100644
--- a/engines/ags/plugins/core/listbox.h
+++ b/engines/ags/plugins/core/listbox.h
@@ -33,7 +33,31 @@ class Listbox : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void AddItem(ScriptMethodParams &params);
+	static void Clear(ScriptMethodParams &params);
+	static void FillDirList(ScriptMethodParams &params);
+	static void FillSaveGameList(ScriptMethodParams &params);
+	static void GetItemAtLocation(ScriptMethodParams &params);
+	static void GetItemText(ScriptMethodParams &params);
+	static void InsertItemAt(ScriptMethodParams &params);
+	static void RemoveItem(ScriptMethodParams &params);
+	static void ScrollDown(ScriptMethodParams &params);
+	static void ScrollUp(ScriptMethodParams &params);
+	static void SetItemText(ScriptMethodParams &params);
+	static void GetFont(ScriptMethodParams &params);
+	static void SetFont(ScriptMethodParams &params);
+	static void GetHideBorder(ScriptMethodParams &params);
+	static void SetHideBorder(ScriptMethodParams &params);
+	static void GetHideScrollArrows(ScriptMethodParams &params);
+	static void SetHideScrollArrows(ScriptMethodParams &params);
+	static void GetItemCount(ScriptMethodParams &params);
+	static void GetItems(ScriptMethodParams &params);
+	static void GetRowCount(ScriptMethodParams &params);
+	static void GetSaveGameSlots(ScriptMethodParams &params);
+	static void GetSelectedIndex(ScriptMethodParams &params);
+	static void SetSelectedIndex(ScriptMethodParams &params);
+	static void GetTopItem(ScriptMethodParams &params);
+	static void SetTopItem(ScriptMethodParams &params);
 };
 
 } // namespace Core


Commit: 0274540d479809fea093969ac6f7156256fce099
    https://github.com/scummvm/scummvm/commit/0274540d479809fea093969ac6f7156256fce099
Author: Paul Gilbert (dreammaster at scummvm.org)
Date: 2021-07-17T15:52:11-07:00

Commit Message:
AGS: Implement remaining plugin core export classes

Changed paths:
    engines/ags/engine/ac/math.cpp
    engines/ags/engine/ac/mouse.cpp
    engines/ags/engine/ac/mouse.h
    engines/ags/engine/ac/object.cpp
    engines/ags/engine/ac/object.h
    engines/ags/engine/ac/overlay.cpp
    engines/ags/engine/ac/parser.cpp
    engines/ags/engine/ac/region.cpp
    engines/ags/engine/ac/region.h
    engines/ags/engine/ac/room.cpp
    engines/ags/engine/ac/slider.cpp
    engines/ags/engine/ac/string.cpp
    engines/ags/engine/ac/string.h
    engines/ags/engine/ac/system.cpp
    engines/ags/engine/ac/textbox.cpp
    engines/ags/engine/ac/view_frame.cpp
    engines/ags/plugins/core/math.cpp
    engines/ags/plugins/core/math.h
    engines/ags/plugins/core/mouse.cpp
    engines/ags/plugins/core/mouse.h
    engines/ags/plugins/core/object.cpp
    engines/ags/plugins/core/object.h
    engines/ags/plugins/core/overlay.cpp
    engines/ags/plugins/core/overlay.h
    engines/ags/plugins/core/parser.cpp
    engines/ags/plugins/core/parser.h
    engines/ags/plugins/core/region.cpp
    engines/ags/plugins/core/region.h
    engines/ags/plugins/core/room.cpp
    engines/ags/plugins/core/room.h
    engines/ags/plugins/core/slider.cpp
    engines/ags/plugins/core/slider.h
    engines/ags/plugins/core/string.cpp
    engines/ags/plugins/core/string.h
    engines/ags/plugins/core/system.cpp
    engines/ags/plugins/core/system.h
    engines/ags/plugins/core/textbox.cpp
    engines/ags/plugins/core/textbox.h
    engines/ags/plugins/core/view_frame.cpp
    engines/ags/plugins/core/view_frame.h


diff --git a/engines/ags/engine/ac/math.cpp b/engines/ags/engine/ac/math.cpp
index f157cfa7e4..40154bae03 100644
--- a/engines/ags/engine/ac/math.cpp
+++ b/engines/ags/engine/ac/math.cpp
@@ -268,27 +268,6 @@ void RegisterMathAPI() {
 	ccAddExternalStaticFunction("Maths::Tan^1", Sc_Math_Tan);
 	ccAddExternalStaticFunction("Maths::Tanh^1", Sc_Math_Tanh);
 	ccAddExternalStaticFunction("Maths::get_Pi", Sc_Math_GetPi);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Maths::ArcCos^1", (void *)Math_ArcCos);
-	ccAddExternalFunctionForPlugin("Maths::ArcSin^1", (void *)Math_ArcSin);
-	ccAddExternalFunctionForPlugin("Maths::ArcTan^1", (void *)Math_ArcTan);
-	ccAddExternalFunctionForPlugin("Maths::ArcTan2^2", (void *)Math_ArcTan2);
-	ccAddExternalFunctionForPlugin("Maths::Cos^1", (void *)Math_Cos);
-	ccAddExternalFunctionForPlugin("Maths::Cosh^1", (void *)Math_Cosh);
-	ccAddExternalFunctionForPlugin("Maths::DegreesToRadians^1", (void *)Math_DegreesToRadians);
-	ccAddExternalFunctionForPlugin("Maths::Exp^1", (void *)Math_Exp);
-	ccAddExternalFunctionForPlugin("Maths::Log^1", (void *)Math_Log);
-	ccAddExternalFunctionForPlugin("Maths::Log10^1", (void *)Math_Log10);
-	ccAddExternalFunctionForPlugin("Maths::RadiansToDegrees^1", (void *)Math_RadiansToDegrees);
-	ccAddExternalFunctionForPlugin("Maths::RaiseToPower^2", (void *)Math_RaiseToPower);
-	ccAddExternalFunctionForPlugin("Maths::Sin^1", (void *)Math_Sin);
-	ccAddExternalFunctionForPlugin("Maths::Sinh^1", (void *)Math_Sinh);
-	ccAddExternalFunctionForPlugin("Maths::Sqrt^1", (void *)Math_Sqrt);
-	ccAddExternalFunctionForPlugin("Maths::Tan^1", (void *)Math_Tan);
-	ccAddExternalFunctionForPlugin("Maths::Tanh^1", (void *)Math_Tanh);
-	ccAddExternalFunctionForPlugin("Maths::get_Pi", (void *)Math_GetPi);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/mouse.cpp b/engines/ags/engine/ac/mouse.cpp
index 3e3db430fe..3836c507ac 100644
--- a/engines/ags/engine/ac/mouse.cpp
+++ b/engines/ags/engine/ac/mouse.cpp
@@ -578,29 +578,6 @@ void RegisterMouseAPI() {
 	ccAddExternalStaticFunction("Mouse::set_Speed", Sc_Mouse_SetSpeed);
 	ccAddExternalStaticFunction("Mouse::get_Visible", Sc_Mouse_GetVisible);
 	ccAddExternalStaticFunction("Mouse::set_Visible", Sc_Mouse_SetVisible);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Mouse::ChangeModeGraphic^2", (void *)ChangeCursorGraphic);
-	ccAddExternalFunctionForPlugin("Mouse::ChangeModeHotspot^3", (void *)ChangeCursorHotspot);
-	ccAddExternalFunctionForPlugin("Mouse::ChangeModeView^2", (void *)Mouse_ChangeModeView);
-	ccAddExternalFunctionForPlugin("Mouse::DisableMode^1", (void *)disable_cursor_mode);
-	ccAddExternalFunctionForPlugin("Mouse::EnableMode^1", (void *)enable_cursor_mode);
-	ccAddExternalFunctionForPlugin("Mouse::GetModeGraphic^1", (void *)Mouse_GetModeGraphic);
-	ccAddExternalFunctionForPlugin("Mouse::IsButtonDown^1", (void *)IsButtonDown);
-	ccAddExternalFunctionForPlugin("Mouse::IsModeEnabled^1", (void *)IsModeEnabled);
-	ccAddExternalFunctionForPlugin("Mouse::SaveCursorUntilItLeaves^0", (void *)SaveCursorForLocationChange);
-	ccAddExternalFunctionForPlugin("Mouse::SelectNextMode^0", (void *)SetNextCursor);
-	ccAddExternalFunctionForPlugin("Mouse::SelectPreviousMode^0", (void *)SetPreviousCursor);
-	ccAddExternalFunctionForPlugin("Mouse::SetBounds^4", (void *)SetMouseBounds);
-	ccAddExternalFunctionForPlugin("Mouse::SetPosition^2", (void *)SetMousePosition);
-	ccAddExternalFunctionForPlugin("Mouse::Update^0", (void *)RefreshMouse);
-	ccAddExternalFunctionForPlugin("Mouse::UseDefaultGraphic^0", (void *)set_default_cursor);
-	ccAddExternalFunctionForPlugin("Mouse::UseModeGraphic^1", (void *)set_mouse_cursor);
-	ccAddExternalFunctionForPlugin("Mouse::get_Mode", (void *)GetCursorMode);
-	ccAddExternalFunctionForPlugin("Mouse::set_Mode", (void *)set_cursor_mode);
-	ccAddExternalFunctionForPlugin("Mouse::get_Visible", (void *)Mouse_GetVisible);
-	ccAddExternalFunctionForPlugin("Mouse::set_Visible", (void *)Mouse_SetVisible);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/mouse.h b/engines/ags/engine/ac/mouse.h
index 84b590e170..a6fd01f90f 100644
--- a/engines/ags/engine/ac/mouse.h
+++ b/engines/ags/engine/ac/mouse.h
@@ -41,10 +41,12 @@ void Mouse_ChangeModeView(int curs, int newview);
 void SetMousePosition(int newx, int newy);
 int GetCursorMode();
 void SetNextCursor();
+void SetPreviousCursor();
 // permanently change cursor graphic
 void ChangeCursorGraphic(int curs, int newslot);
 void ChangeCursorHotspot(int curs, int x, int y);
 int IsButtonDown(int which);
+int IsModeEnabled(int which);
 void SetMouseBounds(int x1, int y1, int x2, int y2);
 void RefreshMouse();
 // mouse cursor functions:
diff --git a/engines/ags/engine/ac/object.cpp b/engines/ags/engine/ac/object.cpp
index 5cd1e0416d..d55a27d41f 100644
--- a/engines/ags/engine/ac/object.cpp
+++ b/engines/ags/engine/ac/object.cpp
@@ -881,57 +881,6 @@ void RegisterObjectAPI() {
 	ccAddExternalObjectFunction("Object::get_TintRed", Sc_Object_GetTintRed);
 	ccAddExternalObjectFunction("Object::get_TintSaturation", Sc_Object_GetTintSaturation);
 	ccAddExternalObjectFunction("Object::get_TintLuminance", Sc_Object_GetTintLuminance);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Object::Animate^5", (void *)Object_Animate);
-	ccAddExternalFunctionForPlugin("Object::IsCollidingWithObject^1", (void *)Object_IsCollidingWithObject);
-	ccAddExternalFunctionForPlugin("Object::GetName^1", (void *)Object_GetName);
-	ccAddExternalFunctionForPlugin("Object::GetProperty^1", (void *)Object_GetProperty);
-	ccAddExternalFunctionForPlugin("Object::GetPropertyText^2", (void *)Object_GetPropertyText);
-	ccAddExternalFunctionForPlugin("Object::GetTextProperty^1", (void *)Object_GetTextProperty);
-	ccAddExternalFunctionForPlugin("Object::MergeIntoBackground^0", (void *)Object_MergeIntoBackground);
-	ccAddExternalFunctionForPlugin("Object::Move^5", (void *)Object_Move);
-	ccAddExternalFunctionForPlugin("Object::RemoveTint^0", (void *)Object_RemoveTint);
-	ccAddExternalFunctionForPlugin("Object::RunInteraction^1", (void *)Object_RunInteraction);
-	ccAddExternalFunctionForPlugin("Object::SetPosition^2", (void *)Object_SetPosition);
-	ccAddExternalFunctionForPlugin("Object::SetView^3", (void *)Object_SetView);
-	ccAddExternalFunctionForPlugin("Object::StopAnimating^0", (void *)Object_StopAnimating);
-	ccAddExternalFunctionForPlugin("Object::StopMoving^0", (void *)Object_StopMoving);
-	ccAddExternalFunctionForPlugin("Object::Tint^5", (void *)Object_Tint);
-	ccAddExternalFunctionForPlugin("Object::GetAtRoomXY^2", (void *)GetObjectAtRoom);
-	ccAddExternalFunctionForPlugin("Object::GetAtScreenXY^2", (void *)GetObjectAtScreen);
-	ccAddExternalFunctionForPlugin("Object::get_Animating", (void *)Object_GetAnimating);
-	ccAddExternalFunctionForPlugin("Object::get_Baseline", (void *)Object_GetBaseline);
-	ccAddExternalFunctionForPlugin("Object::set_Baseline", (void *)Object_SetBaseline);
-	ccAddExternalFunctionForPlugin("Object::get_BlockingHeight", (void *)Object_GetBlockingHeight);
-	ccAddExternalFunctionForPlugin("Object::set_BlockingHeight", (void *)Object_SetBlockingHeight);
-	ccAddExternalFunctionForPlugin("Object::get_BlockingWidth", (void *)Object_GetBlockingWidth);
-	ccAddExternalFunctionForPlugin("Object::set_BlockingWidth", (void *)Object_SetBlockingWidth);
-	ccAddExternalFunctionForPlugin("Object::get_Clickable", (void *)Object_GetClickable);
-	ccAddExternalFunctionForPlugin("Object::set_Clickable", (void *)Object_SetClickable);
-	ccAddExternalFunctionForPlugin("Object::get_Frame", (void *)Object_GetFrame);
-	ccAddExternalFunctionForPlugin("Object::get_Graphic", (void *)Object_GetGraphic);
-	ccAddExternalFunctionForPlugin("Object::set_Graphic", (void *)Object_SetGraphic);
-	ccAddExternalFunctionForPlugin("Object::get_ID", (void *)Object_GetID);
-	ccAddExternalFunctionForPlugin("Object::get_IgnoreScaling", (void *)Object_GetIgnoreScaling);
-	ccAddExternalFunctionForPlugin("Object::set_IgnoreScaling", (void *)Object_SetIgnoreScaling);
-	ccAddExternalFunctionForPlugin("Object::get_IgnoreWalkbehinds", (void *)Object_GetIgnoreWalkbehinds);
-	ccAddExternalFunctionForPlugin("Object::set_IgnoreWalkbehinds", (void *)Object_SetIgnoreWalkbehinds);
-	ccAddExternalFunctionForPlugin("Object::get_Loop", (void *)Object_GetLoop);
-	ccAddExternalFunctionForPlugin("Object::get_Moving", (void *)Object_GetMoving);
-	ccAddExternalFunctionForPlugin("Object::get_Name", (void *)Object_GetName_New);
-	ccAddExternalFunctionForPlugin("Object::get_Solid", (void *)Object_GetSolid);
-	ccAddExternalFunctionForPlugin("Object::set_Solid", (void *)Object_SetSolid);
-	ccAddExternalFunctionForPlugin("Object::get_Transparency", (void *)Object_GetTransparency);
-	ccAddExternalFunctionForPlugin("Object::set_Transparency", (void *)Object_SetTransparency);
-	ccAddExternalFunctionForPlugin("Object::get_View", (void *)Object_GetView);
-	ccAddExternalFunctionForPlugin("Object::get_Visible", (void *)Object_GetVisible);
-	ccAddExternalFunctionForPlugin("Object::set_Visible", (void *)Object_SetVisible);
-	ccAddExternalFunctionForPlugin("Object::get_X", (void *)Object_GetX);
-	ccAddExternalFunctionForPlugin("Object::set_X", (void *)Object_SetX);
-	ccAddExternalFunctionForPlugin("Object::get_Y", (void *)Object_GetY);
-	ccAddExternalFunctionForPlugin("Object::set_Y", (void *)Object_SetY);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/object.h b/engines/ags/engine/ac/object.h
index add94e7a6d..395d9fe43d 100644
--- a/engines/ags/engine/ac/object.h
+++ b/engines/ags/engine/ac/object.h
@@ -47,6 +47,7 @@ using namespace AGS; // FIXME later
 extern AGS_INLINE int is_valid_object(int obtest);
 int     Object_IsCollidingWithObject(ScriptObject *objj, ScriptObject *obj2);
 ScriptObject *GetObjectAtScreen(int xx, int yy);
+ScriptObject *GetObjectAtRoom(int x, int y);
 void    Object_Tint(ScriptObject *objj, int red, int green, int blue, int saturation, int luminance);
 void    Object_RemoveTint(ScriptObject *objj);
 void    Object_SetView(ScriptObject *objj, int view, int loop, int frame);
diff --git a/engines/ags/engine/ac/overlay.cpp b/engines/ags/engine/ac/overlay.cpp
index 76111ee1dc..b3cccac2e9 100644
--- a/engines/ags/engine/ac/overlay.cpp
+++ b/engines/ags/engine/ac/overlay.cpp
@@ -336,12 +336,6 @@ RuntimeScriptValue Sc_Overlay_SetY(void *self, const RuntimeScriptValue *params,
 //
 //=============================================================================
 
-// ScriptOverlay* (int x, int y, int width, int font, int colour, const char* text, ...)
-ScriptOverlay *ScPl_Overlay_CreateTextual(int x, int y, int width, int font, int colour, const char *text, ...) {
-	API_PLUGIN_SCRIPT_SPRINTF(text);
-	return Overlay_CreateTextual(x, y, width, font, colour, scsf_buffer);
-}
-
 // void (ScriptOverlay *scover, int wii, int fontid, int clr, char*texx, ...)
 void ScPl_Overlay_SetText(ScriptOverlay *scover, int wii, int fontid, int clr, char *texx, ...) {
 	API_PLUGIN_SCRIPT_SPRINTF(texx);
@@ -359,18 +353,6 @@ void RegisterOverlayAPI() {
 	ccAddExternalObjectFunction("Overlay::set_X", Sc_Overlay_SetX);
 	ccAddExternalObjectFunction("Overlay::get_Y", Sc_Overlay_GetY);
 	ccAddExternalObjectFunction("Overlay::set_Y", Sc_Overlay_SetY);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Overlay::CreateGraphical^4", (void *)Overlay_CreateGraphical);
-	ccAddExternalFunctionForPlugin("Overlay::CreateTextual^106", (void *)ScPl_Overlay_CreateTextual);
-	ccAddExternalFunctionForPlugin("Overlay::SetText^104", (void *)ScPl_Overlay_SetText);
-	ccAddExternalFunctionForPlugin("Overlay::Remove^0", (void *)Overlay_Remove);
-	ccAddExternalFunctionForPlugin("Overlay::get_Valid", (void *)Overlay_GetValid);
-	ccAddExternalFunctionForPlugin("Overlay::get_X", (void *)Overlay_GetX);
-	ccAddExternalFunctionForPlugin("Overlay::set_X", (void *)Overlay_SetX);
-	ccAddExternalFunctionForPlugin("Overlay::get_Y", (void *)Overlay_GetY);
-	ccAddExternalFunctionForPlugin("Overlay::set_Y", (void *)Overlay_SetY);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/parser.cpp b/engines/ags/engine/ac/parser.cpp
index 641bde48a0..c0a0eab92f 100644
--- a/engines/ags/engine/ac/parser.cpp
+++ b/engines/ags/engine/ac/parser.cpp
@@ -332,13 +332,6 @@ void RegisterParserAPI() {
 	ccAddExternalStaticFunction("Parser::ParseText^1", Sc_ParseText);
 	ccAddExternalStaticFunction("Parser::SaidUnknownWord^0", Sc_Parser_SaidUnknownWord);
 	ccAddExternalStaticFunction("Parser::Said^1", Sc_Said);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Parser::FindWordID^1", (void *)Parser_FindWordID);
-	ccAddExternalFunctionForPlugin("Parser::ParseText^1", (void *)ParseText);
-	ccAddExternalFunctionForPlugin("Parser::SaidUnknownWord^0", (void *)Parser_SaidUnknownWord);
-	ccAddExternalFunctionForPlugin("Parser::Said^1", (void *)Said);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/region.cpp b/engines/ags/engine/ac/region.cpp
index 6a6fe1d475..fa37c4f514 100644
--- a/engines/ags/engine/ac/region.cpp
+++ b/engines/ags/engine/ac/region.cpp
@@ -228,23 +228,6 @@ void RegisterRegionAPI() {
 	ccAddExternalObjectFunction("Region::get_TintRed", Sc_Region_GetTintRed);
 	ccAddExternalObjectFunction("Region::get_TintSaturation", Sc_Region_GetTintSaturation);
 	ccAddExternalObjectFunction("Region::get_TintLuminance", Sc_Region_GetTintLuminance);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Region::GetAtRoomXY^2", (void *)GetRegionAtRoom);
-	ccAddExternalFunctionForPlugin("Region::GetAtScreenXY^2", (void *)GetRegionAtScreen);
-	ccAddExternalFunctionForPlugin("Region::Tint^4", (void *)Region_TintNoLum);
-	ccAddExternalFunctionForPlugin("Region::RunInteraction^1", (void *)Region_RunInteraction);
-	ccAddExternalFunctionForPlugin("Region::get_Enabled", (void *)Region_GetEnabled);
-	ccAddExternalFunctionForPlugin("Region::set_Enabled", (void *)Region_SetEnabled);
-	ccAddExternalFunctionForPlugin("Region::get_ID", (void *)Region_GetID);
-	ccAddExternalFunctionForPlugin("Region::get_LightLevel", (void *)Region_GetLightLevel);
-	ccAddExternalFunctionForPlugin("Region::set_LightLevel", (void *)Region_SetLightLevel);
-	ccAddExternalFunctionForPlugin("Region::get_TintEnabled", (void *)Region_GetTintEnabled);
-	ccAddExternalFunctionForPlugin("Region::get_TintBlue", (void *)Region_GetTintBlue);
-	ccAddExternalFunctionForPlugin("Region::get_TintGreen", (void *)Region_GetTintGreen);
-	ccAddExternalFunctionForPlugin("Region::get_TintRed", (void *)Region_GetTintRed);
-	ccAddExternalFunctionForPlugin("Region::get_TintSaturation", (void *)Region_GetTintSaturation);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/region.h b/engines/ags/engine/ac/region.h
index 4d6c61dde4..cf7a916797 100644
--- a/engines/ags/engine/ac/region.h
+++ b/engines/ags/engine/ac/region.h
@@ -28,6 +28,7 @@
 namespace AGS3 {
 
 ScriptRegion *GetRegionAtRoom(int xx, int yy);
+ScriptRegion *GetRegionAtScreen(int x, int y);
 void    Region_SetLightLevel(ScriptRegion *ssr, int brightness);
 int     Region_GetLightLevel(ScriptRegion *ssr);
 int     Region_GetTintEnabled(ScriptRegion *srr);
@@ -43,6 +44,7 @@ int     Region_GetID(ScriptRegion *ssr);
 void    Region_RunInteraction(ScriptRegion *ssr, int mood);
 
 void    generate_light_table();
+void    Region_TintNoLum(ScriptRegion *srr, int red, int green, int blue, int amount);
 
 } // namespace AGS3
 
diff --git a/engines/ags/engine/ac/room.cpp b/engines/ags/engine/ac/room.cpp
index 0b957dbe9d..9305c69a81 100644
--- a/engines/ags/engine/ac/room.cpp
+++ b/engines/ags/engine/ac/room.cpp
@@ -1177,22 +1177,6 @@ void RegisterRoomAPI() {
 	ccAddExternalStaticFunction("Room::get_RightEdge",                      Sc_Room_GetRightEdge);
 	ccAddExternalStaticFunction("Room::get_TopEdge",                        Sc_Room_GetTopEdge);
 	ccAddExternalStaticFunction("Room::get_Width",                          Sc_Room_GetWidth);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Room::GetDrawingSurfaceForBackground^1", (void *)Room_GetDrawingSurfaceForBackground);
-	ccAddExternalFunctionForPlugin("Room::GetProperty^1", (void *)Room_GetProperty);
-	ccAddExternalFunctionForPlugin("Room::GetTextProperty^1", (void *)Room_GetTextProperty);
-	ccAddExternalFunctionForPlugin("Room::get_BottomEdge", (void *)Room_GetBottomEdge);
-	ccAddExternalFunctionForPlugin("Room::get_ColorDepth", (void *)Room_GetColorDepth);
-	ccAddExternalFunctionForPlugin("Room::get_Height", (void *)Room_GetHeight);
-	ccAddExternalFunctionForPlugin("Room::get_LeftEdge", (void *)Room_GetLeftEdge);
-	ccAddExternalFunctionForPlugin("Room::geti_Messages", (void *)Room_GetMessages);
-	ccAddExternalFunctionForPlugin("Room::get_MusicOnLoad", (void *)Room_GetMusicOnLoad);
-	ccAddExternalFunctionForPlugin("Room::get_ObjectCount", (void *)Room_GetObjectCount);
-	ccAddExternalFunctionForPlugin("Room::get_RightEdge", (void *)Room_GetRightEdge);
-	ccAddExternalFunctionForPlugin("Room::get_TopEdge", (void *)Room_GetTopEdge);
-	ccAddExternalFunctionForPlugin("Room::get_Width", (void *)Room_GetWidth);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/slider.cpp b/engines/ags/engine/ac/slider.cpp
index 2541ab71e3..6b3195ce9d 100644
--- a/engines/ags/engine/ac/slider.cpp
+++ b/engines/ags/engine/ac/slider.cpp
@@ -196,21 +196,6 @@ void RegisterSliderAPI() {
 	ccAddExternalObjectFunction("Slider::set_Min", Sc_Slider_SetMin);
 	ccAddExternalObjectFunction("Slider::get_Value", Sc_Slider_GetValue);
 	ccAddExternalObjectFunction("Slider::set_Value", Sc_Slider_SetValue);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("Slider::get_BackgroundGraphic", (void *)Slider_GetBackgroundGraphic);
-	ccAddExternalFunctionForPlugin("Slider::set_BackgroundGraphic", (void *)Slider_SetBackgroundGraphic);
-	ccAddExternalFunctionForPlugin("Slider::get_HandleGraphic", (void *)Slider_GetHandleGraphic);
-	ccAddExternalFunctionForPlugin("Slider::set_HandleGraphic", (void *)Slider_SetHandleGraphic);
-	ccAddExternalFunctionForPlugin("Slider::get_HandleOffset", (void *)Slider_GetHandleOffset);
-	ccAddExternalFunctionForPlugin("Slider::set_HandleOffset", (void *)Slider_SetHandleOffset);
-	ccAddExternalFunctionForPlugin("Slider::get_Max", (void *)Slider_GetMax);
-	ccAddExternalFunctionForPlugin("Slider::set_Max", (void *)Slider_SetMax);
-	ccAddExternalFunctionForPlugin("Slider::get_Min", (void *)Slider_GetMin);
-	ccAddExternalFunctionForPlugin("Slider::set_Min", (void *)Slider_SetMin);
-	ccAddExternalFunctionForPlugin("Slider::get_Value", (void *)Slider_GetValue);
-	ccAddExternalFunctionForPlugin("Slider::set_Value", (void *)Slider_SetValue);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/string.cpp b/engines/ags/engine/ac/string.cpp
index 9610c7c61b..cb8346c44e 100644
--- a/engines/ags/engine/ac/string.cpp
+++ b/engines/ags/engine/ac/string.cpp
@@ -432,13 +432,6 @@ RuntimeScriptValue Sc_strlen(void *self, const RuntimeScriptValue *params, int32
 //
 //=============================================================================
 
-// const char* (const char *texx, ...)
-const char *ScPl_String_Format(const char *texx, ...) {
-	API_PLUGIN_SCRIPT_SPRINTF(texx);
-	return CreateNewScriptString(scsf_buffer);
-}
-
-
 void RegisterStringAPI() {
 	ccAddExternalStaticFunction("String::IsNullOrEmpty^1", Sc_String_IsNullOrEmpty);
 	ccAddExternalObjectFunction("String::Append^1", Sc_String_Append);
@@ -460,29 +453,6 @@ void RegisterStringAPI() {
 	ccAddExternalObjectFunction("String::get_AsInt", Sc_StringToInt);
 	ccAddExternalObjectFunction("String::geti_Chars", Sc_String_GetChars);
 	ccAddExternalObjectFunction("String::get_Length", Sc_strlen);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("String::IsNullOrEmpty^1", (void *)String_IsNullOrEmpty);
-	ccAddExternalFunctionForPlugin("String::Append^1", (void *)String_Append);
-	ccAddExternalFunctionForPlugin("String::AppendChar^1", (void *)String_AppendChar);
-	ccAddExternalFunctionForPlugin("String::CompareTo^2", (void *)String_CompareTo);
-	ccAddExternalFunctionForPlugin("String::Contains^1", (void *)StrContains);
-	ccAddExternalFunctionForPlugin("String::Copy^0", (void *)String_Copy);
-	ccAddExternalFunctionForPlugin("String::EndsWith^2", (void *)String_EndsWith);
-	ccAddExternalFunctionForPlugin("String::Format^101", (void *)ScPl_String_Format);
-	ccAddExternalFunctionForPlugin("String::IndexOf^1", (void *)StrContains);
-	ccAddExternalFunctionForPlugin("String::LowerCase^0", (void *)String_LowerCase);
-	ccAddExternalFunctionForPlugin("String::Replace^3", (void *)String_Replace);
-	ccAddExternalFunctionForPlugin("String::ReplaceCharAt^2", (void *)String_ReplaceCharAt);
-	ccAddExternalFunctionForPlugin("String::StartsWith^2", (void *)String_StartsWith);
-	ccAddExternalFunctionForPlugin("String::Substring^2", (void *)String_Substring);
-	ccAddExternalFunctionForPlugin("String::Truncate^1", (void *)String_Truncate);
-	ccAddExternalFunctionForPlugin("String::UpperCase^0", (void *)String_UpperCase);
-	ccAddExternalFunctionForPlugin("String::get_AsFloat", (void *)StringToFloat);
-	ccAddExternalFunctionForPlugin("String::get_AsInt", (void *)StringToInt);
-	ccAddExternalFunctionForPlugin("String::geti_Chars", (void *)String_GetChars);
-	ccAddExternalFunctionForPlugin("String::get_Length", (void *)strlen);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/string.h b/engines/ags/engine/ac/string.h
index 46740ea7f7..f1701270b7 100644
--- a/engines/ags/engine/ac/string.h
+++ b/engines/ags/engine/ac/string.h
@@ -40,13 +40,14 @@ const char *String_Truncate(const char *thisString, int length);
 const char *String_Substring(const char *thisString, int index, int length);
 int String_CompareTo(const char *thisString, const char *otherString, bool caseSensitive);
 int String_StartsWith(const char *thisString, const char *checkForString, bool caseSensitive);
-int String_EndsWith(const char *thisString, const char *checkForString, bool caseSensitive);
+int String_EfndsWith(const char *thisString, const char *checkForString, bool caseSensitive);
 const char *String_Replace(const char *thisString, const char *lookForText, const char *replaceWithText, bool caseSensitive);
 const char *String_LowerCase(const char *thisString);
 const char *String_UpperCase(const char *thisString);
 int String_GetChars(const char *texx, int index);
 int StringToInt(const char *stino);
 int StrContains(const char *s1, const char *s2);
+int String_EndsWith(const char *thisString, const char *checkForString, bool caseSensitive);
 
 //=============================================================================
 
diff --git a/engines/ags/engine/ac/system.cpp b/engines/ags/engine/ac/system.cpp
index 161db5e3d1..8c62d528ea 100644
--- a/engines/ags/engine/ac/system.cpp
+++ b/engines/ags/engine/ac/system.cpp
@@ -372,32 +372,6 @@ void RegisterSystemAPI() {
 
 	ccAddExternalStaticFunction("System::SaveConfigToFile", Sc_System_SaveConfigToFile);
 	ccAddExternalStaticFunction("System::Log^102", Sc_System_Log);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("System::get_AudioChannelCount", (void *)System_GetAudioChannelCount);
-	ccAddExternalFunctionForPlugin("System::geti_AudioChannels", (void *)System_GetAudioChannels);
-	ccAddExternalFunctionForPlugin("System::get_CapsLock", (void *)System_GetCapsLock);
-	ccAddExternalFunctionForPlugin("System::get_ColorDepth", (void *)System_GetColorDepth);
-	ccAddExternalFunctionForPlugin("System::get_Gamma", (void *)System_GetGamma);
-	ccAddExternalFunctionForPlugin("System::set_Gamma", (void *)System_SetGamma);
-	ccAddExternalFunctionForPlugin("System::get_HardwareAcceleration", (void *)System_GetHardwareAcceleration);
-	ccAddExternalFunctionForPlugin("System::get_NumLock", (void *)System_GetNumLock);
-	ccAddExternalFunctionForPlugin("System::get_OperatingSystem", (void *)System_GetOS);
-	ccAddExternalFunctionForPlugin("System::get_RuntimeInfo", (void *)System_GetRuntimeInfo);
-	ccAddExternalFunctionForPlugin("System::get_ScreenHeight", (void *)System_GetScreenHeight);
-	ccAddExternalFunctionForPlugin("System::get_ScreenWidth", (void *)System_GetScreenWidth);
-	ccAddExternalFunctionForPlugin("System::get_ScrollLock", (void *)System_GetScrollLock);
-	ccAddExternalFunctionForPlugin("System::get_SupportsGammaControl", (void *)System_GetSupportsGammaControl);
-	ccAddExternalFunctionForPlugin("System::get_Version", (void *)System_GetVersion);
-	ccAddExternalFunctionForPlugin("SystemInfo::get_Version", (void *)System_GetVersion);
-	ccAddExternalFunctionForPlugin("System::get_ViewportHeight", (void *)System_GetViewportHeight);
-	ccAddExternalFunctionForPlugin("System::get_ViewportWidth", (void *)System_GetViewportWidth);
-	ccAddExternalFunctionForPlugin("System::get_Volume", (void *)System_GetVolume);
-	ccAddExternalFunctionForPlugin("System::set_Volume", (void *)System_SetVolume);
-	ccAddExternalFunctionForPlugin("System::get_VSync", (void *)System_GetVsync);
-	ccAddExternalFunctionForPlugin("System::set_VSync", (void *)System_SetVsync);
-	ccAddExternalFunctionForPlugin("System::get_Windowed", (void *)System_GetWindowed);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/textbox.cpp b/engines/ags/engine/ac/textbox.cpp
index b783ef4a75..eb57df83f2 100644
--- a/engines/ags/engine/ac/textbox.cpp
+++ b/engines/ags/engine/ac/textbox.cpp
@@ -147,17 +147,6 @@ void RegisterTextBoxAPI() {
 	ccAddExternalObjectFunction("TextBox::set_Text", Sc_TextBox_SetText);
 	ccAddExternalObjectFunction("TextBox::get_TextColor", Sc_TextBox_GetTextColor);
 	ccAddExternalObjectFunction("TextBox::set_TextColor", Sc_TextBox_SetTextColor);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("TextBox::GetText^1", (void *)TextBox_GetText);
-	ccAddExternalFunctionForPlugin("TextBox::SetText^1", (void *)TextBox_SetText);
-	ccAddExternalFunctionForPlugin("TextBox::get_Font", (void *)TextBox_GetFont);
-	ccAddExternalFunctionForPlugin("TextBox::set_Font", (void *)TextBox_SetFont);
-	ccAddExternalFunctionForPlugin("TextBox::get_Text", (void *)TextBox_GetText_New);
-	ccAddExternalFunctionForPlugin("TextBox::set_Text", (void *)TextBox_SetText);
-	ccAddExternalFunctionForPlugin("TextBox::get_TextColor", (void *)TextBox_GetTextColor);
-	ccAddExternalFunctionForPlugin("TextBox::set_TextColor", (void *)TextBox_SetTextColor);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/engine/ac/view_frame.cpp b/engines/ags/engine/ac/view_frame.cpp
index f199e774d1..f4ba47e136 100644
--- a/engines/ags/engine/ac/view_frame.cpp
+++ b/engines/ags/engine/ac/view_frame.cpp
@@ -250,20 +250,6 @@ void RegisterViewFrameAPI() {
 	ccAddExternalObjectFunction("ViewFrame::set_Sound", Sc_ViewFrame_SetSound);
 	ccAddExternalObjectFunction("ViewFrame::get_Speed", Sc_ViewFrame_GetSpeed);
 	ccAddExternalObjectFunction("ViewFrame::get_View", Sc_ViewFrame_GetView);
-
-	/* ----------------------- Registering unsafe exports for plugins -----------------------*/
-
-	ccAddExternalFunctionForPlugin("ViewFrame::get_Flipped", (void *)ViewFrame_GetFlipped);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_Frame", (void *)ViewFrame_GetFrame);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_Graphic", (void *)ViewFrame_GetGraphic);
-	ccAddExternalFunctionForPlugin("ViewFrame::set_Graphic", (void *)ViewFrame_SetGraphic);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_LinkedAudio", (void *)ViewFrame_GetLinkedAudio);
-	ccAddExternalFunctionForPlugin("ViewFrame::set_LinkedAudio", (void *)ViewFrame_SetLinkedAudio);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_Loop", (void *)ViewFrame_GetLoop);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_Sound", (void *)ViewFrame_GetSound);
-	ccAddExternalFunctionForPlugin("ViewFrame::set_Sound", (void *)ViewFrame_SetSound);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_Speed", (void *)ViewFrame_GetSpeed);
-	ccAddExternalFunctionForPlugin("ViewFrame::get_View", (void *)ViewFrame_GetView);
 }
 
 } // namespace AGS3
diff --git a/engines/ags/plugins/core/math.cpp b/engines/ags/plugins/core/math.cpp
index d11cb0fa45..faa8f3e553 100644
--- a/engines/ags/plugins/core/math.cpp
+++ b/engines/ags/plugins/core/math.cpp
@@ -28,6 +28,113 @@ namespace Plugins {
 namespace Core {
 
 void Math::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Maths::ArcCos^1, ArcCos);
+	SCRIPT_METHOD_EXT(Maths::ArcSin^1, ArcSin);
+	SCRIPT_METHOD_EXT(Maths::ArcTan^1, ArcTan);
+	SCRIPT_METHOD_EXT(Maths::ArcTan2^2, ArcTan2);
+	SCRIPT_METHOD_EXT(Maths::Cos^1, Cos);
+	SCRIPT_METHOD_EXT(Maths::Cosh^1, Cosh);
+	SCRIPT_METHOD_EXT(Maths::DegreesToRadians^1, DegreesToRadians);
+	SCRIPT_METHOD_EXT(Maths::Exp^1, Exp);
+	SCRIPT_METHOD_EXT(Maths::Log^1, Log);
+	SCRIPT_METHOD_EXT(Maths::Log10^1, Log10);
+	SCRIPT_METHOD_EXT(Maths::RadiansToDegrees^1, RadiansToDegrees);
+	SCRIPT_METHOD_EXT(Maths::RaiseToPower^2, RaiseToPower);
+	SCRIPT_METHOD_EXT(Maths::Sin^1, Sin);
+	SCRIPT_METHOD_EXT(Maths::Sinh^1, Sinh);
+	SCRIPT_METHOD_EXT(Maths::Sqrt^1, Sqrt);
+	SCRIPT_METHOD_EXT(Maths::Tan^1, Tan);
+	SCRIPT_METHOD_EXT(Maths::Tanh^1, Tanh);
+	SCRIPT_METHOD_EXT(Maths::get_Pi, GetPi);
+}
+
+void Math::ArcCos(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_ArcCos(value);
+}
+
+void Math::ArcSin(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_ArcSin(value);
+}
+
+void Math::ArcTan(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_ArcTan(value);
+}
+
+void Math::ArcTan2(ScriptMethodParams &params) {
+	PARAMS2(float, yval, float, xval);
+	params._result = AGS3::Math_ArcTan2(xval, yval);
+}
+
+void Math::Cos(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Cos(value);
+}
+
+void Math::Cosh(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Cosh(value);
+}
+
+void Math::DegreesToRadians(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_DegreesToRadians(value);
+}
+
+void Math::Exp(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Exp(value);
+}
+
+void Math::Log(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Log(value);
+}
+
+void Math::Log10(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Log10(value);
+}
+
+void Math::RadiansToDegrees(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_RadiansToDegrees(value);
+}
+
+void Math::RaiseToPower(ScriptMethodParams &params) {
+	PARAMS2(float, base, float, exp);
+	params._result = AGS3::Math_RaiseToPower(base, exp);
+}
+
+void Math::Sin(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Sin(value);
+}
+
+void Math::Sinh(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Sinh(value);
+}
+
+void Math::Sqrt(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Sqrt(value);
+}
+
+void Math::Tan(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Tan(value);
+}
+
+void Math::Tanh(ScriptMethodParams &params) {
+	PARAMS1(float, value);
+	params._result = AGS3::Math_Tanh(value);
+}
+
+void Math::GetPi(ScriptMethodParams &params) {
+	params._result = AGS3::Math_GetPi();
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/math.h b/engines/ags/plugins/core/math.h
index da09ab87c0..133231dbdd 100644
--- a/engines/ags/plugins/core/math.h
+++ b/engines/ags/plugins/core/math.h
@@ -33,7 +33,24 @@ class Math : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void ArcCos(ScriptMethodParams &params);
+	static void ArcSin(ScriptMethodParams &params);
+	static void ArcTan(ScriptMethodParams &params);
+	static void ArcTan2(ScriptMethodParams &params);
+	static void Cos(ScriptMethodParams &params);
+	static void Cosh(ScriptMethodParams &params);
+	static void DegreesToRadians(ScriptMethodParams &params);
+	static void Exp(ScriptMethodParams &params);
+	static void Log(ScriptMethodParams &params);
+	static void Log10(ScriptMethodParams &params);
+	static void RadiansToDegrees(ScriptMethodParams &params);
+	static void RaiseToPower(ScriptMethodParams &params);
+	static void Sin(ScriptMethodParams &params);
+	static void Sinh(ScriptMethodParams &params);
+	static void Sqrt(ScriptMethodParams &params);
+	static void Tan(ScriptMethodParams &params);
+	static void Tanh(ScriptMethodParams &params);
+	static void GetPi(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/mouse.cpp b/engines/ags/plugins/core/mouse.cpp
index ce57ae0804..44fa1078d1 100644
--- a/engines/ags/plugins/core/mouse.cpp
+++ b/engines/ags/plugins/core/mouse.cpp
@@ -22,12 +22,126 @@
 
 #include "ags/plugins/core/mouse.h"
 #include "ags/engine/ac/mouse.h"
+#include "ags/engine/ac/global_game.h"
 
 namespace AGS3 {
 namespace Plugins {
 namespace Core {
 
 void Mouse::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Mouse::ChangeModeGraphic^2, ChangeCursorGraphic);
+	SCRIPT_METHOD_EXT(Mouse::ChangeModeHotspot^3, ChangeCursorHotspot);
+	SCRIPT_METHOD_EXT(Mouse::ChangeModeView^2, Mouse_ChangeModeView);
+	SCRIPT_METHOD_EXT(Mouse::DisableMode^1, disable_cursor_mode);
+	SCRIPT_METHOD_EXT(Mouse::EnableMode^1, enable_cursor_mode);
+	SCRIPT_METHOD_EXT(Mouse::GetModeGraphic^1, Mouse_GetModeGraphic);
+	SCRIPT_METHOD_EXT(Mouse::IsButtonDown^1, IsButtonDown);
+	SCRIPT_METHOD_EXT(Mouse::IsModeEnabled^1, IsModeEnabled);
+	SCRIPT_METHOD_EXT(Mouse::SaveCursorUntilItLeaves^0, SaveCursorForLocationChange);
+	SCRIPT_METHOD_EXT(Mouse::SelectNextMode^0, SetNextCursor);
+	SCRIPT_METHOD_EXT(Mouse::SelectPreviousMode^0, SetPreviousCursor);
+	SCRIPT_METHOD_EXT(Mouse::SetBounds^4, SetMouseBounds);
+	SCRIPT_METHOD_EXT(Mouse::SetPosition^2, SetMousePosition);
+	SCRIPT_METHOD_EXT(Mouse::Update^0, RefreshMouse);
+	SCRIPT_METHOD_EXT(Mouse::UseDefaultGraphic^0, set_default_cursor);
+	SCRIPT_METHOD_EXT(Mouse::UseModeGraphic^1, set_mouse_cursor);
+	SCRIPT_METHOD_EXT(Mouse::get_Mode, GetCursorMode);
+	SCRIPT_METHOD_EXT(Mouse::set_Mode, set_cursor_mode);
+	SCRIPT_METHOD_EXT(Mouse::get_Visible, Mouse_GetVisible);
+	SCRIPT_METHOD_EXT(Mouse::set_Visible, Mouse_SetVisible);
+}
+
+void Mouse::ChangeCursorGraphic(ScriptMethodParams &params) {
+	PARAMS2(int, curs, int, newslot);
+	AGS3::ChangeCursorGraphic(curs, newslot);
+}
+
+void Mouse::ChangeCursorHotspot(ScriptMethodParams &params) {
+	PARAMS3(int, curs, int, x, int, y);
+	AGS3::ChangeCursorHotspot(curs, x, y);
+}
+
+void Mouse::Mouse_ChangeModeView(ScriptMethodParams &params) {
+	PARAMS2(int, curs, int, newview);
+	AGS3::Mouse_ChangeModeView(curs, newview);
+}
+
+void Mouse::disable_cursor_mode(ScriptMethodParams &params) {
+	PARAMS1(int, modd);
+	AGS3::disable_cursor_mode(modd);
+}
+
+void Mouse::enable_cursor_mode(ScriptMethodParams &params) {
+	PARAMS1(int, modd);
+	AGS3::enable_cursor_mode(modd);
+}
+
+void Mouse::Mouse_GetModeGraphic(ScriptMethodParams &params) {
+	PARAMS1(int, curs);
+	params._result = AGS3::Mouse_GetModeGraphic(curs);
+}
+
+void Mouse::IsButtonDown(ScriptMethodParams &params) {
+	PARAMS1(int, curs);
+	params._result = AGS3::IsButtonDown(curs);
+}
+
+void Mouse::IsModeEnabled(ScriptMethodParams &params) {
+	PARAMS1(int, curs);
+	params._result = AGS3::IsModeEnabled(curs);
+}
+
+void Mouse::SaveCursorForLocationChange(ScriptMethodParams &params) {
+	AGS3::SaveCursorForLocationChange();
+}
+
+void Mouse::SetNextCursor(ScriptMethodParams &params) {
+	AGS3::SetNextCursor();
+}
+
+void Mouse::SetPreviousCursor(ScriptMethodParams &params) {
+	AGS3::SetPreviousCursor();
+}
+
+void Mouse::SetMouseBounds(ScriptMethodParams &params) {
+	PARAMS4(int, x1, int, y1, int, x2, int, y2);
+	AGS3::SetMouseBounds(x1, y1, x2, y2);
+}
+
+void Mouse::SetMousePosition(ScriptMethodParams &params) {
+	PARAMS2(int, newx, int, newy);
+	AGS3::SetMousePosition(newx, newy);
+}
+
+void Mouse::RefreshMouse(ScriptMethodParams &params) {
+	AGS3::RefreshMouse();
+}
+
+void Mouse::set_default_cursor(ScriptMethodParams &params) {
+	AGS3::set_default_cursor();
+}
+
+void Mouse::set_mouse_cursor(ScriptMethodParams &params) {
+	PARAMS1(int, newcurs);
+	AGS3::set_mouse_cursor(newcurs);
+}
+
+void Mouse::GetCursorMode(ScriptMethodParams &params) {
+	params._result = AGS3::GetCursorMode();
+}
+
+void Mouse::set_cursor_mode(ScriptMethodParams &params) {
+	PARAMS1(int, newmode);
+	AGS3::set_cursor_mode(newmode);
+}
+
+void Mouse::Mouse_GetVisible(ScriptMethodParams &params) {
+	params._result = AGS3::Mouse_GetVisible();
+}
+
+void Mouse::Mouse_SetVisible(ScriptMethodParams &params) {
+	PARAMS1(int, isOn);
+	AGS3::Mouse_SetVisible(isOn);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/mouse.h b/engines/ags/plugins/core/mouse.h
index 41534c0d7a..0f578c59c7 100644
--- a/engines/ags/plugins/core/mouse.h
+++ b/engines/ags/plugins/core/mouse.h
@@ -33,7 +33,26 @@ class Mouse : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void ChangeCursorGraphic(ScriptMethodParams &params);
+	static void ChangeCursorHotspot(ScriptMethodParams &params);
+	static void Mouse_ChangeModeView(ScriptMethodParams &params);
+	static void disable_cursor_mode(ScriptMethodParams &params);
+	static void enable_cursor_mode(ScriptMethodParams &params);
+	static void Mouse_GetModeGraphic(ScriptMethodParams &params);
+	static void IsButtonDown(ScriptMethodParams &params);
+	static void IsModeEnabled(ScriptMethodParams &params);
+	static void SaveCursorForLocationChange(ScriptMethodParams &params);
+	static void SetNextCursor(ScriptMethodParams &params);
+	static void SetPreviousCursor(ScriptMethodParams &params);
+	static void SetMouseBounds(ScriptMethodParams &params);
+	static void SetMousePosition(ScriptMethodParams &params);
+	static void RefreshMouse(ScriptMethodParams &params);
+	static void set_default_cursor(ScriptMethodParams &params);
+	static void set_mouse_cursor(ScriptMethodParams &params);
+	static void GetCursorMode(ScriptMethodParams &params);
+	static void set_cursor_mode(ScriptMethodParams &params);
+	static void Mouse_GetVisible(ScriptMethodParams &params);
+	static void Mouse_SetVisible(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/object.cpp b/engines/ags/plugins/core/object.cpp
index 676eef5e38..16dd6085fc 100644
--- a/engines/ags/plugins/core/object.cpp
+++ b/engines/ags/plugins/core/object.cpp
@@ -28,6 +28,294 @@ namespace Plugins {
 namespace Core {
 
 void Object::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Object::Animate^5, Animate);
+	SCRIPT_METHOD_EXT(Object::IsCollidingWithObject^1, IsCollidingWithObject);
+	SCRIPT_METHOD_EXT(Object::GetName^1, GetName);
+	SCRIPT_METHOD_EXT(Object::GetProperty^1, GetProperty);
+	SCRIPT_METHOD_EXT(Object::GetPropertyText^2, GetPropertyText);
+	SCRIPT_METHOD_EXT(Object::GetTextProperty^1, GetTextProperty);
+	SCRIPT_METHOD_EXT(Object::MergeIntoBackground^0, MergeIntoBackground);
+	SCRIPT_METHOD_EXT(Object::Move^5, Move);
+	SCRIPT_METHOD_EXT(Object::RemoveTint^0, RemoveTint);
+	SCRIPT_METHOD_EXT(Object::RunInteraction^1, RunInteraction);
+	SCRIPT_METHOD_EXT(Object::SetPosition^2, SetPosition);
+	SCRIPT_METHOD_EXT(Object::SetView^3, SetView);
+	SCRIPT_METHOD_EXT(Object::StopAnimating^0, StopAnimating);
+	SCRIPT_METHOD_EXT(Object::StopMoving^0, StopMoving);
+	SCRIPT_METHOD_EXT(Object::Tint^5, Tint);
+	SCRIPT_METHOD_EXT(Object::GetAtRoomXY^2, GetObjectAtRoom);
+	SCRIPT_METHOD_EXT(Object::GetAtScreenXY^2, GetObjectAtScreen);
+	SCRIPT_METHOD_EXT(Object::get_Animating, GetAnimating);
+	SCRIPT_METHOD_EXT(Object::get_Baseline, GetBaseline);
+	SCRIPT_METHOD_EXT(Object::set_Baseline, SetBaseline);
+	SCRIPT_METHOD_EXT(Object::get_BlockingHeight, GetBlockingHeight);
+	SCRIPT_METHOD_EXT(Object::set_BlockingHeight, SetBlockingHeight);
+	SCRIPT_METHOD_EXT(Object::get_BlockingWidth, GetBlockingWidth);
+	SCRIPT_METHOD_EXT(Object::set_BlockingWidth, SetBlockingWidth);
+	SCRIPT_METHOD_EXT(Object::get_Clickable, GetClickable);
+	SCRIPT_METHOD_EXT(Object::set_Clickable, SetClickable);
+	SCRIPT_METHOD_EXT(Object::get_Frame, GetFrame);
+	SCRIPT_METHOD_EXT(Object::get_Graphic, GetGraphic);
+	SCRIPT_METHOD_EXT(Object::set_Graphic, SetGraphic);
+	SCRIPT_METHOD_EXT(Object::get_ID, GetID);
+	SCRIPT_METHOD_EXT(Object::get_IgnoreScaling, GetIgnoreScaling);
+	SCRIPT_METHOD_EXT(Object::set_IgnoreScaling, SetIgnoreScaling);
+	SCRIPT_METHOD_EXT(Object::get_IgnoreWalkbehinds, GetIgnoreWalkbehinds);
+	SCRIPT_METHOD_EXT(Object::set_IgnoreWalkbehinds, SetIgnoreWalkbehinds);
+	SCRIPT_METHOD_EXT(Object::get_Loop, GetLoop);
+	SCRIPT_METHOD_EXT(Object::get_Moving, GetMoving);
+	SCRIPT_METHOD_EXT(Object::get_Name, GetName_New);
+	SCRIPT_METHOD_EXT(Object::get_Solid, GetSolid);
+	SCRIPT_METHOD_EXT(Object::set_Solid, SetSolid);
+	SCRIPT_METHOD_EXT(Object::get_Transparency, GetTransparency);
+	SCRIPT_METHOD_EXT(Object::set_Transparency, SetTransparency);
+	SCRIPT_METHOD_EXT(Object::get_View, GetView);
+	SCRIPT_METHOD_EXT(Object::get_Visible, GetVisible);
+	SCRIPT_METHOD_EXT(Object::set_Visible, SetVisible);
+	SCRIPT_METHOD_EXT(Object::get_X, GetX);
+	SCRIPT_METHOD_EXT(Object::set_X, SetX);
+	SCRIPT_METHOD_EXT(Object::get_Y, GetY);
+	SCRIPT_METHOD_EXT(Object::set_Y, SetY);
+}
+
+void Object::Animate(ScriptMethodParams &params) {
+	PARAMS6(ScriptObject *, objj, int, loop, int, delay, int, repeat, int, blocking, int, direction);
+	AGS3::Object_Animate(objj, loop, delay, repeat, blocking, direction);
+}
+
+void Object::IsCollidingWithObject(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, ScriptObject *, obj2);
+	params._result = AGS3::Object_IsCollidingWithObject(objj, obj2);
+}
+
+void Object::GetName(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, char *, buffer);
+	AGS3::Object_GetName(objj, buffer);
+}
+
+void Object::GetProperty(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, const char *, property);
+	params._result = AGS3::Object_GetProperty(objj, property);
+}
+
+void Object::GetPropertyText(ScriptMethodParams &params) {
+	PARAMS3(ScriptObject *, objj, const char *, property, char *, buffer);
+	AGS3::Object_GetPropertyText(objj, property, buffer);
+}
+
+void Object::GetTextProperty(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, const char *, property);
+	params._result = AGS3::Object_GetTextProperty(objj, property);
+}
+
+void Object::MergeIntoBackground(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	AGS3::Object_MergeIntoBackground(objj);
+}
+
+void Object::Move(ScriptMethodParams &params) {
+	PARAMS6(ScriptObject *, objj, int, x, int, y, int, speed, int, blocking, int, direct);
+	AGS3::Object_Move(objj, x, y, speed, blocking, direct);
+}
+
+void Object::RemoveTint(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	AGS3::Object_RemoveTint(objj);
+}
+
+void Object::RunInteraction(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, mode);
+	AGS3::Object_RunInteraction(objj, mode);
+}
+
+void Object::SetPosition(ScriptMethodParams &params) {
+	PARAMS3(ScriptObject *, objj, int, xx, int, yy);
+	AGS3::Object_SetPosition(objj, xx, yy);
+}
+
+void Object::SetView(ScriptMethodParams &params) {
+	PARAMS4(ScriptObject *, objj, int, view, int, loop, int, frame);
+	AGS3::Object_SetView(objj, view, loop, frame);
+}
+
+void Object::StopAnimating(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	AGS3::Object_StopAnimating(objj);
+}
+
+void Object::StopMoving(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	AGS3::Object_StopMoving(objj);
+}
+
+void Object::Tint(ScriptMethodParams &params) {
+	PARAMS6(ScriptObject *, objj, int, red, int, green, int, blue, int, saturation, int, luminance);
+	AGS3::Object_Tint(objj, red, green, blue, saturation, luminance);
+}
+
+void Object::GetObjectAtRoom(ScriptMethodParams &params) {
+	PARAMS2(int, x, int, y);
+	params._result = AGS3::GetObjectAtRoom(x, y);
+}
+
+void Object::GetObjectAtScreen(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetObjectAtScreen(xx, yy);
+}
+
+void Object::GetAnimating(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetAnimating(objj);
+}
+
+void Object::GetBaseline(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetBaseline(objj);
+}
+
+void Object::SetBaseline(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, basel);
+	AGS3::Object_SetBaseline(objj, basel);
+}
+
+void Object::GetBlockingHeight(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetBlockingHeight(objj);
+}
+
+void Object::SetBlockingHeight(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, bhit);
+	AGS3::Object_SetBlockingHeight(objj, bhit);
+}
+
+void Object::GetBlockingWidth(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetBlockingWidth(objj);
+}
+
+void Object::SetBlockingWidth(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, bwid);
+	AGS3::Object_SetBlockingWidth(objj, bwid);
+}
+
+void Object::GetClickable(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetClickable(objj);
+}
+
+void Object::SetClickable(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, clik);
+	AGS3::Object_SetClickable(objj, clik);
+}
+
+void Object::GetFrame(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetFrame(objj);
+}
+
+void Object::GetGraphic(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetGraphic(objj);
+}
+
+void Object::SetGraphic(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, slott);
+	AGS3::Object_SetGraphic(objj, slott);
+}
+
+void Object::GetID(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetID(objj);
+}
+
+void Object::GetIgnoreScaling(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetIgnoreScaling(objj);
+}
+
+void Object::SetIgnoreScaling(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, newval);
+	AGS3::Object_SetIgnoreScaling(objj, newval);
+}
+
+void Object::GetIgnoreWalkbehinds(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetIgnoreWalkbehinds(objj);
+}
+
+void Object::SetIgnoreWalkbehinds(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, chaa, int, clik);
+	AGS3::Object_SetIgnoreWalkbehinds(chaa, clik);
+}
+
+void Object::GetLoop(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetLoop(objj);
+}
+
+void Object::GetMoving(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetMoving(objj);
+}
+
+void Object::GetName_New(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetName_New(objj);
+}
+
+void Object::GetSolid(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetSolid(objj);
+}
+
+void Object::SetSolid(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, solid);
+	AGS3::Object_SetSolid(objj, solid);
+}
+
+void Object::GetTransparency(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetTransparency(objj);
+}
+
+void Object::SetTransparency(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, trans);
+	AGS3::Object_SetTransparency(objj, trans);
+}
+
+void Object::GetView(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetView(objj);
+}
+
+void Object::GetVisible(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetVisible(objj);
+}
+
+void Object::SetVisible(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, onOrOff);
+	AGS3::Object_SetVisible(objj, onOrOff);
+}
+
+void Object::GetX(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetX(objj);
+}
+
+void Object::SetX(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, xx);
+	AGS3::Object_SetY(objj, xx);
+}
+
+void Object::GetY(ScriptMethodParams &params) {
+	PARAMS1(ScriptObject *, objj);
+	params._result = AGS3::Object_GetY(objj);
+}
+
+void Object::SetY(ScriptMethodParams &params) {
+	PARAMS2(ScriptObject *, objj, int, yy);
+	AGS3::Object_SetY(objj, yy);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/object.h b/engines/ags/plugins/core/object.h
index 0affc577a3..d40d8dd909 100644
--- a/engines/ags/plugins/core/object.h
+++ b/engines/ags/plugins/core/object.h
@@ -33,7 +33,54 @@ class Object : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void Animate(ScriptMethodParams &params);
+	static void IsCollidingWithObject(ScriptMethodParams &params);
+	static void GetName(ScriptMethodParams &params);
+	static void GetProperty(ScriptMethodParams &params);
+	static void GetPropertyText(ScriptMethodParams &params);
+	static void GetTextProperty(ScriptMethodParams &params);
+	static void MergeIntoBackground(ScriptMethodParams &params);
+	static void Move(ScriptMethodParams &params);
+	static void RemoveTint(ScriptMethodParams &params);
+	static void RunInteraction(ScriptMethodParams &params);
+	static void SetPosition(ScriptMethodParams &params);
+	static void SetView(ScriptMethodParams &params);
+	static void StopAnimating(ScriptMethodParams &params);
+	static void StopMoving(ScriptMethodParams &params);
+	static void Tint(ScriptMethodParams &params);
+	static void GetObjectAtRoom(ScriptMethodParams &params);
+	static void GetObjectAtScreen(ScriptMethodParams &params);
+	static void GetAnimating(ScriptMethodParams &params);
+	static void GetBaseline(ScriptMethodParams &params);
+	static void SetBaseline(ScriptMethodParams &params);
+	static void GetBlockingHeight(ScriptMethodParams &params);
+	static void SetBlockingHeight(ScriptMethodParams &params);
+	static void GetBlockingWidth(ScriptMethodParams &params);
+	static void SetBlockingWidth(ScriptMethodParams &params);
+	static void GetClickable(ScriptMethodParams &params);
+	static void SetClickable(ScriptMethodParams &params);
+	static void GetFrame(ScriptMethodParams &params);
+	static void GetGraphic(ScriptMethodParams &params);
+	static void SetGraphic(ScriptMethodParams &params);
+	static void GetID(ScriptMethodParams &params);
+	static void GetIgnoreScaling(ScriptMethodParams &params);
+	static void SetIgnoreScaling(ScriptMethodParams &params);
+	static void GetIgnoreWalkbehinds(ScriptMethodParams &params);
+	static void SetIgnoreWalkbehinds(ScriptMethodParams &params);
+	static void GetLoop(ScriptMethodParams &params);
+	static void GetMoving(ScriptMethodParams &params);
+	static void GetName_New(ScriptMethodParams &params);
+	static void GetSolid(ScriptMethodParams &params);
+	static void SetSolid(ScriptMethodParams &params);
+	static void GetTransparency(ScriptMethodParams &params);
+	static void SetTransparency(ScriptMethodParams &params);
+	static void GetView(ScriptMethodParams &params);
+	static void GetVisible(ScriptMethodParams &params);
+	static void SetVisible(ScriptMethodParams &params);
+	static void GetX(ScriptMethodParams &params);
+	static void SetX(ScriptMethodParams &params);
+	static void GetY(ScriptMethodParams &params);
+	static void SetY(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/overlay.cpp b/engines/ags/plugins/core/overlay.cpp
index 81ac4aeec8..5880a7181e 100644
--- a/engines/ags/plugins/core/overlay.cpp
+++ b/engines/ags/plugins/core/overlay.cpp
@@ -28,6 +28,61 @@ namespace Plugins {
 namespace Core {
 
 void Overlay::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Overlay::CreateGraphical^4, CreateGraphical);
+	SCRIPT_METHOD_EXT(Overlay::CreateTextual^106, ScPl_CreateTextual);
+	SCRIPT_METHOD_EXT(Overlay::SetText^104, ScPl_SetText);
+	SCRIPT_METHOD_EXT(Overlay::Remove^0, Remove);
+	SCRIPT_METHOD_EXT(Overlay::get_Valid, GetValid);
+	SCRIPT_METHOD_EXT(Overlay::get_X, GetX);
+	SCRIPT_METHOD_EXT(Overlay::set_X, SetX);
+	SCRIPT_METHOD_EXT(Overlay::get_Y, GetY);
+	SCRIPT_METHOD_EXT(Overlay::set_Y, SetY);
+}
+
+void Overlay::CreateGraphical(ScriptMethodParams &params) {
+	PARAMS4(int, x, int, y, int, slot, int, transparent);
+	params._result = AGS3::Overlay_CreateGraphical(x, y, slot, transparent);
+}
+
+void Overlay::ScPl_CreateTextual(ScriptMethodParams &params) {
+	PARAMS6(int, x, int, y, int, width, int, font, int, colour, const char *, text);
+	params._result = AGS3::Overlay_CreateTextual(x, y, width, font, colour, text);
+}
+
+void Overlay::ScPl_SetText(ScriptMethodParams &params) {
+	PARAMS5(int, x, int, y, int, width, int, font, int, colour);
+	Common::String text = params.format(5);
+	params._result = AGS3::Overlay_CreateTextual(x, y, width, font, colour, text.c_str());
+}
+
+void Overlay::Remove(ScriptMethodParams &params) {
+	PARAMS1(ScriptOverlay *, sco);
+	AGS3::Overlay_Remove(sco);
+}
+
+void Overlay::GetValid(ScriptMethodParams &params) {
+	PARAMS1(ScriptOverlay *, sco);
+	params._result = AGS3::Overlay_GetValid(sco);
+}
+
+void Overlay::GetX(ScriptMethodParams &params) {
+	PARAMS1(ScriptOverlay *, sco);
+	params._result = AGS3::Overlay_GetX(sco);
+}
+
+void Overlay::SetX(ScriptMethodParams &params) {
+	PARAMS2(ScriptOverlay *, scover, int, newx);
+	AGS3::Overlay_SetX(scover, newx);
+}
+
+void Overlay::GetY(ScriptMethodParams &params) {
+	PARAMS1(ScriptOverlay *, sco);
+	params._result = AGS3::Overlay_GetY(sco);
+}
+
+void Overlay::SetY(ScriptMethodParams &params) {
+	PARAMS2(ScriptOverlay *, scover, int, newy);
+	AGS3::Overlay_SetY(scover, newy);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/overlay.h b/engines/ags/plugins/core/overlay.h
index 9a75a50d6c..3626c5544f 100644
--- a/engines/ags/plugins/core/overlay.h
+++ b/engines/ags/plugins/core/overlay.h
@@ -33,7 +33,15 @@ class Overlay : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void CreateGraphical(ScriptMethodParams &params);
+	static void ScPl_CreateTextual(ScriptMethodParams &params);
+	static void ScPl_SetText(ScriptMethodParams &params);
+	static void Remove(ScriptMethodParams &params);
+	static void GetValid(ScriptMethodParams &params);
+	static void GetX(ScriptMethodParams &params);
+	static void SetX(ScriptMethodParams &params);
+	static void GetY(ScriptMethodParams &params);
+	static void SetY(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/parser.cpp b/engines/ags/plugins/core/parser.cpp
index d4fab3c343..56887f1172 100644
--- a/engines/ags/plugins/core/parser.cpp
+++ b/engines/ags/plugins/core/parser.cpp
@@ -28,6 +28,29 @@ namespace Plugins {
 namespace Core {
 
 void Parser::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Parser::FindWordID^1, FindWordID);
+	SCRIPT_METHOD_EXT(Parser::ParseText^1, ParseText);
+	SCRIPT_METHOD_EXT(Parser::SaidUnknownWord^0, SaidUnknownWord);
+	SCRIPT_METHOD_EXT(Parser::Said^1, Said);
+}
+
+void Parser::FindWordID(ScriptMethodParams &params) {
+	PARAMS1(const char *, wordToFind);
+	params._result = AGS3::Parser_FindWordID(wordToFind);
+}
+
+void Parser::ParseText(ScriptMethodParams &params) {
+	PARAMS1(const char *, text);
+	AGS3::Parser_FindWordID(text);
+}
+
+void Parser::SaidUnknownWord(ScriptMethodParams &params) {
+	AGS3::Parser_SaidUnknownWord();
+}
+
+void Parser::Said(ScriptMethodParams &params) {
+	PARAMS1(const char *, checkWords);
+	params._result = AGS3::Parser_FindWordID(checkWords);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/parser.h b/engines/ags/plugins/core/parser.h
index f0f593e820..6f248280d8 100644
--- a/engines/ags/plugins/core/parser.h
+++ b/engines/ags/plugins/core/parser.h
@@ -33,7 +33,10 @@ class Parser : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void FindWordID(ScriptMethodParams &params);
+	static void ParseText(ScriptMethodParams &params);
+	static void SaidUnknownWord(ScriptMethodParams &params);
+	static void Said(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/region.cpp b/engines/ags/plugins/core/region.cpp
index 4a25508ebb..3380b5495c 100644
--- a/engines/ags/plugins/core/region.cpp
+++ b/engines/ags/plugins/core/region.cpp
@@ -28,6 +28,90 @@ namespace Plugins {
 namespace Core {
 
 void Region::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Region::GetAtRoomXY^2, GetRegionAtRoom);
+	SCRIPT_METHOD_EXT(Region::GetAtScreenXY^2, GetRegionAtScreen);
+	SCRIPT_METHOD_EXT(Region::Tint^4, TintNoLum);
+	SCRIPT_METHOD_EXT(Region::RunInteraction^1, RunInteraction);
+	SCRIPT_METHOD_EXT(Region::get_Enabled, GetEnabled);
+	SCRIPT_METHOD_EXT(Region::set_Enabled, SetEnabled);
+	SCRIPT_METHOD_EXT(Region::get_ID, GetID);
+	SCRIPT_METHOD_EXT(Region::get_LightLevel, GetLightLevel);
+	SCRIPT_METHOD_EXT(Region::set_LightLevel, SetLightLevel);
+	SCRIPT_METHOD_EXT(Region::get_TintEnabled, GetTintEnabled);
+	SCRIPT_METHOD_EXT(Region::get_TintBlue, GetTintBlue);
+	SCRIPT_METHOD_EXT(Region::get_TintGreen, GetTintGreen);
+	SCRIPT_METHOD_EXT(Region::get_TintRed, GetTintRed);
+	SCRIPT_METHOD_EXT(Region::get_TintSaturation, GetTintSaturation);
+}
+
+void Region::GetRegionAtRoom(ScriptMethodParams &params) {
+	PARAMS2(int, xx, int, yy);
+	params._result = AGS3::GetRegionAtRoom(xx, yy);
+}
+
+void Region::GetRegionAtScreen(ScriptMethodParams &params) {
+	PARAMS2(int, x, int, y);
+	params._result = AGS3::GetRegionAtScreen(x, y);
+}
+
+void Region::TintNoLum(ScriptMethodParams &params) {
+	PARAMS5(ScriptRegion *, srr, int, red, int, green, int, blue, int, amount);
+	AGS3::Region_TintNoLum(srr, red, green, blue, amount);
+}
+
+void Region::RunInteraction(ScriptMethodParams &params) {
+	PARAMS2(ScriptRegion *, ssr, int, mood);
+	AGS3::Region_RunInteraction(ssr, mood);
+}
+
+void Region::GetEnabled(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetEnabled(ssr);
+}
+
+void Region::SetEnabled(ScriptMethodParams &params) {
+	PARAMS2(ScriptRegion *, ssr, int, enable);
+	AGS3::Region_SetEnabled(ssr, enable);
+}
+
+void Region::GetID(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetID(ssr);
+}
+
+void Region::GetLightLevel(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetLightLevel(ssr);
+}
+
+void Region::SetLightLevel(ScriptMethodParams &params) {
+	PARAMS2(ScriptRegion *, ssr, int, brightness);
+	AGS3::Region_SetLightLevel(ssr, brightness);
+}
+
+void Region::GetTintEnabled(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetTintEnabled(ssr);
+}
+
+void Region::GetTintBlue(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetTintBlue(ssr);
+}
+
+void Region::GetTintGreen(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetTintGreen(ssr);
+}
+
+void Region::GetTintRed(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetTintRed(ssr);
+}
+
+void Region::GetTintSaturation(ScriptMethodParams &params) {
+	PARAMS1(ScriptRegion *, ssr);
+	params._result = AGS3::Region_GetTintSaturation(ssr);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/region.h b/engines/ags/plugins/core/region.h
index af95509b9c..b92fdf6736 100644
--- a/engines/ags/plugins/core/region.h
+++ b/engines/ags/plugins/core/region.h
@@ -33,7 +33,20 @@ class Region : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetRegionAtRoom(ScriptMethodParams &params);
+	static void GetRegionAtScreen(ScriptMethodParams &params);
+	static void TintNoLum(ScriptMethodParams &params);
+	static void RunInteraction(ScriptMethodParams &params);
+	static void GetEnabled(ScriptMethodParams &params);
+	static void SetEnabled(ScriptMethodParams &params);
+	static void GetID(ScriptMethodParams &params);
+	static void GetLightLevel(ScriptMethodParams &params);
+	static void SetLightLevel(ScriptMethodParams &params);
+	static void GetTintEnabled(ScriptMethodParams &params);
+	static void GetTintBlue(ScriptMethodParams &params);
+	static void GetTintGreen(ScriptMethodParams &params);
+	static void GetTintRed(ScriptMethodParams &params);
+	static void GetTintSaturation(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/room.cpp b/engines/ags/plugins/core/room.cpp
index c07a262a83..50d110e035 100644
--- a/engines/ags/plugins/core/room.cpp
+++ b/engines/ags/plugins/core/room.cpp
@@ -28,6 +28,75 @@ namespace Plugins {
 namespace Core {
 
 void Room::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Room::GetDrawingSurfaceForBackground^1, GetDrawingSurfaceForBackground);
+	SCRIPT_METHOD_EXT(Room::GetProperty^1, GetProperty);
+	SCRIPT_METHOD_EXT(Room::GetTextProperty^1, GetTextProperty);
+	SCRIPT_METHOD_EXT(Room::get_BottomEdge, GetBottomEdge);
+	SCRIPT_METHOD_EXT(Room::get_ColorDepth, GetColorDepth);
+	SCRIPT_METHOD_EXT(Room::get_Height, GetHeight);
+	SCRIPT_METHOD_EXT(Room::get_LeftEdge, GetLeftEdge);
+	SCRIPT_METHOD_EXT(Room::geti_Messages, GetMessages);
+	SCRIPT_METHOD_EXT(Room::get_MusicOnLoad, GetMusicOnLoad);
+	SCRIPT_METHOD_EXT(Room::get_ObjectCount, GetObjectCount);
+	SCRIPT_METHOD_EXT(Room::get_RightEdge, GetRightEdge);
+	SCRIPT_METHOD_EXT(Room::get_TopEdge, GetTopEdge);
+	SCRIPT_METHOD_EXT(Room::get_Width, GetWidth);
+}
+
+void Room::GetDrawingSurfaceForBackground(ScriptMethodParams &params) {
+	PARAMS1(int, backgroundNumber);
+	params._result = AGS3::Room_GetDrawingSurfaceForBackground(backgroundNumber);
+}
+
+void Room::GetProperty(ScriptMethodParams &params) {
+	PARAMS1(const char *, property);
+	params._result = AGS3::Room_GetProperty(property);
+}
+
+void Room::GetTextProperty(ScriptMethodParams &params) {
+	PARAMS1(const char *, property);
+	params._result = AGS3::Room_GetTextProperty(property);
+}
+
+void Room::GetBottomEdge(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetBottomEdge();
+}
+
+void Room::GetColorDepth(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetColorDepth();
+}
+
+void Room::GetHeight(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetHeight();
+}
+
+void Room::GetLeftEdge(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetLeftEdge();
+}
+
+void Room::GetMessages(ScriptMethodParams &params) {
+	PARAMS1(int, index);
+	params._result = AGS3::Room_GetMessages(index);
+}
+
+void Room::GetMusicOnLoad(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetMusicOnLoad();
+}
+
+void Room::GetObjectCount(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetObjectCount();
+}
+
+void Room::GetRightEdge(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetRightEdge();
+}
+
+void Room::GetTopEdge(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetTopEdge();
+}
+
+void Room::GetWidth(ScriptMethodParams &params) {
+	params._result = AGS3::Room_GetWidth();
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/room.h b/engines/ags/plugins/core/room.h
index 0487da9c8d..a3d7a32ece 100644
--- a/engines/ags/plugins/core/room.h
+++ b/engines/ags/plugins/core/room.h
@@ -33,7 +33,19 @@ class Room : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetDrawingSurfaceForBackground(ScriptMethodParams &params);
+	static void GetProperty(ScriptMethodParams &params);
+	static void GetTextProperty(ScriptMethodParams &params);
+	static void GetBottomEdge(ScriptMethodParams &params);
+	static void GetColorDepth(ScriptMethodParams &params);
+	static void GetHeight(ScriptMethodParams &params);
+	static void GetLeftEdge(ScriptMethodParams &params);
+	static void GetMessages(ScriptMethodParams &params);
+	static void GetMusicOnLoad(ScriptMethodParams &params);
+	static void GetObjectCount(ScriptMethodParams &params);
+	static void GetRightEdge(ScriptMethodParams &params);
+	static void GetTopEdge(ScriptMethodParams &params);
+	static void GetWidth(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/slider.cpp b/engines/ags/plugins/core/slider.cpp
index 527c24431e..53d2531931 100644
--- a/engines/ags/plugins/core/slider.cpp
+++ b/engines/ags/plugins/core/slider.cpp
@@ -28,6 +28,78 @@ namespace Plugins {
 namespace Core {
 
 void Slider::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(Slider::get_BackgroundGraphic, GetBackgroundGraphic);
+	SCRIPT_METHOD_EXT(Slider::set_BackgroundGraphic, SetBackgroundGraphic);
+	SCRIPT_METHOD_EXT(Slider::get_HandleGraphic, GetHandleGraphic);
+	SCRIPT_METHOD_EXT(Slider::set_HandleGraphic, SetHandleGraphic);
+	SCRIPT_METHOD_EXT(Slider::get_HandleOffset, GetHandleOffset);
+	SCRIPT_METHOD_EXT(Slider::set_HandleOffset, SetHandleOffset);
+	SCRIPT_METHOD_EXT(Slider::get_Max, GetMax);
+	SCRIPT_METHOD_EXT(Slider::set_Max, SetMax);
+	SCRIPT_METHOD_EXT(Slider::get_Min, GetMin);
+	SCRIPT_METHOD_EXT(Slider::set_Min, SetMin);
+	SCRIPT_METHOD_EXT(Slider::get_Value, GetValue);
+	SCRIPT_METHOD_EXT(Slider::set_Value, SetValue);
+}
+
+void Slider::GetBackgroundGraphic(ScriptMethodParams &params) {
+	PARAMS1(GUISlider *, guisl);
+	params._result = AGS3::Slider_GetBackgroundGraphic(guisl);
+}
+
+void Slider::SetBackgroundGraphic(ScriptMethodParams &params) {
+	PARAMS2(GUISlider *, guisl, int, newImage);
+	AGS3::Slider_SetBackgroundGraphic(guisl, newImage);
+}
+
+void Slider::GetHandleGraphic(ScriptMethodParams &params) {
+	PARAMS1(GUISlider *, guisl);
+	params._result = AGS3::Slider_GetHandleGraphic(guisl);
+}
+
+void Slider::SetHandleGraphic(ScriptMethodParams &params) {
+	PARAMS2(GUISlider *, guisl, int, newImage);
+	AGS3::Slider_SetHandleGraphic(guisl, newImage);
+}
+
+void Slider::GetHandleOffset(ScriptMethodParams &params) {
+	PARAMS1(GUISlider *, guisl);
+	params._result = AGS3::Slider_GetHandleOffset(guisl);
+}
+
+void Slider::SetHandleOffset(ScriptMethodParams &params) {
+	PARAMS2(GUISlider *, guisl, int, newOffset);
+	AGS3::Slider_SetHandleOffset(guisl, newOffset);
+}
+
+void Slider::GetMax(ScriptMethodParams &params) {
+	PARAMS1(GUISlider *, guisl);
+	params._result = AGS3::Slider_GetMax(guisl);
+}
+
+void Slider::SetMax(ScriptMethodParams &params) {
+	PARAMS2(GUISlider *, guisl, int, valn);
+	AGS3::Slider_SetMax(guisl, valn);
+}
+
+void Slider::GetMin(ScriptMethodParams &params) {
+	PARAMS1(GUISlider *, guisl);
+	params._result = AGS3::Slider_GetMin(guisl);
+}
+
+void Slider::SetMin(ScriptMethodParams &params) {
+	PARAMS2(GUISlider *, guisl, int, valn);
+	AGS3::Slider_SetMin(guisl, valn);
+}
+
+void Slider::GetValue(ScriptMethodParams &params) {
+	PARAMS1(GUISlider *, guisl);
+	params._result = AGS3::Slider_GetValue(guisl);
+}
+
+void Slider::SetValue(ScriptMethodParams &params) {
+	PARAMS2(GUISlider *, guisl, int, valn);
+	AGS3::Slider_SetValue(guisl, valn);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/slider.h b/engines/ags/plugins/core/slider.h
index 9f4f66c7bd..2ec35089ce 100644
--- a/engines/ags/plugins/core/slider.h
+++ b/engines/ags/plugins/core/slider.h
@@ -33,7 +33,18 @@ class Slider : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetBackgroundGraphic(ScriptMethodParams &params);
+	static void SetBackgroundGraphic(ScriptMethodParams &params);
+	static void GetHandleGraphic(ScriptMethodParams &params);
+	static void SetHandleGraphic(ScriptMethodParams &params);
+	static void GetHandleOffset(ScriptMethodParams &params);
+	static void SetHandleOffset(ScriptMethodParams &params);
+	static void GetMax(ScriptMethodParams &params);
+	static void SetMax(ScriptMethodParams &params);
+	static void GetMin(ScriptMethodParams &params);
+	static void SetMin(ScriptMethodParams &params);
+	static void GetValue(ScriptMethodParams &params);
+	static void SetValue(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/string.cpp b/engines/ags/plugins/core/string.cpp
index ffd2fda3b3..de7050c7e3 100644
--- a/engines/ags/plugins/core/string.cpp
+++ b/engines/ags/plugins/core/string.cpp
@@ -22,12 +22,128 @@
 
 #include "ags/plugins/core/string.h"
 #include "ags/engine/ac/string.h"
+#include "ags/engine/ac/math.h"
 
 namespace AGS3 {
 namespace Plugins {
 namespace Core {
 
 void String::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(String::IsNullOrEmpty^1, IsNullOrEmpty);
+	SCRIPT_METHOD_EXT(String::Append^1, Append);
+	SCRIPT_METHOD_EXT(String::AppendChar^1, AppendChar);
+	SCRIPT_METHOD_EXT(String::CompareTo^2, CompareTo);
+	SCRIPT_METHOD_EXT(String::Contains^1, StrContains);
+	SCRIPT_METHOD_EXT(String::Copy^0, Copy);
+	SCRIPT_METHOD_EXT(String::EndsWith^2, EndsWith);
+	SCRIPT_METHOD_EXT(String::Format^101, ScPl_String_Format);
+	SCRIPT_METHOD_EXT(String::IndexOf^1, StrContains);
+	SCRIPT_METHOD_EXT(String::LowerCase^0, LowerCase);
+	SCRIPT_METHOD_EXT(String::Replace^3, Replace);
+	SCRIPT_METHOD_EXT(String::ReplaceCharAt^2, ReplaceCharAt);
+	SCRIPT_METHOD_EXT(String::StartsWith^2, StartsWith);
+	SCRIPT_METHOD_EXT(String::Substring^2, Substring);
+	SCRIPT_METHOD_EXT(String::Truncate^1, Truncate);
+	SCRIPT_METHOD_EXT(String::UpperCase^0, UpperCase);
+	SCRIPT_METHOD_EXT(String::get_AsFloat, StringToFloat);
+	SCRIPT_METHOD_EXT(String::get_AsInt, StringToInt);
+	SCRIPT_METHOD_EXT(String::geti_Chars, GetChars);
+	SCRIPT_METHOD_EXT(String::get_Length, strlen);
+}
+
+void String::IsNullOrEmpty(ScriptMethodParams &params) {
+	PARAMS1(const char *, str);
+	params._result = AGS3::String_IsNullOrEmpty(str);
+}
+
+void String::Append(ScriptMethodParams &params) {
+	PARAMS2(const char *, str, const char *, extrabit);
+	params._result = AGS3::String_Append(str, extrabit);
+}
+
+void String::AppendChar(ScriptMethodParams &params) {
+	PARAMS2(const char *, str, char, extraOne);
+	params._result = AGS3::String_AppendChar(str, extraOne);
+}
+
+void String::CompareTo(ScriptMethodParams &params) {
+	PARAMS3(const char *, str1, const char *, str2, bool, caseSensitive);
+	params._result = AGS3::String_CompareTo(str1, str2, caseSensitive);
+}
+
+void String::StrContains(ScriptMethodParams &params) {
+	PARAMS2(const char *, s1, const char *, s2);
+	params._result = AGS3::StrContains(s1, s2);
+}
+
+void String::Copy(ScriptMethodParams &params) {
+	PARAMS1(const char *, str);
+	params._result = AGS3::String_Copy(str);
+}
+
+void String::EndsWith(ScriptMethodParams &params) {
+	PARAMS3(const char *, s1, const char *, s2, bool, caseSensitive);
+	params._result = AGS3::String_EndsWith(s1, s2, caseSensitive);
+}
+
+void String::ScPl_String_Format(ScriptMethodParams &params) {
+	Common::String text = params.format(0);
+	params._result = AGS3::CreateNewScriptString(text.c_str());
+}
+
+void String::LowerCase(ScriptMethodParams &params) {
+	PARAMS1(const char *, str);
+	params._result = AGS3::String_LowerCase(str);
+}
+
+void String::Replace(ScriptMethodParams &params) {
+	PARAMS4(const char *, thisString, const char *, lookForText, const char *, replaceWithText, bool, caseSensitive);
+	params._result = AGS3::String_Replace(thisString, lookForText, replaceWithText, caseSensitive);
+}
+
+void String::ReplaceCharAt(ScriptMethodParams &params) {
+	PARAMS3(const char *, thisString, int, index, char, newChar);
+	params._result = AGS3::String_ReplaceCharAt(thisString, index, newChar);
+}
+
+void String::StartsWith(ScriptMethodParams &params) {
+	PARAMS3(const char *, thisString, const char *, checkForString, bool, caseSensitive);
+	params._result = AGS3::String_StartsWith(thisString, checkForString, caseSensitive);
+}
+
+void String::Substring(ScriptMethodParams &params) {
+	PARAMS3(const char *, thisString, int, index, int, length);
+	params._result = AGS3::String_Substring(thisString, index, length);
+}
+
+void String::Truncate(ScriptMethodParams &params) {
+	PARAMS2(const char *, thisString, int, length);
+	params._result = AGS3::String_Truncate(thisString, length);
+}
+
+void String::UpperCase(ScriptMethodParams &params) {
+	PARAMS1(const char *, str);
+	params._result = AGS3::String_UpperCase(str);
+}
+
+void String::StringToFloat(ScriptMethodParams &params) {
+	PARAMS1(const char *, value);
+	params._result = AGS3::StringToFloat(value);
+}
+
+void String::StringToInt(ScriptMethodParams &params) {
+	PARAMS1(const char *, value);
+	params._result = AGS3::StringToInt(value);
+}
+
+void String::GetChars(ScriptMethodParams &params) {
+	PARAMS2(const char *, texx, int, index);
+	params._result = AGS3::String_GetChars(texx, index);
+}
+
+void String::strlen(ScriptMethodParams &params) {
+	PARAMS1(const char *, s);
+	params._result = ::strlen(s);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/string.h b/engines/ags/plugins/core/string.h
index 1ed32b9e2c..4951a2933a 100644
--- a/engines/ags/plugins/core/string.h
+++ b/engines/ags/plugins/core/string.h
@@ -33,7 +33,25 @@ class String : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void IsNullOrEmpty(ScriptMethodParams &params);
+	static void Append(ScriptMethodParams &params);
+	static void AppendChar(ScriptMethodParams &params);
+	static void CompareTo(ScriptMethodParams &params);
+	static void StrContains(ScriptMethodParams &params);
+	static void Copy(ScriptMethodParams &params);
+	static void EndsWith(ScriptMethodParams &params);
+	static void ScPl_String_Format(ScriptMethodParams &params);
+	static void LowerCase(ScriptMethodParams &params);
+	static void Replace(ScriptMethodParams &params);
+	static void ReplaceCharAt(ScriptMethodParams &params);
+	static void StartsWith(ScriptMethodParams &params);
+	static void Substring(ScriptMethodParams &params);
+	static void Truncate(ScriptMethodParams &params);
+	static void UpperCase(ScriptMethodParams &params);
+	static void StringToFloat(ScriptMethodParams &params);
+	static void StringToInt(ScriptMethodParams &params);
+	static void GetChars(ScriptMethodParams &params);
+	static void strlen(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/system.cpp b/engines/ags/plugins/core/system.cpp
index 3136cee8dc..f32d6c371a 100644
--- a/engines/ags/plugins/core/system.cpp
+++ b/engines/ags/plugins/core/system.cpp
@@ -28,6 +28,121 @@ namespace Plugins {
 namespace Core {
 
 void System::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(System::get_AudioChannelCount, GetAudioChannelCount);
+	SCRIPT_METHOD_EXT(System::geti_AudioChannels, GetAudioChannels);
+	SCRIPT_METHOD_EXT(System::get_CapsLock, GetCapsLock);
+	SCRIPT_METHOD_EXT(System::get_ColorDepth, GetColorDepth);
+	SCRIPT_METHOD_EXT(System::get_Gamma, GetGamma);
+	SCRIPT_METHOD_EXT(System::set_Gamma, SetGamma);
+	SCRIPT_METHOD_EXT(System::get_HardwareAcceleration, GetHardwareAcceleration);
+	SCRIPT_METHOD_EXT(System::get_NumLock, GetNumLock);
+	SCRIPT_METHOD_EXT(System::get_OperatingSystem, GetOS);
+	SCRIPT_METHOD_EXT(System::get_RuntimeInfo, GetRuntimeInfo);
+	SCRIPT_METHOD_EXT(System::get_ScreenHeight, GetScreenHeight);
+	SCRIPT_METHOD_EXT(System::get_ScreenWidth, GetScreenWidth);
+	SCRIPT_METHOD_EXT(System::get_ScrollLock, GetScrollLock);
+	SCRIPT_METHOD_EXT(System::get_SupportsGammaControl, GetSupportsGammaControl);
+	SCRIPT_METHOD_EXT(System::get_Version, GetVersion);
+	SCRIPT_METHOD_EXT(SystemInfo::get_Version, GetVersion);
+	SCRIPT_METHOD_EXT(System::get_ViewportHeight, GetViewportHeight);
+	SCRIPT_METHOD_EXT(System::get_ViewportWidth, GetViewportWidth);
+	SCRIPT_METHOD_EXT(System::get_Volume, GetVolume);
+	SCRIPT_METHOD_EXT(System::set_Volume, SetVolume);
+	SCRIPT_METHOD_EXT(System::get_VSync, GetVsync);
+	SCRIPT_METHOD_EXT(System::set_VSync, SetVsync);
+	SCRIPT_METHOD_EXT(System::get_Windowed, GetWindowed);
+}
+
+void System::GetAudioChannelCount(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetAudioChannelCount();
+}
+
+void System::GetAudioChannels(ScriptMethodParams &params) {
+	PARAMS1(int, index);
+	params._result = AGS3::System_GetAudioChannels(index);
+}
+
+void System::GetCapsLock(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetCapsLock();
+}
+
+void System::GetColorDepth(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetColorDepth();
+}
+
+void System::GetGamma(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetGamma();
+}
+
+void System::SetGamma(ScriptMethodParams &params) {
+	PARAMS1(int, newValue);
+	AGS3::System_SetGamma(newValue);
+}
+
+void System::GetHardwareAcceleration(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetHardwareAcceleration();
+}
+
+void System::GetNumLock(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetNumLock();
+}
+
+void System::GetOS(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetOS();
+}
+
+void System::GetRuntimeInfo(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetRuntimeInfo();
+}
+
+void System::GetScreenHeight(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetScreenHeight();
+}
+
+void System::GetScreenWidth(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetScreenWidth();
+}
+
+void System::GetScrollLock(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetScrollLock();
+}
+
+void System::GetSupportsGammaControl(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetSupportsGammaControl();
+}
+
+void System::GetVersion(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetVersion();
+}
+
+void System::GetViewportHeight(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetViewportHeight();
+}
+
+void System::GetViewportWidth(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetViewportWidth();
+}
+
+void System::GetVolume(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetVolume();
+}
+
+void System::SetVolume(ScriptMethodParams &params) {
+	PARAMS1(int, newvol);
+	AGS3::System_SetVolume(newvol);
+}
+
+void System::GetVsync(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetVsync();
+}
+
+void System::SetVsync(ScriptMethodParams &params) {
+	PARAMS1(int, newValue);
+	AGS3::System_SetVsync(newValue);
+}
+
+void System::GetWindowed(ScriptMethodParams &params) {
+	params._result = AGS3::System_GetWindowed();
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/system.h b/engines/ags/plugins/core/system.h
index 3c18593eef..51b1293116 100644
--- a/engines/ags/plugins/core/system.h
+++ b/engines/ags/plugins/core/system.h
@@ -33,7 +33,28 @@ class System : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetAudioChannelCount(ScriptMethodParams &params);
+	static void GetAudioChannels(ScriptMethodParams &params);
+	static void GetCapsLock(ScriptMethodParams &params);
+	static void GetColorDepth(ScriptMethodParams &params);
+	static void GetGamma(ScriptMethodParams &params);
+	static void SetGamma(ScriptMethodParams &params);
+	static void GetHardwareAcceleration(ScriptMethodParams &params);
+	static void GetNumLock(ScriptMethodParams &params);
+	static void GetOS(ScriptMethodParams &params);
+	static void GetRuntimeInfo(ScriptMethodParams &params);
+	static void GetScreenHeight(ScriptMethodParams &params);
+	static void GetScreenWidth(ScriptMethodParams &params);
+	static void GetScrollLock(ScriptMethodParams &params);
+	static void GetSupportsGammaControl(ScriptMethodParams &params);
+	static void GetVersion(ScriptMethodParams &params);
+	static void GetViewportHeight(ScriptMethodParams &params);
+	static void GetViewportWidth(ScriptMethodParams &params);
+	static void GetVolume(ScriptMethodParams &params);
+	static void SetVolume(ScriptMethodParams &params);
+	static void GetVsync(ScriptMethodParams &params);
+	static void SetVsync(ScriptMethodParams &params);
+	static void GetWindowed(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/textbox.cpp b/engines/ags/plugins/core/textbox.cpp
index c8de4f7774..7b96d737fe 100644
--- a/engines/ags/plugins/core/textbox.cpp
+++ b/engines/ags/plugins/core/textbox.cpp
@@ -28,6 +28,49 @@ namespace Plugins {
 namespace Core {
 
 void Textbox::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(TextBox::GetText^1, GetText);
+	SCRIPT_METHOD_EXT(TextBox::SetText^1, SetText);
+	SCRIPT_METHOD_EXT(TextBox::get_Font, GetFont);
+	SCRIPT_METHOD_EXT(TextBox::set_Font, SetFont);
+	SCRIPT_METHOD_EXT(TextBox::get_Text, GetText_New);
+	SCRIPT_METHOD_EXT(TextBox::set_Text, SetText);
+	SCRIPT_METHOD_EXT(TextBox::get_TextColor, GetTextColor);
+	SCRIPT_METHOD_EXT(TextBox::set_TextColor, SetTextColor);
+}
+
+void Textbox::GetText(ScriptMethodParams &params) {
+	PARAMS2(GUITextBox *, texbox, char *, buffer);
+	AGS3::TextBox_GetText(texbox, buffer);
+}
+
+void Textbox::SetText(ScriptMethodParams &params) {
+	PARAMS2(GUITextBox *, texbox, const char *, newtex);
+	AGS3::TextBox_SetText(texbox, newtex);
+}
+
+void Textbox::GetText_New(ScriptMethodParams &params) {
+	PARAMS1(GUITextBox *, texbox);
+	params._result = AGS3::TextBox_GetText_New(texbox);
+}
+
+void Textbox::GetFont(ScriptMethodParams &params) {
+	PARAMS1(GUITextBox *, texbox);
+	params._result = AGS3::TextBox_GetFont(texbox);
+}
+
+void Textbox::SetFont(ScriptMethodParams &params) {
+	PARAMS2(GUITextBox *, guit, int, fontnum);
+	AGS3::TextBox_SetFont(guit, fontnum);
+}
+
+void Textbox::GetTextColor(ScriptMethodParams &params) {
+	PARAMS1(GUITextBox *, texbox);
+	params._result = AGS3::TextBox_GetTextColor(texbox);
+}
+
+void Textbox::SetTextColor(ScriptMethodParams &params) {
+	PARAMS2(GUITextBox *, guit, int, colr);
+	AGS3::TextBox_SetTextColor(guit, colr);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/textbox.h b/engines/ags/plugins/core/textbox.h
index 093e67c1c2..d14d20a470 100644
--- a/engines/ags/plugins/core/textbox.h
+++ b/engines/ags/plugins/core/textbox.h
@@ -33,7 +33,13 @@ class Textbox : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetText(ScriptMethodParams &params);
+	static void SetText(ScriptMethodParams &params);
+	static void GetText_New(ScriptMethodParams &params);
+	static void GetFont(ScriptMethodParams &params);
+	static void SetFont(ScriptMethodParams &params);
+	static void GetTextColor(ScriptMethodParams &params);
+	static void SetTextColor(ScriptMethodParams &params);
 };
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/view_frame.cpp b/engines/ags/plugins/core/view_frame.cpp
index 6d043d3250..8aadd3c538 100644
--- a/engines/ags/plugins/core/view_frame.cpp
+++ b/engines/ags/plugins/core/view_frame.cpp
@@ -28,6 +28,72 @@ namespace Plugins {
 namespace Core {
 
 void ViewFrame::AGS_EngineStartup(IAGSEngine *engine) {
+	SCRIPT_METHOD_EXT(ViewFrame::get_Flipped, GetFlipped);
+	SCRIPT_METHOD_EXT(ViewFrame::get_Frame, GetFrame);
+	SCRIPT_METHOD_EXT(ViewFrame::get_Graphic, GetGraphic);
+	SCRIPT_METHOD_EXT(ViewFrame::set_Graphic, SetGraphic);
+	SCRIPT_METHOD_EXT(ViewFrame::get_LinkedAudio, GetLinkedAudio);
+	SCRIPT_METHOD_EXT(ViewFrame::set_LinkedAudio, SetLinkedAudio);
+	SCRIPT_METHOD_EXT(ViewFrame::get_Loop, GetLoop);
+	SCRIPT_METHOD_EXT(ViewFrame::get_Sound, GetSound);
+	SCRIPT_METHOD_EXT(ViewFrame::set_Sound, SetSound);
+	SCRIPT_METHOD_EXT(ViewFrame::get_Speed, GetSpeed);
+	SCRIPT_METHOD_EXT(ViewFrame::get_View, GetView);
+}
+
+void ViewFrame::GetFlipped(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetFlipped(svf);
+}
+
+void ViewFrame::GetFrame(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetFrame(svf);
+}
+
+void ViewFrame::GetGraphic(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetGraphic(svf);
+}
+
+void ViewFrame::SetGraphic(ScriptMethodParams &params) {
+	PARAMS2(ScriptViewFrame *, svf, int, newPic);
+	AGS3::ViewFrame_SetGraphic(svf, newPic);
+}
+
+void ViewFrame::GetLinkedAudio(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetLinkedAudio(svf);
+}
+
+void ViewFrame::SetLinkedAudio(ScriptMethodParams &params) {
+	PARAMS2(ScriptViewFrame *, svf, ScriptAudioClip *, clip);
+	AGS3::ViewFrame_SetLinkedAudio(svf, clip);
+}
+
+void ViewFrame::GetLoop(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetLoop(svf);
+}
+
+void ViewFrame::GetSound(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetSound(svf);
+}
+
+void ViewFrame::SetSound(ScriptMethodParams &params) {
+	PARAMS2(ScriptViewFrame *, svf, int, newSound);
+	AGS3::ViewFrame_SetSound(svf, newSound);
+}
+
+void ViewFrame::GetSpeed(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetSpeed(svf);
+}
+
+void ViewFrame::GetView(ScriptMethodParams &params) {
+	PARAMS1(ScriptViewFrame *, svf);
+	params._result = AGS3::ViewFrame_GetView(svf);
 }
 
 } // namespace Core
diff --git a/engines/ags/plugins/core/view_frame.h b/engines/ags/plugins/core/view_frame.h
index 99fe44876a..ea315d0dcf 100644
--- a/engines/ags/plugins/core/view_frame.h
+++ b/engines/ags/plugins/core/view_frame.h
@@ -33,7 +33,17 @@ class ViewFrame : public ScriptContainer {
 public:
 	void AGS_EngineStartup(IAGSEngine *engine);
 
-//	static void Now(ScriptMethodParams &params);
+	static void GetFlipped(ScriptMethodParams &params);
+	static void GetFrame(ScriptMethodParams &params);
+	static void GetGraphic(ScriptMethodParams &params);
+	static void SetGraphic(ScriptMethodParams &params);
+	static void GetLinkedAudio(ScriptMethodParams &params);
+	static void SetLinkedAudio(ScriptMethodParams &params);
+	static void GetLoop(ScriptMethodParams &params);
+	static void GetSound(ScriptMethodParams &params);
+	static void SetSound(ScriptMethodParams &params);
+	static void GetSpeed(ScriptMethodParams &params);
+	static void GetView(ScriptMethodParams &params);
 };
 
 } // namespace Core