diff --git a/doomsday/api/doomsday.h b/doomsday/api/doomsday.h
index 4a726c7008..f6c17bd492 100644
--- a/doomsday/api/doomsday.h
+++ b/doomsday/api/doomsday.h
@@ -69,6 +69,7 @@
 #include "api_server.h"
 #include "api_sound.h"
 #include "api_svg.h"
+#include "api_uri.h"
 
 #include <de/memoryzone.h>
 #include <de/point.h>
diff --git a/doomsday/plugins/common/common.pri b/doomsday/plugins/common/common.pri
index a6f8a87e98..0c10981712 100644
--- a/doomsday/plugins/common/common.pri
+++ b/doomsday/plugins/common/common.pri
@@ -9,6 +9,9 @@ INCLUDEPATH += \
     $$DENG_LZSS_DIR/portable/include
 
 HEADERS += \
+    $$common_inc/acs/interpreter.h \
+    $$common_inc/acs/script.h \
+    $$common_inc/acs/system.h \
     $$common_inc/am_map.h \
     $$common_inc/animdefs.h \
     $$common_inc/common.h \
@@ -93,6 +96,9 @@ HEADERS += \
     $$common_inc/menu/widgets/widget.h
 
 SOURCES += \
+    $$common_src/acs/interpreter.cpp \
+    $$common_src/acs/script.cpp \
+    $$common_src/acs/system.cpp \
     $$common_src/am_map.c \
     $$common_src/animdefs.cpp \
     $$common_src/common.c \
@@ -132,7 +138,7 @@ SOURCES += \
     $$common_src/p_iterlist.c \
     $$common_src/p_map.cpp \
     $$common_src/p_mapsetup.cpp \
-    $$common_src/p_mapspec.c \
+    $$common_src/p_mapspec.cpp \
     $$common_src/p_plat.cpp \
     $$common_src/p_saveg.cpp \
     $$common_src/p_saveio.cpp \
diff --git a/doomsday/plugins/common/include/acs/interpreter.h b/doomsday/plugins/common/include/acs/interpreter.h
new file mode 100644
index 0000000000..76e71edefd
--- /dev/null
+++ b/doomsday/plugins/common/include/acs/interpreter.h
@@ -0,0 +1,112 @@
+/** @file interpreter.h  Action Code Script (ACS) interpreter.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#ifndef LIBCOMMON_ACS_INTERPRETER_H
+#define LIBCOMMON_ACS_INTERPRETER_H
+
+#if __cplusplus
+#  include "acs/script.h"
+#  include "mapstatereader.h"
+#  include "mapstatewriter.h"
+#endif
+
+#define ACS_INTERPRETER_MAX_SCRIPT_ARGS     10
+#define ACS_INTERPRETER_SCRIPT_STACK_DEPTH  32
+
+#ifdef __cplusplus
+
+namespace acs {
+
+class System;
+
+/**
+ * Action Code Script (ACS) interpreter (thinker).
+ *
+ * @ingroup playsim
+ */
+struct Interpreter
+{
+    thinker_t thinker;
+    struct mobj_s *activator;
+    Line *line;
+    int side;
+    void *_script;
+    int delayCount;
+    struct Stack { // Local value stack.
+        int values[ACS_INTERPRETER_SCRIPT_STACK_DEPTH];
+        int height;
+
+        void push(int value);
+        int pop();
+        int top() const;
+        void drop();
+    } locals;
+    int args[ACS_INTERPRETER_MAX_SCRIPT_ARGS];
+    int const *pcodePtr;
+
+    acs::System &scriptSys() const;
+
+    /**
+     * Returns the Script data for the thinker.
+     */
+    acs::Script &script() const;
+
+    void think();
+
+    /**
+     * Deserialize the thinker from the currently open save file.
+     */
+    int read(MapStateReader *msr);
+
+    /**
+     * Serialize the thinker to the currently open save file.
+     */
+    void write(MapStateWriter *msw) const;
+
+    /**
+     * @param script      Logical ACS script-state instance.
+     * @param scriptArgs  Args passed to the script.
+     * @param delayCount  Delay in tics to wait before interpretation begins.
+     */
+    static thinker_s *newThinker(acs::Script &script, acs::Script::Args const &scriptArgs,
+                                 struct mobj_s *activator = nullptr, Line *line = nullptr,
+                                 int side = 0, int delayCount = 0);
+};
+
+}  // namespace acs
+#endif  // __cplusplus
+
+// C wrapper API ---------------------------------------------------------------
+
+// Opaque type for interpreter instances.
+struct acs_Interpreter;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void acs_Interpreter_Think(acs_Interpreter *interp);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // LIBCOMMON_ACS_INTERPRETER_H
diff --git a/doomsday/plugins/common/include/acs/script.h b/doomsday/plugins/common/include/acs/script.h
new file mode 100644
index 0000000000..a99a5fc776
--- /dev/null
+++ b/doomsday/plugins/common/include/acs/script.h
@@ -0,0 +1,174 @@
+/** @file script.h  Action Code Script (ACS), script model.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#ifndef LIBCOMMON_ACS_SCRIPT_H
+#define LIBCOMMON_ACS_SCRIPT_H
+
+#include "common.h"
+#include <array>
+#include <de/reader.h>
+#include <de/writer.h>
+#include <de/String>
+
+namespace acs {
+
+class System;
+
+/**
+ * Models the high-level state of an Action Code Script (ACS).
+ *
+ * @ingroup playsim
+ */
+class Script
+{
+public:
+    /**
+     * Stores information about an ACS byte/p-code entry point.
+     */
+    struct EntryPoint
+    {
+        int const *pcodePtr     = nullptr;
+        bool startWhenMapBegins = false;
+        int scriptNumber        = 0;
+        int scriptArgCount      = 0;
+    };
+
+    /**
+     * Script arguments.
+     */
+    class Args : public std::array<de::dbyte, 4>
+    {
+    public:
+        Args();
+        Args(de::dbyte const *cArr, de::dint length);
+    };
+
+    /**
+     * Logical script states.
+     */
+    enum State {
+        Inactive,
+        Running,
+        Suspended,
+
+        WaitingForSector,
+        WaitingForPolyobj,
+        WaitingForScript,
+
+        Terminating
+    };
+    static de::String stateAsText(State state);
+
+public:
+    Script();
+    Script(EntryPoint const &ep);
+
+    /**
+     * Composes the human-friendly, styled, textual name of the object.
+     */
+    de::String describe() const;
+
+    /**
+     * Composes a human-friendly, styled, textual description of the script.
+     */
+    de::String description() const;
+
+    /**
+     * Start/resume script interpretation if inactive/suspended.
+     *
+     * If currently suspended the script is instructed to resume (deferred).
+     *
+     * Otherwise instantiate a new script Interpreter and add it to the list of
+     * thinkers for the @em current map.
+     *
+     * @param args       Script argument values.
+     * @param activator  Mobj activator, if any (can be @c nullptr).
+     * @param line       Line activator, if any (can be @c nullptr).
+     * @param side       Line side number.
+     * @param delayTics  Number of tics to wait before interpretation begins.
+     *                   (Can be used to delay processing during map startup).
+     *
+     * @return  @c true if started/resumed.
+     */
+    bool start(Args const &args, mobj_t *activator = nullptr,
+               Line *line = nullptr, int side = 0, int delayTics = 0);
+
+    /**
+     * Instruct the script to self-suspend if running (deferred).
+     *
+     * @return  @c true if marked for suspension.
+     */
+    bool suspend();
+
+    /**
+     * Instruct the script to self-terminate if running (deferred).
+     *
+     * @return  @c true if marked for termination.
+     */
+    bool terminate();
+
+    /**
+     * Returns the current logical state of the script (FYI).
+     */
+    State state() const;
+
+    bool isRunning()   const;
+    bool isSuspended() const;
+    bool isWaiting()   const;
+
+    void waitForPolyobj(int tag);
+    void waitForScript (int number);
+    void waitForSector (int tag);
+
+    void polyobjFinished(int tag);
+    void sectorFinished (int tag);
+
+    /**
+     * Returns the entry point info for the script.
+     */
+    EntryPoint const &entryPoint() const;
+
+    /**
+     * Reconfigure the entry point info for the script.
+     */
+    void applyEntryPoint(EntryPoint const &epToCopy);
+
+    void read(Reader *reader);
+    void write(Writer *writer) const;
+
+public:  /// @todo make private:
+
+    /**
+     * Resume @em this script if it is waiting on @a other (which has just terminated).
+     *
+     * @param other  Script to be considered.
+     */
+    void resumeIfWaitingForScript(Script const &other);
+
+    void setState(State newState);
+
+private:
+    DENG2_PRIVATE(d)
+};
+
+} // namespace acs
+
+#endif  // LIBCOMMON_ACS_SCRIPT_H
diff --git a/doomsday/plugins/common/include/acs/system.h b/doomsday/plugins/common/include/acs/system.h
new file mode 100644
index 0000000000..c6bcd0ad4e
--- /dev/null
+++ b/doomsday/plugins/common/include/acs/system.h
@@ -0,0 +1,161 @@
+/** @file system.h  Action Code Script (ACS) system.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#ifndef COMMON_ACS_SYSTEM_H
+#define COMMON_ACS_SYSTEM_H
+
+#include "common.h"
+#ifdef __cplusplus
+#  include <array>
+#  include <functional>
+#  include <de/Error>
+#  include <de/Block>
+#  include <de/Reader>
+#  include <de/Writer>
+#  include <doomsday/filesys/file.h>
+#  include <doomsday/uri.h>
+#  include "acs/interpreter.h"
+#  include "acs/script.h"
+#  include "mapstatereader.h"
+#  include "mapstatewriter.h"
+
+namespace acs {
+
+/**
+ * Action Code Script (ACS) system.
+ *
+ * @ingroup playsim
+ */
+class System
+{
+public:  /// @todo make private:
+    std::array<int, 32> mapVars;
+    std::array<int, 64> worldVars;
+
+public:
+    /// Required/referenced script is missing. @ingroup errors
+    DENG2_ERROR(MissingScriptError);
+
+    /// Required/referenced string-constant is missing. @ingroup errors
+    DENG2_ERROR(MissingStringError);
+
+public:
+    System();
+
+    /**
+     * To be called when a new game session begins to reset the system. All
+     * global scripting variables are discarded and deferred-tasks purged.
+     */
+    void reset();
+
+    /**
+     * Load new ACS bytecode from the specified @a file.
+     */
+    void loadBytecode(de::File1 &file);
+
+    /**
+     * Returns the total number of script entry points in the loaded bytecode.
+     */
+    int scriptCount() const;
+
+    /**
+     * Returns @c true iff @a scriptNumber is a known entry point.
+     */
+    bool hasScript(int scriptNumber);
+
+    /**
+     * Lookup the Script info for the given @a scriptNumber.
+     */
+    Script &script(int scriptNumber) const;
+
+    /**
+     * Iterate through the Scripts of the loaded bytecode.
+     *
+     * @param func  Callback to make for each Script.
+     */
+    de::LoopResult forAllScripts(std::function<de::LoopResult (Script &)> func) const;
+
+    /**
+     * Defer a script start task until the identified map is next current.
+     *
+     * @param mapUri  Unique identifier of the map on which to start the script.
+     *
+     * @return  @c true iff a script was newly started (or deferred).
+     */
+    bool deferScriptStart(de::Uri const &mapUri, int scriptNumber, Script::Args const &args);
+
+    /**
+     * Provides readonly access to the loaded bytecode.
+     */
+    byte const *pcode() const;
+
+    /**
+     * Provides readonly access to a string constant from the loaded bytecode.
+     */
+    de::String stringConstant(int stringNumber) const;
+
+    de::Block serializeWorldState() const;
+    void readWorldState(de::Reader &from);
+
+    void writeMapState(MapStateWriter *msw) const;
+    void readMapState(MapStateReader *msr);
+
+public:  /// @todo make private: -----------------------------------------------
+
+    /**
+     * To be called when the current map changes to activate any deferred scripts
+     * which should now begin/resume.
+     */
+    void runDeferredTasks(de::Uri const &mapUri);
+
+public:
+    /**
+     * Register the console commands and variables of this module.
+     */
+    static void consoleRegister();
+
+private:
+    DENG2_PRIVATE(d)
+};
+
+} // namespace acs
+
+/**
+ * Returns the game's global acs::System.
+ */
+acs::System &Game_ACScriptSystem();
+
+#endif  // __cplusplus
+
+// C wrapper API: --------------------------------------------------------------
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+dd_bool Game_ACScriptSystem_StartScript(int scriptNumber, Uri const *mapUri,
+    byte const args[4], struct mobj_s *activator, Line *line, int side);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // COMMON_ACS_SYSTEM_H
diff --git a/doomsday/plugins/common/include/common.h b/doomsday/plugins/common/include/common.h
index a2cdbc8304..49e61afa30 100644
--- a/doomsday/plugins/common/include/common.h
+++ b/doomsday/plugins/common/include/common.h
@@ -46,13 +46,13 @@
 #  include "jhexen.h"
 #endif
 
+#ifdef __cplusplus
+#  include <doomsday/filesys/lumpindex.h>
+#endif
 #include "gamerules.h"
 #include "g_defs.h"
 #include "pause.h"
 #include "p_mapsetup.h"
-#ifdef __cplusplus
-#  include <doomsday/filesys/lumpindex.h>
-#endif
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/doomsday/plugins/common/include/d_net.h b/doomsday/plugins/common/include/d_net.h
index 5b6e50bf71..a48afc516e 100644
--- a/doomsday/plugins/common/include/d_net.h
+++ b/doomsday/plugins/common/include/d_net.h
@@ -23,15 +23,14 @@
 #ifndef LIBCOMMON_NETWORK_DEF_H
 #define LIBCOMMON_NETWORK_DEF_H
 
-#include "dd_share.h"
+#include "doomsday.h"
 #include <de/reader.h>
 #include <de/writer.h>
 #ifdef __cplusplus
 #  include <de/String>
+#  include <doomsday/uri.h>
 #endif
 
-#include "common.h"
-
 #define NETBUFFER_MAXMESSAGE 255
 
 #ifdef __JHEXEN__
@@ -231,7 +230,7 @@ long int D_NetPlayerEvent(int plrNumber, int peType, void *data);
  * @return  @c true = no further processing of the damage should be done else, process the
  * damage as normally.
  */
-dd_bool D_NetDamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, int damage);
+dd_bool D_NetDamageMobj(struct mobj_s *target, struct mobj_s *inflictor, struct mobj_s *source, int damage);
 
 int D_NetWorldEvent(int type, int tic, void *data);
 
@@ -267,7 +266,4 @@ de::String D_NetDefaultEpisode();
 de::Uri D_NetDefaultMap();
 #endif
 
-#include "d_netsv.h"
-#include "d_netcl.h"
-
-#endif // LIBCOMMON_NETWORK_DEF_H
+#endif  // LIBCOMMON_NETWORK_DEF_H
diff --git a/doomsday/plugins/common/include/d_netcl.h b/doomsday/plugins/common/include/d_netcl.h
index b7cb7f29d7..5d2953b27f 100644
--- a/doomsday/plugins/common/include/d_netcl.h
+++ b/doomsday/plugins/common/include/d_netcl.h
@@ -22,7 +22,8 @@
 #ifndef LIBCOMMON_D_NETCL_H
 #define LIBCOMMON_D_NETCL_H
 
-#include "d_net.h"
+#include "common.h"
+#include <de/reader.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/doomsday/plugins/common/include/g_common.h b/doomsday/plugins/common/include/g_common.h
index 483129afd3..342c71c3a4 100644
--- a/doomsday/plugins/common/include/g_common.h
+++ b/doomsday/plugins/common/include/g_common.h
@@ -22,10 +22,10 @@
 #define LIBCOMMON_GAME_H
 
 #include "dd_share.h"
+#include <doomsday/uri.h>
 #include "fi_lib.h"
 #include "mobj.h"
 #include "player.h"
-#include <doomsday/uri.h>
 
 #if __cplusplus
 class SaveSlots;
@@ -216,4 +216,4 @@ D_CMD( CCmdExitLevel );
 
 DENG_EXTERN_C dd_bool singledemo;
 
-#endif // LIBCOMMON_GAME_H
+#endif  // LIBCOMMON_GAME_H
diff --git a/doomsday/plugins/common/include/mapstatereader.h b/doomsday/plugins/common/include/mapstatereader.h
index c9e7154dd9..968cbb23ab 100644
--- a/doomsday/plugins/common/include/mapstatereader.h
+++ b/doomsday/plugins/common/include/mapstatereader.h
@@ -21,10 +21,11 @@
 #ifndef LIBCOMMON_MAPSTATEREADER_H
 #define LIBCOMMON_MAPSTATEREADER_H
 
-#include "common.h"
-#include "thingarchive.h"
+#include <de/reader.h>
 #include <de/game/SavedSession>
 #include <de/String>
+#include "common.h"
+#include "thingarchive.h"
 
 /**
  * Performs native saved game map state deserialization.
diff --git a/doomsday/plugins/common/include/mobj.h b/doomsday/plugins/common/include/mobj.h
index 85b601c572..1a01f34feb 100644
--- a/doomsday/plugins/common/include/mobj.h
+++ b/doomsday/plugins/common/include/mobj.h
@@ -22,7 +22,7 @@
 #ifndef LIBCOMMON_MOBJ
 #define LIBCOMMON_MOBJ
 
-#include "g_common.h"
+#include "common.h"
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/doomsday/plugins/common/include/p_mapspec.h b/doomsday/plugins/common/include/p_mapspec.h
index 208d2c7c1e..78e26fbc1f 100644
--- a/doomsday/plugins/common/include/p_mapspec.h
+++ b/doomsday/plugins/common/include/p_mapspec.h
@@ -1,7 +1,9 @@
-/** @file p_mapspec.h Crossed line special list utilities.
+/** @file p_mapspec.h  Crossed line special list utilities.
+ *
+ * Line Tag handling. Line and Sector groups. Specialized iterators, etc...
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
  *
  * @par License
  * GPL: http://www.gnu.org/licenses/gpl.html
@@ -34,8 +36,13 @@ extern "C" {
 /// Recursively traverse adjacent sectors, sound blocking lines cut off traversal.
 void P_RecursiveSound(struct mobj_s *soundTarget, Sector *sec, int soundBlocks);
 
+dd_bool P_SectorTagIsBusy(int tag);
+
+void P_NotifySectorFinished(int tag);
+void P_NotifyPolyobjFinished(int tag);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
-#endif // LIBCOMMON_PLAYSIM_MAP_SPECIAL_H
+#endif  // LIBCOMMON_PLAYSIM_MAP_SPECIAL_H
diff --git a/doomsday/plugins/common/include/p_xgline.h b/doomsday/plugins/common/include/p_xgline.h
index bb9616de42..d55d33c68f 100644
--- a/doomsday/plugins/common/include/p_xgline.h
+++ b/doomsday/plugins/common/include/p_xgline.h
@@ -32,9 +32,10 @@
 
 #include "doomsday.h"
 #include "xgclass.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 // Line type classes. Add new classes to the end!
diff --git a/doomsday/plugins/common/include/p_xgsec.h b/doomsday/plugins/common/include/p_xgsec.h
index c9d6d59946..0c47ea21a2 100644
--- a/doomsday/plugins/common/include/p_xgsec.h
+++ b/doomsday/plugins/common/include/p_xgsec.h
@@ -24,8 +24,11 @@
 #include "g_common.h"
 #ifdef __cplusplus
 #  include <de/Vector>
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+#endif
+
+#ifdef __cplusplus
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 // Sector chain event types.
diff --git a/doomsday/plugins/common/include/saveslots.h b/doomsday/plugins/common/include/saveslots.h
index 3c19f954a0..7761856b34 100644
--- a/doomsday/plugins/common/include/saveslots.h
+++ b/doomsday/plugins/common/include/saveslots.h
@@ -23,6 +23,7 @@
 #include <de/Error>
 #include <de/Path>
 #include <de/String>
+#include <de/game/SavedSession>
 
 /**
  * Maps saved game session file names into a finite set of "save slots".
@@ -193,4 +194,4 @@ class SaveSlots
 
 typedef SaveSlots::Slot SaveSlot;
 
-#endif // LIBCOMMON_SAVESLOTS_H
+#endif  // LIBCOMMON_SAVESLOTS_H
diff --git a/doomsday/plugins/common/src/acs/interpreter.cpp b/doomsday/plugins/common/src/acs/interpreter.cpp
new file mode 100644
index 0000000000..ee3742ccee
--- /dev/null
+++ b/doomsday/plugins/common/src/acs/interpreter.cpp
@@ -0,0 +1,1299 @@
+/** @file interpreter.cpp  Action Code Script (ACS), interpreter.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#include "acs/interpreter.h"
+
+#include <de/Log>
+#include "acs/system.h"
+#include "dmu_lib.h"
+#include "g_common.h"
+#include "gamesession.h"
+#include "player.h"
+#include "p_map.h"
+#include "p_saveg.h"
+#include "p_saveio.h"
+#include "p_sound.h"
+
+using namespace de;
+
+namespace internal {
+
+    /// Bytecode command return value.
+    enum CommandResult
+    {
+        Continue,
+        Stop,
+        Terminate
+    };
+
+    typedef CommandResult (*CommandFunc) (acs::Interpreter &);
+
+/// Helper macro for declaring an ACS command (function callback).
+#define ACS_COMMAND(Name) CommandResult cmd##Name(acs::Interpreter &interp)
+
+    static String printBuffer;
+    static byte specArgs[5];
+
+#ifdef __JHEXEN__
+
+    ACS_COMMAND(NOP)
+    {
+        DENG2_UNUSED(interp);
+        return Continue;
+    }
+
+    ACS_COMMAND(Terminate)
+    {
+        DENG2_UNUSED(interp);
+        return Terminate;
+    }
+
+    ACS_COMMAND(Suspend)
+    {
+        interp.script().setState(acs::Script::Suspended);
+        return Stop;
+    }
+
+    ACS_COMMAND(PushNumber)
+    {
+        interp.locals.push(LONG(*interp.pcodePtr++));
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec1)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[0] = interp.locals.pop();
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side, interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec2)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[1] = interp.locals.pop();
+        specArgs[0] = interp.locals.pop();
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side, interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec3)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[2] = interp.locals.pop();
+        specArgs[1] = interp.locals.pop();
+        specArgs[0] = interp.locals.pop();
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side, interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec4)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[3] = interp.locals.pop();
+        specArgs[2] = interp.locals.pop();
+        specArgs[1] = interp.locals.pop();
+        specArgs[0] = interp.locals.pop();
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side, interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec5)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[4] = interp.locals.pop();
+        specArgs[3] = interp.locals.pop();
+        specArgs[2] = interp.locals.pop();
+        specArgs[1] = interp.locals.pop();
+        specArgs[0] = interp.locals.pop();
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side,
+                             interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec1Direct)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[0] = LONG(*interp.pcodePtr++);
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side,
+                             interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec2Direct)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[0] = LONG(*interp.pcodePtr++);
+        specArgs[1] = LONG(*interp.pcodePtr++);
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side,
+                             interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec3Direct)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[0] = LONG(*interp.pcodePtr++);
+        specArgs[1] = LONG(*interp.pcodePtr++);
+        specArgs[2] = LONG(*interp.pcodePtr++);
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side,
+                             interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec4Direct)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[0] = LONG(*interp.pcodePtr++);
+        specArgs[1] = LONG(*interp.pcodePtr++);
+        specArgs[2] = LONG(*interp.pcodePtr++);
+        specArgs[3] = LONG(*interp.pcodePtr++);
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side,
+                             interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(LSpec5Direct)
+    {
+        int special = LONG(*interp.pcodePtr++);
+        specArgs[0] = LONG(*interp.pcodePtr++);
+        specArgs[1] = LONG(*interp.pcodePtr++);
+        specArgs[2] = LONG(*interp.pcodePtr++);
+        specArgs[3] = LONG(*interp.pcodePtr++);
+        specArgs[4] = LONG(*interp.pcodePtr++);
+        P_ExecuteLineSpecial(special, specArgs, interp.line, interp.side,
+                             interp.activator);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(Add)
+    {
+        interp.locals.push(interp.locals.pop() + interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(Subtract)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() - operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(Multiply)
+    {
+        interp.locals.push(interp.locals.pop() * interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(Divide)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() / operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(Modulus)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() % operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(EQ)
+    {
+        interp.locals.push(interp.locals.pop() == interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(NE)
+    {
+        interp.locals.push(interp.locals.pop() != interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(LT)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() < operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(GT)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() > operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(LE)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() <= operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(GE)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() >= operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(AssignScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)] = interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(AssignMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)] = interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(AssignWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)] = interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(PushScriptVar)
+    {
+        interp.locals.push(interp.args[LONG(*interp.pcodePtr++)]);
+        return Continue;
+    }
+
+    ACS_COMMAND(PushMapVar)
+    {
+        interp.locals.push(interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)]);
+        return Continue;
+    }
+
+    ACS_COMMAND(PushWorldVar)
+    {
+        interp.locals.push(interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)]);
+        return Continue;
+    }
+
+    ACS_COMMAND(AddScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)] += interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(AddMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)] += interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(AddWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)] += interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(SubScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)] -= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(SubMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)] -= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(SubWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)] -= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(MulScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)] *= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(MulMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)] *= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(MulWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)] *= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(DivScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)] /= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(DivMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)] /= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(DivWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)] /= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(ModScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)] %= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(ModMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)] %= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(ModWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)] %= interp.locals.pop();
+        return Continue;
+    }
+
+    ACS_COMMAND(IncScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)]++;
+        return Continue;
+    }
+
+    ACS_COMMAND(IncMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)]++;
+        return Continue;
+    }
+
+    ACS_COMMAND(IncWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)]++;
+        return Continue;
+    }
+
+    ACS_COMMAND(DecScriptVar)
+    {
+        interp.args[LONG(*interp.pcodePtr++)]--;
+        return Continue;
+    }
+
+    ACS_COMMAND(DecMapVar)
+    {
+        interp.scriptSys().mapVars[LONG(*interp.pcodePtr++)]--;
+        return Continue;
+    }
+
+    ACS_COMMAND(DecWorldVar)
+    {
+        interp.scriptSys().worldVars[LONG(*interp.pcodePtr++)]--;
+        return Continue;
+    }
+
+    ACS_COMMAND(Goto)
+    {
+        interp.pcodePtr = (int *) (interp.scriptSys().pcode() + LONG(*interp.pcodePtr));
+        return Continue;
+    }
+
+    ACS_COMMAND(IfGoto)
+    {
+        if(interp.locals.pop())
+        {
+            interp.pcodePtr = (int *) (interp.scriptSys().pcode() + LONG(*interp.pcodePtr));
+        }
+        else
+        {
+            interp.pcodePtr++;
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(Drop)
+    {
+        interp.locals.drop();
+        return Continue;
+    }
+
+    ACS_COMMAND(Delay)
+    {
+        interp.delayCount = interp.locals.pop();
+        return Stop;
+    }
+
+    ACS_COMMAND(DelayDirect)
+    {
+        interp.delayCount = LONG(*interp.pcodePtr++);
+        return Stop;
+    }
+
+    ACS_COMMAND(Random)
+    {
+        int high = interp.locals.pop();
+        int low  = interp.locals.pop();
+        interp.locals.push(low + (P_Random() % (high - low + 1)));
+        return Continue;
+    }
+
+    ACS_COMMAND(RandomDirect)
+    {
+        int low  = LONG(*interp.pcodePtr++);
+        int high = LONG(*interp.pcodePtr++);
+        interp.locals.push(low + (P_Random() % (high - low + 1)));
+        return Continue;
+    }
+
+    ACS_COMMAND(ThingCount)
+    {
+        int tid  = interp.locals.pop();
+        int type = interp.locals.pop();
+        // Anything to count?
+        if(type + tid)
+        {
+            interp.locals.push(P_MobjCount(type, tid));
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(ThingCountDirect)
+    {
+        int type = LONG(*interp.pcodePtr++);
+        int tid  = LONG(*interp.pcodePtr++);
+        // Anything to count?
+        if(type + tid)
+        {
+            interp.locals.push(P_MobjCount(type, tid));
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(TagWait)
+    {
+        interp.script().waitForSector(interp.locals.pop());
+        return Stop;
+    }
+
+    ACS_COMMAND(TagWaitDirect)
+    {
+        interp.script().waitForSector(LONG(*interp.pcodePtr++));
+        return Stop;
+    }
+
+    ACS_COMMAND(PolyWait)
+    {
+        interp.script().waitForPolyobj(interp.locals.pop());
+        return Stop;
+    }
+
+    ACS_COMMAND(PolyWaitDirect)
+    {
+        interp.script().waitForPolyobj(LONG(*interp.pcodePtr++));
+        return Stop;
+    }
+
+    ACS_COMMAND(ChangeFloor)
+    {
+        AutoStr *path = Str_PercentEncode(AutoStr_FromTextStd(interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData()));
+        uri_s *uri = Uri_NewWithPath3("Flats", Str_Text(path));
+
+        Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
+        Uri_Delete(uri);
+
+        int tag = interp.locals.pop();
+
+        if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Sector *sec;
+            while((sec = (Sector *) IterList_MoveIterator(list)))
+            {
+                P_SetPtrp(sec, DMU_FLOOR_MATERIAL, mat);
+            }
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(ChangeFloorDirect)
+    {
+        int tag = LONG(*interp.pcodePtr++);
+
+        AutoStr *path = Str_PercentEncode(AutoStr_FromTextStd(interp.scriptSys().stringConstant(LONG(*interp.pcodePtr++)).toUtf8().constData()));
+        uri_s *uri = Uri_NewWithPath3("Flats", Str_Text(path));
+
+        Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
+        Uri_Delete(uri);
+
+        if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Sector *sec;
+            while((sec = (Sector *) IterList_MoveIterator(list)))
+            {
+                P_SetPtrp(sec, DMU_FLOOR_MATERIAL, mat);
+            }
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(ChangeCeiling)
+    {
+        AutoStr *path = Str_PercentEncode(AutoStr_FromTextStd(interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData()));
+        uri_s *uri = Uri_NewWithPath3("Flats", Str_Text(path));
+
+        Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
+        Uri_Delete(uri);
+
+        int tag = interp.locals.pop();
+
+        if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Sector *sec;
+            while((sec = (Sector *) IterList_MoveIterator(list)))
+            {
+                P_SetPtrp(sec, DMU_CEILING_MATERIAL, mat);
+            }
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(ChangeCeilingDirect)
+    {
+        int tag = LONG(*interp.pcodePtr++);
+
+        AutoStr *path = Str_PercentEncode(AutoStr_FromTextStd(interp.scriptSys().stringConstant(LONG(*interp.pcodePtr++)).toUtf8().constData()));
+        uri_s *uri = Uri_NewWithPath3("Flats", Str_Text(path));
+
+        Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
+        Uri_Delete(uri);
+
+        if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Sector *sec;
+            while((sec = (Sector *) IterList_MoveIterator(list)))
+            {
+                P_SetPtrp(sec, DMU_CEILING_MATERIAL, mat);
+            }
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(Restart)
+    {
+        interp.pcodePtr = interp.script().entryPoint().pcodePtr;
+        return Continue;
+    }
+
+    ACS_COMMAND(AndLogical)
+    {
+        interp.locals.push(interp.locals.pop() && interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(OrLogical)
+    {
+        interp.locals.push(interp.locals.pop() || interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(AndBitwise)
+    {
+        interp.locals.push(interp.locals.pop() & interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(OrBitwise)
+    {
+        interp.locals.push(interp.locals.pop() | interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(EorBitwise)
+    {
+        interp.locals.push(interp.locals.pop() ^ interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(NegateLogical)
+    {
+        interp.locals.push(!interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(LShift)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() << operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(RShift)
+    {
+        int operand2 = interp.locals.pop();
+        interp.locals.push(interp.locals.pop() >> operand2);
+        return Continue;
+    }
+
+    ACS_COMMAND(UnaryMinus)
+    {
+        interp.locals.push(-interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(IfNotGoto)
+    {
+        if(interp.locals.pop())
+        {
+            interp.pcodePtr++;
+        }
+        else
+        {
+            interp.pcodePtr = (int *) (interp.scriptSys().pcode() + LONG(*interp.pcodePtr));
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(LineSide)
+    {
+        interp.locals.push(interp.side);
+        return Continue;
+    }
+
+    ACS_COMMAND(ScriptWait)
+    {
+        interp.script().waitForScript(interp.locals.pop());
+        return Stop;
+    }
+
+    ACS_COMMAND(ScriptWaitDirect)
+    {
+        interp.script().waitForScript(LONG(*interp.pcodePtr++));
+        return Stop;
+    }
+
+    ACS_COMMAND(ClearLineSpecial)
+    {
+        if(interp.line)
+        {
+            P_ToXLine(interp.line)->special = 0;
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(CaseGoto)
+    {
+        if(interp.locals.top() == LONG(*interp.pcodePtr++))
+        {
+            interp.pcodePtr = (int *) (interp.scriptSys().pcode() + LONG(*interp.pcodePtr));
+            interp.locals.drop();
+        }
+        else
+        {
+            interp.pcodePtr++;
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(BeginPrint)
+    {
+        DENG2_UNUSED(interp);
+        printBuffer.clear();
+        return Continue;
+    }
+
+    ACS_COMMAND(EndPrint)
+    {
+        if(interp.activator && interp.activator->player)
+        {
+            P_SetMessage(interp.activator->player, 0, printBuffer.toUtf8().constData());
+        }
+        else
+        {
+            // Send to everybody.
+            for(int i = 0; i < MAXPLAYERS; ++i)
+            {
+                if(players[i].plr->inGame)
+                {
+                    P_SetMessage(&players[i], 0, printBuffer.toUtf8().constData());
+                }
+            }
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(EndPrintBold)
+    {
+        DENG2_UNUSED(interp);
+        for(int i = 0; i < MAXPLAYERS; ++i)
+        {
+            if(players[i].plr->inGame)
+            {
+                P_SetYellowMessage(&players[i], 0, printBuffer.toUtf8().constData());
+            }
+        }
+        return Continue;
+    }
+
+    ACS_COMMAND(PrintString)
+    {
+        printBuffer += interp.scriptSys().stringConstant(interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(PrintNumber)
+    {
+        printBuffer += String::number(interp.locals.pop());
+        return Continue;
+    }
+
+    ACS_COMMAND(PrintCharacter)
+    {
+        char ch[2];
+        ch[0] = interp.locals.pop();
+        ch[1] = 0;
+        printBuffer += String(ch);
+        return Continue;
+    }
+
+    ACS_COMMAND(PlayerCount)
+    {
+        int count = 0;
+        for(int i = 0; i < MAXPLAYERS; ++i)
+        {
+            count += players[i].plr->inGame;
+        }
+        interp.locals.push(count);
+        return Continue;
+    }
+
+    ACS_COMMAND(GameType)
+    {
+        int gametype;
+
+        if(!IS_NETGAME)
+        {
+            gametype = 0; // singleplayer
+        }
+        else if(COMMON_GAMESESSION->rules().deathmatch)
+        {
+            gametype = 2; // deathmatch
+        }
+        else
+        {
+            gametype = 1; // cooperative
+        }
+        interp.locals.push(gametype);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(GameSkill)
+    {
+        interp.locals.push((int)COMMON_GAMESESSION->rules().skill);
+        return Continue;
+    }
+
+    ACS_COMMAND(Timer)
+    {
+        interp.locals.push(mapTime);
+        return Continue;
+    }
+
+    ACS_COMMAND(SectorSound)
+    {
+        mobj_t *emitter = nullptr;
+        if(interp.line)
+        {
+            auto *sector = (Sector *) P_GetPtrp(interp.line, DMU_FRONT_SECTOR);
+            emitter = (mobj_t *) P_GetPtrp(sector, DMU_EMITTER);
+        }
+        int volume = interp.locals.pop();
+
+        S_StartSoundAtVolume(S_GetSoundID(interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData()),
+                             emitter, volume / 127.0f);
+        return Continue;
+    }
+
+    ACS_COMMAND(ThingSound)
+    {
+        int volume   = interp.locals.pop();
+        int sound    = S_GetSoundID(interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData());
+        int tid      = interp.locals.pop();
+        int searcher = -1;
+
+        mobj_t *emitter;
+        while(sound && (emitter = P_FindMobjFromTID(tid, &searcher)))
+        {
+            S_StartSoundAtVolume(sound, emitter, volume / 127.0f);
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(AmbientSound)
+    {
+        mobj_t *emitter = nullptr; // For 3D positioning.
+        mobj_t *plrMo   = players[DISPLAYPLAYER].plr->mo;
+
+        int volume = interp.locals.pop();
+
+        // If we are playing 3D sounds, create a temporary source mobj for the sound.
+        if(Con_GetInteger("sound-3d") && plrMo)
+        {
+            // SpawnMobj calls P_Random. We don't want that the random generator gets
+            // out of sync.
+            if((emitter = P_SpawnMobjXYZ(MT_CAMERA,
+                                         plrMo->origin[VX] + ((M_Random() - 127) * 2),
+                                         plrMo->origin[VY] + ((M_Random() - 127) * 2),
+                                         plrMo->origin[VZ] + ((M_Random() - 127) * 2),
+                                         0, 0)))
+            {
+                emitter->tics = 5 * TICSPERSEC; // Five seconds should be enough.
+            }
+        }
+
+        int sound = S_GetSoundID(interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData());
+        S_StartSoundAtVolume(sound, emitter, volume / 127.0f);
+
+        return Continue;
+    }
+
+    ACS_COMMAND(SoundSequence)
+    {
+        mobj_t *emitter = nullptr;
+        if(interp.line)
+        {
+            auto *sector = (Sector *) P_GetPtrp(interp.line, DMU_FRONT_SECTOR);
+            emitter = (mobj_t *) P_GetPtrp(sector, DMU_EMITTER);
+        }
+        SN_StartSequenceName(emitter, interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData());
+
+        return Continue;
+    }
+
+    ACS_COMMAND(SetLineTexture)
+    {
+#define TEXTURE_TOP 0
+#define TEXTURE_MIDDLE 1
+#define TEXTURE_BOTTOM 2
+
+        AutoStr *path = Str_PercentEncode(AutoStr_FromTextStd(interp.scriptSys().stringConstant(interp.locals.pop()).toUtf8().constData()));
+        uri_s *uri = Uri_NewWithPath3("Textures", Str_Text(path));
+
+        Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
+        Uri_Delete(uri);
+
+        int position = interp.locals.pop();
+        int side     = interp.locals.pop();
+        int lineTag  = interp.locals.pop();
+
+        if(iterlist_t *list = P_GetLineIterListForTag(lineTag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Line *line;
+            while((line = (Line *) IterList_MoveIterator(list)))
+            {
+                Side *sdef = (Side *) P_GetPtrp(line, (side == 0? DMU_FRONT : DMU_BACK));
+
+                if(position == TEXTURE_MIDDLE)
+                {
+                    P_SetPtrp(sdef, DMU_MIDDLE_MATERIAL, mat);
+                }
+                else if(position == TEXTURE_BOTTOM)
+                {
+                    P_SetPtrp(sdef, DMU_BOTTOM_MATERIAL, mat);
+                }
+                else // TEXTURE_TOP
+                {
+                    P_SetPtrp(sdef, DMU_TOP_MATERIAL, mat);
+                }
+            }
+        }
+
+        return Continue;
+
+#undef TEXTURE_BOTTOM
+#undef TEXTURE_MIDDLE
+#undef TEXTURE_TOP
+    }
+
+    ACS_COMMAND(SetLineBlocking)
+    {
+        int lineFlags = interp.locals.pop()? DDLF_BLOCKING : 0;
+        int lineTag   = interp.locals.pop();
+
+        if(iterlist_t *list = P_GetLineIterListForTag(lineTag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Line *line;
+            while((line = (Line *) IterList_MoveIterator(list)))
+            {
+                P_SetIntp(line, DMU_FLAGS, (P_GetIntp(line, DMU_FLAGS) & ~DDLF_BLOCKING) | lineFlags);
+            }
+        }
+
+        return Continue;
+    }
+
+    ACS_COMMAND(SetLineSpecial)
+    {
+        int arg5    = interp.locals.pop();
+        int arg4    = interp.locals.pop();
+        int arg3    = interp.locals.pop();
+        int arg2    = interp.locals.pop();
+        int arg1    = interp.locals.pop();
+        int special = interp.locals.pop();
+        int lineTag = interp.locals.pop();
+
+        if(iterlist_t *list = P_GetLineIterListForTag(lineTag, false))
+        {
+            IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
+            IterList_RewindIterator(list);
+
+            Line *line;
+            while((line = (Line *) IterList_MoveIterator(list)))
+            {
+                xline_t *xline = P_ToXLine(line);
+
+                xline->special = special;
+                xline->arg1 = arg1;
+                xline->arg2 = arg2;
+                xline->arg3 = arg3;
+                xline->arg4 = arg4;
+                xline->arg5 = arg5;
+            }
+        }
+
+        return Continue;
+    }
+
+    static CommandFunc const &findCommand(int name)
+    {
+        static CommandFunc const cmds[] =
+        {
+            cmdNOP, cmdTerminate, cmdSuspend, cmdPushNumber, cmdLSpec1, cmdLSpec2,
+            cmdLSpec3, cmdLSpec4, cmdLSpec5, cmdLSpec1Direct, cmdLSpec2Direct,
+            cmdLSpec3Direct, cmdLSpec4Direct, cmdLSpec5Direct, cmdAdd,
+            cmdSubtract, cmdMultiply, cmdDivide, cmdModulus, cmdEQ, cmdNE,
+            cmdLT, cmdGT, cmdLE, cmdGE, cmdAssignScriptVar, cmdAssignMapVar,
+            cmdAssignWorldVar, cmdPushScriptVar, cmdPushMapVar,
+            cmdPushWorldVar, cmdAddScriptVar, cmdAddMapVar, cmdAddWorldVar,
+            cmdSubScriptVar, cmdSubMapVar, cmdSubWorldVar, cmdMulScriptVar,
+            cmdMulMapVar, cmdMulWorldVar, cmdDivScriptVar, cmdDivMapVar,
+            cmdDivWorldVar, cmdModScriptVar, cmdModMapVar, cmdModWorldVar,
+            cmdIncScriptVar, cmdIncMapVar, cmdIncWorldVar, cmdDecScriptVar,
+            cmdDecMapVar, cmdDecWorldVar, cmdGoto, cmdIfGoto, cmdDrop,
+            cmdDelay, cmdDelayDirect, cmdRandom, cmdRandomDirect,
+            cmdThingCount, cmdThingCountDirect, cmdTagWait, cmdTagWaitDirect,
+            cmdPolyWait, cmdPolyWaitDirect, cmdChangeFloor,
+            cmdChangeFloorDirect, cmdChangeCeiling, cmdChangeCeilingDirect,
+            cmdRestart, cmdAndLogical, cmdOrLogical, cmdAndBitwise,
+            cmdOrBitwise, cmdEorBitwise, cmdNegateLogical, cmdLShift,
+            cmdRShift, cmdUnaryMinus, cmdIfNotGoto, cmdLineSide, cmdScriptWait,
+            cmdScriptWaitDirect, cmdClearLineSpecial, cmdCaseGoto,
+            cmdBeginPrint, cmdEndPrint, cmdPrintString, cmdPrintNumber,
+            cmdPrintCharacter, cmdPlayerCount, cmdGameType, cmdGameSkill,
+            cmdTimer, cmdSectorSound, cmdAmbientSound, cmdSoundSequence,
+            cmdSetLineTexture, cmdSetLineBlocking, cmdSetLineSpecial,
+            cmdThingSound, cmdEndPrintBold
+        };
+        static int const numCmds = sizeof(cmds) / sizeof(cmds[0]);
+        if(name >= 0 && name < numCmds) return cmds[name];
+        /// @throw Error  Invalid command name specified.
+        throw Error("acs::Interpreter::findCommand", "Unknown command #" + String::number(name));
+    }
+
+#endif  // __JHEXEN__
+
+}  // namespace internal
+using namespace internal;
+
+namespace acs {
+
+thinker_t *Interpreter::newThinker(Script &script, Script::Args const &scriptArgs,
+    mobj_t *activator, Line *line, int side, int delayCount)
+{
+    Script::EntryPoint const &ep = script.entryPoint();
+
+    Interpreter *th = (Interpreter *) Z_Calloc(sizeof(*th), PU_MAP, nullptr);
+    th->thinker.function = (thinkfunc_t) acs_Interpreter_Think;
+
+    th->_script    = &script;
+    th->pcodePtr   = ep.pcodePtr;
+    th->delayCount = delayCount;
+    th->activator  = activator;
+    th->line       = line;
+    th->side       = side;
+    th->delayCount = delayCount;
+
+    for(int i = 0; i < ep.scriptArgCount; ++i)
+    {
+        th->args[i] = scriptArgs[i];
+    }
+
+    Thinker_Add(&th->thinker);
+
+    return &th->thinker;
+}
+
+void Interpreter::think()
+{
+#ifdef __JHEXEN__
+    int action = (script().state() == Script::Terminating? Terminate : Continue);
+
+    if(script().isRunning())
+    {
+        if(delayCount)
+        {
+            delayCount--;
+            return;
+        }
+
+        while((action = findCommand(LONG(*pcodePtr++))(*this)) == Continue)
+        {}
+    }
+
+    if(action == Terminate)
+    {
+        // This script has now finished - notify interested parties.
+        /// @todo Use a de::Observers -based mechanism for this.
+        script().setState(Script::Inactive);
+
+        // Notify any scripts which are waiting for this script to finish.
+        scriptSys().forAllScripts([this] (Script &otherScript)
+        {
+            otherScript.resumeIfWaitingForScript(script());
+            return LoopContinue;
+        });
+
+        Thinker_Remove(&thinker);
+    }
+#endif
+}
+
+System &Interpreter::scriptSys() const
+{
+    return Game_ACScriptSystem();
+}
+
+Script &Interpreter::script() const
+{
+    DENG2_ASSERT(_script);
+    return *static_cast<Script *>(_script);
+}
+
+void Interpreter::Stack::push(int value)
+{
+    if(height == ACS_INTERPRETER_SCRIPT_STACK_DEPTH)
+        LOG_SCR_ERROR("acs::Interpreter::Stack::push: Overflow");
+    values[height++] = value;
+}
+
+int Interpreter::Stack::pop()
+{
+    if(height == 0)
+        LOG_SCR_ERROR("acs::Interpreter::Stack::pop: Underflow");
+    return values[--height];
+}
+
+int Interpreter::Stack::top() const
+{
+    if(height == 0)
+        LOG_SCR_ERROR("acs::Interpreter::Stack::top: Underflow");
+    return values[height - 1];
+}
+
+void Interpreter::Stack::drop()
+{
+    if(height == 0)
+        LOG_SCR_ERROR("acs::Interpreter::Stack::drop: Underflow");
+    height--;
+}
+
+void Interpreter::write(MapStateWriter *msw) const
+{
+    writer_s *writer = msw->writer();
+
+    Writer_WriteByte(writer, 2); // Write a version byte.
+
+    Writer_WriteInt32(writer, msw->serialIdFor(activator));
+    Writer_WriteInt32(writer, P_ToIndex(line));
+    Writer_WriteInt32(writer, side);
+    Writer_WriteInt32(writer, script().entryPoint().scriptNumber);
+    Writer_WriteInt32(writer, delayCount);
+    for(int i = 0; i < ACS_INTERPRETER_SCRIPT_STACK_DEPTH; ++i)
+    {
+        Writer_WriteInt32(writer, locals.values[i]);
+    }
+    Writer_WriteInt32(writer, locals.height);
+    for(int i = 0; i < ACS_INTERPRETER_MAX_SCRIPT_ARGS; ++i)
+    {
+        Writer_WriteInt32(writer, args[i]);
+    }
+    Writer_WriteInt32(writer, ((byte const *)pcodePtr) - scriptSys().pcode());
+}
+
+int Interpreter::read(MapStateReader *msr)
+{
+    reader_s *reader = msr->reader();
+    int mapVersion = msr->mapVersion();
+
+    if(mapVersion >= 4)
+    {
+        // Note: the thinker class byte has already been read.
+        int ver = Reader_ReadByte(reader); // version byte.
+
+        // Activator.
+        activator = INT2PTR(mobj_t, Reader_ReadInt32(reader));
+        activator = msr->mobj(PTR2INT(activator), &activator);
+
+        // Line.
+        int lineIndex = Reader_ReadInt32(reader);
+        if(lineIndex >= 0)
+        {
+            line = (Line *) P_ToPtr(DMU_LINE, lineIndex);
+            DENG2_ASSERT(line);
+        }
+        else
+        {
+            line = nullptr;
+        }
+
+        // Side index.
+        side = Reader_ReadInt32(reader);
+
+        // Script number.
+        int scriptNumber = Reader_ReadInt32(reader);
+        _script = &scriptSys().script(scriptNumber);
+
+        // Obsolete ignored value in the old format?
+        if(ver < 2)
+        {
+            /*infoIndex =*/ Reader_ReadInt32(reader);
+        }
+
+        delayCount = Reader_ReadInt32(reader);
+
+        for(int i = 0; i < ACS_INTERPRETER_SCRIPT_STACK_DEPTH; ++i)
+        {
+            locals.values[i] = Reader_ReadInt32(reader);
+        }
+        locals.height = Reader_ReadInt32(reader);
+
+        for(int i = 0; i < ACS_INTERPRETER_MAX_SCRIPT_ARGS; ++i)
+        {
+            args[i] = Reader_ReadInt32(reader);
+        }
+
+        pcodePtr = (int *) (scriptSys().pcode() + Reader_ReadInt32(reader));
+    }
+    else
+    {
+        // Its in the old pre V4 format which serialized acs_t
+        // Padding at the start (an old thinker_t struct)
+        byte junk[16]; // sizeof thinker_t
+        Reader_Read(reader, junk, 16);
+
+        // Start of used data members.
+        activator  = INT2PTR(mobj_t, Reader_ReadInt32(reader));
+        activator  = msr->mobj(PTR2INT(activator), &activator);
+
+        int temp = Reader_ReadInt32(reader);
+        if(temp >= 0)
+        {
+            line = (Line *) P_ToPtr(DMU_LINE, temp);
+            DENG2_ASSERT(line);
+        }
+        else
+        {
+            line = nullptr;
+        }
+
+        side       = Reader_ReadInt32(reader);
+        _script    = &scriptSys().script(Reader_ReadInt32(reader));
+        /*infoIndex  =*/ Reader_ReadInt32(reader);
+        delayCount = Reader_ReadInt32(reader);
+
+        for(int i = 0; i < ACS_INTERPRETER_SCRIPT_STACK_DEPTH; ++i)
+        {
+            locals.values[i] = Reader_ReadInt32(reader);
+        }
+        locals.height = Reader_ReadInt32(reader);
+
+        for(int i = 0; i < ACS_INTERPRETER_MAX_SCRIPT_ARGS; ++i)
+        {
+            args[i] = Reader_ReadInt32(reader);
+        }
+
+        pcodePtr = (int *) (scriptSys().pcode() + Reader_ReadInt32(reader));
+    }
+
+    thinker.function = (thinkfunc_t) acs_Interpreter_Think;
+
+    return true; // Add this thinker.
+}
+
+}  // namespace acs
+
+void acs_Interpreter_Think(acs_Interpreter *interp)
+{
+    DENG2_ASSERT(interp);
+    reinterpret_cast<acs::Interpreter *>(interp)->think();
+}
diff --git a/doomsday/plugins/common/src/acs/script.cpp b/doomsday/plugins/common/src/acs/script.cpp
new file mode 100644
index 0000000000..59fd16a277
--- /dev/null
+++ b/doomsday/plugins/common/src/acs/script.cpp
@@ -0,0 +1,243 @@
+/** @file script.cpp  Action Code Script (ACS), script model.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#include "acs/script.h"
+#include "acs/interpreter.h"
+
+using namespace de;
+
+namespace acs {
+
+Script::Args::Args()
+{
+    fill(0);
+}
+
+Script::Args::Args(dbyte const *cArr, dint length)
+{
+    length = cArr? de::min(dint( size() ), length) : 0;
+
+    dint i = 0;
+    for(; i < length; ++i)         (*this)[i] = cArr[i];
+    for(; i < dint( size() ); ++i) (*this)[i] = 0;
+}
+
+// ----------------------------------------------------------------------------
+
+DENG2_PIMPL_NOREF(Script)
+{
+    std::unique_ptr<EntryPoint> entrypoint;
+    State state   = Inactive;
+    int waitValue = 0;
+
+    void wait(State waitState, int value)
+    {
+        DENG2_ASSERT((waitState == WaitingForSector)  ||
+                     (waitState == WaitingForPolyobj) ||
+                     (waitState == WaitingForScript));
+
+        state     = waitState;
+        waitValue = value;
+    }
+
+    void resumeIfWaitingForScript(Script const &other)
+    {
+        if(state != WaitingForScript) return;
+        if(waitValue != other.entryPoint().scriptNumber) return;
+
+        state = Running;
+    }
+};
+
+Script::Script() : d(new Instance)
+{}
+
+Script::Script(EntryPoint const &ep) : d(new Instance)
+{
+    applyEntryPoint(ep);
+}
+
+String Script::describe() const
+{
+    EntryPoint const &ep = entryPoint();
+    return "ACScript #" DE2_ESC(b) + String::number(ep.scriptNumber)
+         + DE2_ESC(l) " Args: " DE2_ESC(.) DE2_ESC(i) + String::number(ep.scriptArgCount)
+         + DE2_ESC(l) " Open: " DE2_ESC(.) DE2_ESC(i) + DENG2_BOOL_YESNO(ep.startWhenMapBegins);
+}
+
+String Script::description() const
+{
+    return DE2_ESC(l) "State: "     DE2_ESC(.) DE2_ESC(i) + stateAsText(d->state) + DE2_ESC(.)
+         + DE2_ESC(l) " Wait-for: " DE2_ESC(.) DE2_ESC(i) + d->waitValue;
+}
+
+bool Script::start(Args const &args, mobj_t *activator, Line *line, int side, int delayCount)
+{
+    // Resume a suspended script?
+    if(isSuspended())
+    {
+        d->state = Running;
+        return true;
+    }
+    if(d->state == Inactive)
+    {
+        Interpreter::newThinker(*this, args, activator, line, side, delayCount);
+        d->state = Running;
+        return true;
+    }
+    return false;
+}
+
+bool Script::suspend()
+{
+    // Some states disallow suspension.
+    if(d->state != Inactive && d->state != Suspended && d->state != Terminating)
+    {
+        d->state = Suspended;
+        return true;
+    }
+    return false;
+}
+
+bool Script::terminate()
+{
+    // Some states disallow termination.
+    if(d->state != Inactive && d->state != Terminating)
+    {
+        d->state = Terminating;
+        return true;
+    }
+    return false;
+}
+
+Script::State Script::state() const
+{
+    return d->state;
+}
+
+bool Script::isRunning() const
+{
+    return state() == Running;
+}
+
+bool Script::isSuspended() const
+{
+    return state() == Suspended;
+}
+
+bool Script::isWaiting() const
+{
+    switch(state())
+    {
+    case WaitingForSector:
+    case WaitingForPolyobj:
+    case WaitingForScript:
+        return true;
+    }
+    return false;
+}
+
+void Script::waitForPolyobj(int tag)
+{
+    d->wait(WaitingForPolyobj, tag);
+}
+
+void Script::waitForScript(int number)
+{
+    d->wait(WaitingForScript, number);
+}
+
+void Script::waitForSector(int tag)
+{
+    d->wait(WaitingForSector, tag);
+}
+
+void Script::polyobjFinished(int tag)
+{
+    if(d->state == WaitingForPolyobj && d->waitValue == tag)
+    {
+        d->state = Running;
+    }
+}
+
+void Script::sectorFinished(int tag)
+{
+    if(d->state == WaitingForSector && d->waitValue == tag)
+    {
+        d->state = Running;
+    }
+}
+
+Script::EntryPoint const &Script::entryPoint() const
+{
+    DENG2_ASSERT(d->entrypoint.get());
+    return *d->entrypoint;
+}
+
+void Script::applyEntryPoint(EntryPoint const &epToCopy)
+{
+    d->entrypoint.reset(new EntryPoint(epToCopy));
+}
+
+void Script::write(writer_s *writer) const
+{
+    DENG2_ASSERT(writer);
+    Writer_WriteInt16(writer, d->state);
+    Writer_WriteInt16(writer, d->waitValue);
+}
+
+void Script::read(reader_s *reader)
+{
+    DENG2_ASSERT(reader);
+    d->state     = State( Reader_ReadInt16(reader) );
+    d->waitValue = Reader_ReadInt16(reader);
+}
+
+void Script::resumeIfWaitingForScript(Script const &other)
+{
+    DENG2_ASSERT(&other != this);
+    d->resumeIfWaitingForScript(other);
+}
+
+void Script::setState(Script::State newState)
+{
+    d->state = newState;
+}
+
+String Script::stateAsText(State state) // static
+{
+    static char const *texts[] = {
+        "Inactive",
+        "Running",
+        "Suspended",
+        "Waiting for tag",
+        "Waiting for polyobj",
+        "Waiting for script",
+        "Terminating"
+    };
+    if(state >= Inactive && state <= Terminating)
+    {
+        return texts[int(state)];
+    }
+    return "(invalid-acscript-state)";
+}
+
+} // namespace acs
diff --git a/doomsday/plugins/common/src/acs/system.cpp b/doomsday/plugins/common/src/acs/system.cpp
new file mode 100644
index 0000000000..5916377ecb
--- /dev/null
+++ b/doomsday/plugins/common/src/acs/system.cpp
@@ -0,0 +1,461 @@
+/** @file system.cpp  Action Code Script (ACS) system.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#include "acs/system.h"
+
+#include <de/ISerializable>
+#include <de/Log>
+#include <de/NativePath>
+#include "acs/script.h"
+#include "acs/interpreter.h"
+#include "gamesession.h"
+
+using namespace de;
+
+namespace acs {
+
+namespace internal
+{
+    /**
+     * Bytecode header. Read directly from the map lump.
+     */
+#pragma pack(1)
+    struct BytecodeHeader
+    {
+        dint32 marker;
+        dint32 infoOffset;
+        dint32 code;
+    };
+#pragma pack()
+
+    /**
+     * A deferred task is enqueued when a script is started on a map not currently loaded.
+     */
+    class DeferredTask : public ISerializable
+    {
+    public:
+        de::Uri mapUri;             ///< Unique identifier of the target map.
+        dint32 scriptNumber;        ///< Script number to execute on the target map.
+        Script::Args scriptArgs;
+
+        DeferredTask() : scriptNumber(-1) {}
+        DeferredTask(de::Uri const &mapUri, dint32 scriptNumber, Script::Args const &scriptArgs)
+            : mapUri      (mapUri)
+            , scriptNumber(scriptNumber)
+            , scriptArgs  (scriptArgs)
+        {}
+        DeferredTask(DeferredTask const &other)
+            : mapUri      (other.mapUri)
+            , scriptNumber(other.scriptNumber)
+            , scriptArgs  (other.scriptArgs)
+        {}
+
+        static DeferredTask *newFromReader(de::Reader &from)
+        {
+            std::unique_ptr<DeferredTask> task(new DeferredTask);
+            from >> *task;
+            return task.release();
+        }
+
+        void operator >> (de::Writer &to) const
+        {
+            to << mapUri.compose()
+               << scriptNumber;
+            for(dbyte const &arg : scriptArgs) to << arg;
+        }
+
+        void operator << (de::Reader &from)
+        {
+            String mapUriStr;
+            from >> mapUriStr;
+            mapUri = de::Uri(mapUriStr, RC_NULL);
+            if(mapUri.scheme().isEmpty()) mapUri.setScheme("Maps");
+
+            from >> scriptNumber;
+            for(dbyte &arg : scriptArgs) from >> arg;
+        }
+    };
+}
+using namespace internal;
+
+DENG2_PIMPL(System)
+{
+    byte const *pcode = nullptr;  ///< Loaded bytecode (if any).
+    QList<Script *> scripts;
+    QList<String> strings;
+
+    QList<DeferredTask *> deferredTasks;
+
+    Instance(Public *i) : Base(i) {}
+    ~Instance()
+    {
+        clearDeferredTasks();
+        clearScripts();
+    }
+
+    void clearScripts()
+    {
+        qDeleteAll(scripts); scripts.clear();
+    }
+
+    void clearStrings()
+    {
+        strings.clear();
+    }
+
+    void clearDeferredTasks()
+    {
+        qDeleteAll(deferredTasks); deferredTasks.clear();
+    }
+
+    void runDeferredTasks(de::Uri const &mapUri)
+    {
+        for(int i = 0; i < deferredTasks.count(); ++i)
+        {
+            DeferredTask *task = deferredTasks[i];
+            if(task->mapUri != mapUri) continue;
+
+            if(self.hasScript(task->scriptNumber))
+            {
+                self.script(task->scriptNumber)
+                        .start(task->scriptArgs, nullptr, nullptr, 0, TICSPERSEC);
+            }
+            else
+            {
+                LOG_SCR_WARNING("Unknown script #%i") << task->scriptNumber;
+            }
+
+            delete deferredTasks.takeAt(i);
+            i -= 1;
+        }
+    }
+};
+
+System::System() : d(new Instance(this))
+{
+    mapVars.fill(0);
+    worldVars.fill(0);
+}
+
+void System::loadBytecode(File1 &file)
+{
+#define OPEN_SCRIPTS_BASE 1000
+
+    DENG2_ASSERT(!IS_CLIENT);
+
+    LOG_AS("acs::System");
+    LOG_SCR_VERBOSE("Loading bytecode from %s:%s...")
+            << NativePath(file.container().composePath()).pretty()
+            << file.name();
+
+    d->clearScripts();
+    d->clearStrings();
+
+    int numScripts = 0;
+
+    int const *readBuf = 0;
+    if(file.size() >= sizeof(BytecodeHeader))
+    {
+        void *region = Z_Malloc(file.size(), PU_MAP, nullptr);
+        file.read((uint8_t *)region);
+        BytecodeHeader const *header = (BytecodeHeader const *) region;
+        d->pcode = (byte const *) header;
+
+        if(LONG(header->infoOffset) < (int)file.size())
+        {
+            readBuf = (int *) ((byte const *) header + LONG(header->infoOffset));
+            numScripts = LONG(*readBuf++);
+        }
+    }
+
+    if(!numScripts)
+    {
+        // Empty file / invalid bytecode.
+        LOG_SCR_WARNING("File %s:%s does not appear to be valid ACS bytecode")
+                << NativePath(file.container().composePath())
+                << file.name();
+        return;
+    }
+
+    for(int i = 0; i < numScripts; ++i)
+    {
+        Script::EntryPoint ep;
+
+        ep.scriptNumber = LONG(*readBuf++);
+        if(ep.scriptNumber >= OPEN_SCRIPTS_BASE)
+        {
+            ep.scriptNumber -= OPEN_SCRIPTS_BASE;
+            ep.startWhenMapBegins = true;
+        }
+        ep.pcodePtr = (int const *)(d->pcode + LONG(*readBuf++));
+        ep.scriptArgCount = LONG(*readBuf++);
+        if(ep.scriptArgCount > ACS_INTERPRETER_MAX_SCRIPT_ARGS)
+            throw Error("acs::System::loadBytecode", "Too many script arguments (" + String::number(ep.scriptArgCount) + " > " + String::number(ACS_INTERPRETER_MAX_SCRIPT_ARGS) + ")");
+
+        d->scripts << new Script(ep/*make a copy*/);
+    }
+
+    int const numStrings = LONG(*readBuf++);
+    for(int i = 0; i < numStrings; ++i)
+    {
+        d->strings << String((char const *)(d->pcode + LONG(*readBuf++)));
+    }
+
+#undef OPEN_SCRIPTS_BASE
+}
+
+void System::reset()
+{
+    worldVars.fill(0);
+    mapVars.fill(0);
+    d->clearDeferredTasks();
+}
+
+int System::scriptCount() const
+{
+    return d->scripts.count();
+}
+
+bool System::hasScript(int scriptNumber)
+{
+    for(Script const *script : d->scripts)
+    {
+        if(script->entryPoint().scriptNumber == scriptNumber)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+Script &System::script(int scriptNumber) const
+{
+    for(Script const *script : d->scripts)
+    {
+        if(script->entryPoint().scriptNumber == scriptNumber)
+        {
+            return *const_cast<Script *>(script);
+        }
+    }
+    /// @throw MissingScriptError  Invalid script number specified.
+    throw MissingScriptError("acs::System::script", "Unknown script #" + String::number(scriptNumber));
+}
+
+LoopResult System::forAllScripts(std::function<LoopResult (Script &)> func) const
+{
+    for(Script *script : d->scripts)
+    {
+        if(auto result = func(*script)) return result;
+    }
+    return LoopContinue;
+}
+
+bool System::deferScriptStart(de::Uri const &mapUri, int scriptNumber,
+    Script::Args const &scriptArgs)
+{
+    DENG2_ASSERT(!IS_CLIENT);
+    DENG2_ASSERT(COMMON_GAMESESSION->mapUri() != mapUri);
+    LOG_AS("acs::System");
+
+    // Don't defer tasks in deathmatch.
+    /// @todo Why the restriction? -ds
+    if(COMMON_GAMESESSION->rules().deathmatch)
+        return true;
+
+    // Don't allow duplicates.
+    for(DeferredTask const *task : d->deferredTasks)
+    {
+        if(task->scriptNumber == scriptNumber &&
+           task->mapUri       == mapUri)
+        {
+            return false;
+        }
+    }
+
+    // Add it to the store to be started when that map is next entered.
+    d->deferredTasks << new DeferredTask(mapUri, scriptNumber, scriptArgs);
+    return true;
+}
+
+byte const *System::pcode() const
+{
+    return d->pcode;
+}
+
+String System::stringConstant(int stringNumber) const
+{
+    if(stringNumber >= 0 && stringNumber < d->strings.count())
+    {
+        return d->strings[stringNumber];
+    }
+    /// @throw MissingStringError  Invalid string-constant number specified.
+    throw MissingStringError("acs::System::stringConstant", "Unknown string-constant #" + String::number(stringNumber));
+}
+
+de::Block System::serializeWorldState() const
+{
+    de::Block data;
+    de::Writer writer(data);
+
+    // Write the world-global variable namespace.
+    for(int const &var : worldVars) writer << var;
+
+    // Write the deferred task queue.
+    writer << d->deferredTasks.count();
+    for(DeferredTask const *task : d->deferredTasks) writer << *task;
+
+    return data;
+}
+
+void System::readWorldState(de::Reader &from)
+{
+    // Read the world-global variable namespace.
+    for(int &var : worldVars) from >> var;
+
+    // Read the deferred task queue.
+    d->clearDeferredTasks();
+    int numDeferredTasks;
+    from >> numDeferredTasks;
+    for(int i = 0; i < numDeferredTasks; ++i)
+    {
+        d->deferredTasks << DeferredTask::newFromReader(from);
+    }
+}
+
+void System::writeMapState(MapStateWriter *msw) const
+{
+    writer_s *writer = msw->writer();
+
+    // Write each script state.
+    for(Script const *script : d->scripts) script->write(writer);
+
+    // Write each variable.
+    for(int const &var : mapVars) Writer_WriteInt32(writer, var);
+}
+
+void System::readMapState(MapStateReader *msr)
+{
+    reader_s *reader = msr->reader();
+
+    // Read each script state.
+    for(Script *script : d->scripts) script->read(reader);
+
+    // Read each variable.
+    for(int &var : mapVars) var = Reader_ReadInt32(reader);
+}
+
+void System::runDeferredTasks(de::Uri const &mapUri)
+{
+    LOG_AS("acs::System");
+    d->runDeferredTasks(mapUri);
+}
+
+D_CMD(InspectACScript)
+{
+    DENG2_UNUSED2(src, argc);
+    System &scriptSys = Game_ACScriptSystem();
+    int const scriptNumber    = String(argv[1]).toInt();
+
+    if(!scriptSys.hasScript(scriptNumber))
+    {
+        if(scriptSys.scriptCount())
+        {
+            LOG_SCR_WARNING("Unknown ACScript #%i") << scriptNumber;
+        }
+        else
+        {
+            LOG_SCR_MSG("No ACScripts are currently loaded");
+        }
+        return false;
+    }
+
+    Script const &script = scriptSys.script(scriptNumber);
+    LOG_SCR_MSG("%s\n%s") << script.describe() << script.description();
+    return true;
+}
+
+D_CMD(ListACScripts)
+{
+    DENG2_UNUSED3(src, argc, argv);
+    System &scriptSys = Game_ACScriptSystem();
+
+    if(scriptSys.scriptCount())
+    {
+        LOG_SCR_MSG("World variables:");
+        int idx = 0;
+        for(int const &var : scriptSys.worldVars)
+        {
+            LOG_SCR_MSG("  #%i: %i") << (idx++) << var;
+        }
+
+        LOG_SCR_MSG("Map variables:");
+        idx = 0;
+        for(int const &var : scriptSys.mapVars)
+        {
+            LOG_SCR_MSG("  #%i: %i") << (idx++) << var;
+        }
+
+        LOG_SCR_MSG("Available ACScripts:");
+        scriptSys.forAllScripts([&scriptSys] (Script const &script)
+        {
+            LOG_SCR_MSG("  %s") << script.describe();
+            return LoopContinue;
+        });
+    }
+
+    LOG_SCR_MSG("No ACScripts are currently loaded");
+    return true;
+}
+
+void System::consoleRegister()  // static
+{
+    C_CMD("scriptinfo",  "i",    InspectACScript);
+    C_CMD("scriptinfo",  "",     ListACScripts);
+}
+
+} // namespace acs
+
+static acs::System scriptSys;  ///< The One acs::System instance.
+
+acs::System &Game_ACScriptSystem()
+{
+    return scriptSys;
+}
+
+// C wrapper API: --------------------------------------------------------------
+
+dd_bool Game_ACScriptSystem_StartScript(int scriptNumber, uri_s const *mapUri_,
+    byte const args[], mobj_t *activator, Line *line, int side)
+{
+    de::Uri const *mapUri = reinterpret_cast<de::Uri const *>(mapUri_);
+    acs::Script::Args scriptArgs(args, 4);
+
+    if(!mapUri || COMMON_GAMESESSION->mapUri() == *mapUri)
+    {
+        if(scriptSys.hasScript(scriptNumber))
+        {
+            return scriptSys.script(scriptNumber).start(scriptArgs, activator, line, side);
+        }
+        return false;
+    }
+
+    return scriptSys.deferScriptStart(*mapUri, scriptNumber, scriptArgs);
+}
diff --git a/doomsday/plugins/common/src/d_net.cpp b/doomsday/plugins/common/src/d_net.cpp
index 73cf1c8ce4..bc3037d199 100644
--- a/doomsday/plugins/common/src/d_net.cpp
+++ b/doomsday/plugins/common/src/d_net.cpp
@@ -18,17 +18,18 @@
  * http://www.gnu.org/licenses</small>
  */
 
-#include "common.h"
 #include "d_net.h"
 
 #include <de/RecordValue>
+#include "d_netcl.h"
+#include "d_netsv.h"
+#include "fi_lib.h"
 #include "g_common.h"
 #include "gamesession.h"
-#include "player.h"
 #include "hu_menu.h"
 #include "p_mapsetup.h"
 #include "p_start.h"
-#include "fi_lib.h"
+#include "player.h"
 
 using namespace de;
 using namespace common;
diff --git a/doomsday/plugins/common/src/d_netcl.cpp b/doomsday/plugins/common/src/d_netcl.cpp
index ac8da4856a..8fcbb0ae9d 100644
--- a/doomsday/plugins/common/src/d_netcl.cpp
+++ b/doomsday/plugins/common/src/d_netcl.cpp
@@ -21,20 +21,20 @@
 #include "common.h"
 #include "d_netcl.h"
 
+#include <cstdio>
+#include <cstring>
+#include "d_netsv.h"       ///< @todo remove me
 #include "g_common.h"
 #include "gamesession.h"
-#include "p_saveg.h"
-#include "player.h"
-#include "p_map.h"
-#include "p_start.h"
+#include "hu_inventory.h"
 #include "p_actor.h"
 #include "p_inventory.h"
-#include "hu_inventory.h"
+#include "p_map.h"
+#include "p_saveg.h"
+#include "p_start.h"
+#include "player.h"
 #include "st_stuff.h"
 
-#include <cstdio>
-#include <cstring>
-
 using namespace de;
 using namespace common;
 
diff --git a/doomsday/plugins/common/src/g_game.cpp b/doomsday/plugins/common/src/g_game.cpp
index 4c0c45188e..5a618947d6 100644
--- a/doomsday/plugins/common/src/g_game.cpp
+++ b/doomsday/plugins/common/src/g_game.cpp
@@ -37,6 +37,8 @@
 #include "am_map.h"
 #include "animdefs.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "fi_lib.h"
 #include "g_controls.h"
diff --git a/doomsday/plugins/common/src/gamesession.cpp b/doomsday/plugins/common/src/gamesession.cpp
index 83255fa428..5d2996a165 100644
--- a/doomsday/plugins/common/src/gamesession.cpp
+++ b/doomsday/plugins/common/src/gamesession.cpp
@@ -28,8 +28,10 @@
 #include <de/ZipArchive>
 #include <de/game/SavedSession>
 #include <doomsday/defs/episode.h>
+#include "acs/system.h"
 #include "d_netsv.h"
 #include "g_common.h"
+#include "g_game.h"
 #include "hu_menu.h"
 #include "hu_inventory.h"
 #include "mapstatewriter.h"
@@ -263,7 +265,7 @@ DENG2_PIMPL(GameSession), public SavedSession::IMapStateReaderFactory
         // Save the current game state to the .save package.
 #if __JHEXEN__
         de::Writer(saved->replaceFile("ACScriptState")).withHeader()
-                << Game_ACScriptInterpreter().serializeWorldState();
+                << Game_ACScriptSystem().serializeWorldState();
 #endif
 
         Folder &mapsFolder = App::fileSystem().makeFolder(saved->path() / "maps");
@@ -536,7 +538,7 @@ DENG2_PIMPL(GameSession), public SavedSession::IMapStateReaderFactory
         if(rememberVisitedMaps)
         {
             ArrayValue const &vistedMapsArray = metadata.geta("visitedMaps");
-            foreach(Value const *value, vistedMapsArray.elements())
+            for(Value const *value : vistedMapsArray.elements())
             {
                 visitedMaps << de::Uri(value->as<TextValue>(), RC_NULL);
             }
@@ -546,7 +548,8 @@ DENG2_PIMPL(GameSession), public SavedSession::IMapStateReaderFactory
         // Deserialize the world ACS state.
         if(File const *state = saved.tryLocateStateFile("ACScript"))
         {
-            Game_ACScriptInterpreter().readWorldState(de::Reader(*state).withHeader());
+            Game_ACScriptSystem()
+                    .readWorldState(de::Reader(*state).withHeader());
         }
 #endif
 
@@ -1011,7 +1014,7 @@ void GameSession::end()
     if(!hasBegun()) return;
 
 #if __JHEXEN__
-    Game_ACScriptInterpreter().reset();
+    Game_ACScriptSystem().reset();
 #endif
     Session::removeSaved(internalSavePath);
 
@@ -1233,7 +1236,7 @@ void GameSession::leaveMap(de::Uri const &nextMapUri, uint nextMapEntryPoint)
     d->rules.randomClasses = oldRandomClassesRule;
 
     // Launch waiting scripts.
-    Game_ACScriptInterpreter().runDeferredTasks(d->mapUri);
+    Game_ACScriptSystem().runDeferredTasks(d->mapUri);
 #endif
 
     if(saved)
@@ -1247,9 +1250,9 @@ void GameSession::leaveMap(de::Uri const &nextMapUri, uint nextMapEntryPoint)
         saved->replaceFile("Info") << composeSaveInfo(metadata).toUtf8();
 
 #if __JHEXEN__
-        // Save the world-state of the ACScript interpreter.
+        // Save the world-state of the Script interpreter.
         de::Writer(saved->replaceFile("ACScriptState")).withHeader()
-                << Game_ACScriptInterpreter().serializeWorldState();
+                << Game_ACScriptSystem().serializeWorldState();
 #endif
 
         // Save the state of the current map.
diff --git a/doomsday/plugins/common/src/mapstatereader.cpp b/doomsday/plugins/common/src/mapstatereader.cpp
index 0abc0be155..564451e4d8 100644
--- a/doomsday/plugins/common/src/mapstatereader.cpp
+++ b/doomsday/plugins/common/src/mapstatereader.cpp
@@ -18,12 +18,16 @@
  * 02110-1301 USA</small>
  */
 
-#include "common.h"
 #include "mapstatereader.h"
 
+#include <de/ArrayValue>
+#include <de/NativePath>
+#include <de/String>
+#include "acs/system.h"
+#include "d_netsv.h"           /// @todo remove me
 #include "dmu_lib.h"
 #include "dmu_archiveindex.h"
-#include "d_netsv.h"           /// @todo remove me
+#include "g_game.h"
 #include "hu_log.h"
 #include "mapstatewriter.h"    // ChunkId
 #include "p_actor.h"
@@ -35,9 +39,6 @@
 #include "polyobjs.h"
 #include "r_common.h"
 #include "thinkerinfo.h"
-#include <de/ArrayValue>
-#include <de/NativePath>
-#include <de/String>
 
 namespace internal
 {
@@ -666,7 +667,7 @@ DENG2_PIMPL(MapStateReader)
     {
 #if __JHEXEN__
         beginSegment(ASEG_SCRIPTS);
-        Game_ACScriptInterpreter().readMapState(thisPublic);
+        Game_ACScriptSystem().readMapState(thisPublic);
         // endSegment();
 #endif
     }
diff --git a/doomsday/plugins/common/src/mapstatewriter.cpp b/doomsday/plugins/common/src/mapstatewriter.cpp
index b10186ca97..7cfa6cc273 100644
--- a/doomsday/plugins/common/src/mapstatewriter.cpp
+++ b/doomsday/plugins/common/src/mapstatewriter.cpp
@@ -21,7 +21,9 @@
 #include "common.h"
 #include "mapstatewriter.h"
 
+#include "acs/system.h"
 #include "dmu_lib.h"
+#include "g_game.h"
 #include "p_savedef.h"   // MY_SAVE_VERSION
 #include "p_saveg.h"     // SV_WriteSector, SV_WriteLine
 #include "polyobjs.h"
@@ -231,7 +233,7 @@ DENG2_PIMPL(MapStateWriter)
     {
 #if __JHEXEN__
         beginSegment(ASEG_SCRIPTS);
-        Game_ACScriptInterpreter().writeMapState(thisPublic);
+        Game_ACScriptSystem().writeMapState(thisPublic);
         // endSegment();
 #endif
     }
diff --git a/doomsday/plugins/common/src/mobj.cpp b/doomsday/plugins/common/src/mobj.cpp
index 9d5a75642a..418bff9f85 100644
--- a/doomsday/plugins/common/src/mobj.cpp
+++ b/doomsday/plugins/common/src/mobj.cpp
@@ -28,16 +28,15 @@
 #include "common.h"
 #include "mobj.h"
 
+#include <cmath>
+#include <de/mathutil.h>
 #include "dmu_lib.h"
+#include "mapstatereader.h"
+#include "mapstatewriter.h"
 #include "p_actor.h"
-#include "player.h"
 #include "p_map.h"
 #include "p_saveg.h"
-#include "p_actor.h"
-
-#include <de/mathutil.h>
-#include <cmath>
-#include <cassert>
+#include "player.h"
 
 #define DROPOFFMOMENTUM_THRESHOLD (1.0 / 4)
 
diff --git a/doomsday/plugins/common/src/p_ceiling.cpp b/doomsday/plugins/common/src/p_ceiling.cpp
index 010a048535..62890b3044 100644
--- a/doomsday/plugins/common/src/p_ceiling.cpp
+++ b/doomsday/plugins/common/src/p_ceiling.cpp
@@ -55,10 +55,8 @@
  */
 static void stopCeiling(ceiling_t *ceiling)
 {
-    P_ToXSector(ceiling->sector)->specialData = 0;
-#if __JHEXEN__
-    Game_ACScriptInterpreter().tagFinished(P_ToXSector(ceiling->sector)->tag);
-#endif
+    P_ToXSector(ceiling->sector)->specialData = nullptr;
+    P_NotifySectorFinished(P_ToXSector(ceiling->sector)->tag);
     Thinker_Remove(&ceiling->thinker);
 }
 
diff --git a/doomsday/plugins/common/src/p_door.cpp b/doomsday/plugins/common/src/p_door.cpp
index 771c55e291..c64736e3ff 100644
--- a/doomsday/plugins/common/src/p_door.cpp
+++ b/doomsday/plugins/common/src/p_door.cpp
@@ -183,10 +183,8 @@ void T_Door(void *doorThinkerPtr)
 #endif
             case DT_NORMAL:
             case DT_CLOSE:
-                xsec->specialData = 0;
-#if __JHEXEN__
-                Game_ACScriptInterpreter().tagFinished(P_ToXSector(door->sector)->tag);
-#endif
+                xsec->specialData = nullptr;
+                P_NotifySectorFinished(P_ToXSector(door->sector)->tag);
                 Thinker_Remove(&door->thinker); // Unlink and free.
 #if __JHERETIC__
                 S_PlaneSound((Plane *)P_GetPtrp(door->sector, DMU_CEILING_PLANE), SFX_DOORCLOSED);
@@ -264,10 +262,8 @@ void T_Door(void *doorThinkerPtr)
 #endif
             case DT_CLOSE30THENOPEN:
             case DT_OPEN:
-                xsec->specialData = 0;
-#if __JHEXEN__
-                Game_ACScriptInterpreter().tagFinished(P_ToXSector(door->sector)->tag);
-#endif
+                xsec->specialData = nullptr;
+                P_NotifySectorFinished(P_ToXSector(door->sector)->tag);
                 Thinker_Remove(&door->thinker); // Unlink and free.
 #if __JHERETIC__
                 S_StopSound(0, (mobj_t *) P_GetPtrp(door->sector, DMU_CEILING_EMITTER));
diff --git a/doomsday/plugins/common/src/p_floor.cpp b/doomsday/plugins/common/src/p_floor.cpp
index cc2a4de47d..403ff34f63 100644
--- a/doomsday/plugins/common/src/p_floor.cpp
+++ b/doomsday/plugins/common/src/p_floor.cpp
@@ -385,9 +385,7 @@ void T_MoveFloor(void *floorThinkerPtr)
             }
         }
 #endif
-#if __JHEXEN__
-        Game_ACScriptInterpreter().tagFinished(P_ToXSector(floor->sector)->tag);
-#endif
+        P_NotifySectorFinished(P_ToXSector(floor->sector)->tag);
         Thinker_Remove(&floor->thinker);
     }
 }
@@ -1488,8 +1486,8 @@ static int stopFloorCrush(thinker_t *th, void *context)
     {
         // Completely remove the crushing floor
         SN_StopSequence((mobj_t *)P_GetPtrp(floor->sector, DMU_EMITTER));
-        P_ToXSector(floor->sector)->specialData = NULL;
-        Game_ACScriptInterpreter().tagFinished(P_ToXSector(floor->sector)->tag);
+        P_ToXSector(floor->sector)->specialData = nullptr;
+        P_NotifySectorFinished(P_ToXSector(floor->sector)->tag);
         Thinker_Remove(&floor->thinker);
         (*found) = true;
     }
diff --git a/doomsday/plugins/common/src/p_inventory.cpp b/doomsday/plugins/common/src/p_inventory.cpp
index 816a432f29..dc05cfb5f7 100644
--- a/doomsday/plugins/common/src/p_inventory.cpp
+++ b/doomsday/plugins/common/src/p_inventory.cpp
@@ -22,13 +22,14 @@
 #include "common.h"
 #include "p_inventory.h"
 
+#include <cstring>
+#include <de/memory.h>
+#include "d_net.h"
+#include "d_netcl.h"
 #include "g_common.h"
 #include "gamesession.h"
-#include "player.h"
-#include "d_net.h"
 #include "hu_inventory.h"
-#include <de/memory.h>
-#include <cstring>
+#include "player.h"
 
 struct inventoryitem_t
 {
diff --git a/doomsday/plugins/common/src/p_map.cpp b/doomsday/plugins/common/src/p_map.cpp
index c3dda1a8d7..b33e28ed07 100644
--- a/doomsday/plugins/common/src/p_map.cpp
+++ b/doomsday/plugins/common/src/p_map.cpp
@@ -1,4 +1,4 @@
-/** @file p_map.cpp Common map routines.
+/** @file p_map.cpp  Common map routines.
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
  * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
@@ -19,13 +19,16 @@
  * 02110-1301 USA</small>
  */
 
+#include "common.h"
+#include "p_map.h"
+
 #include <cmath>
 #include <cstdio>
 #include <cstring>
-
-#include "common.h"
-
+#include "acs/system.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "g_common.h"
 #include "gamesession.h"
 #include "dmu_lib.h"
@@ -36,8 +39,6 @@
 #include "player.h"
 #include "p_mapsetup.h"
 
-#include "p_map.h"
-
 /*
  * Try move variables:
  */
@@ -3211,8 +3212,8 @@ static int PTR_PuzzleItemTraverse(Intercept const *icpt, void *context)
             return true; // Item type doesn't match.
         }
 
-        Game_ACScriptInterpreter_StartScript(xline->arg2, 0/*current-map*/, &xline->arg3,
-                                             parm.useMobj, icpt->line, 0);
+        Game_ACScriptSystem_StartScript(xline->arg2, 0/*current-map*/, &xline->arg3,
+                                        parm.useMobj, icpt->line, 0);
         xline->special = 0;
 
         parm.activated = true;
@@ -3231,8 +3232,8 @@ static int PTR_PuzzleItemTraverse(Intercept const *icpt, void *context)
             return false; // Item type doesn't match...
         }
 
-        Game_ACScriptInterpreter_StartScript(icpt->mobj->args[1], 0/*current-map*/,
-                                             &icpt->mobj->args[2], parm.useMobj, NULL, 0);
+        Game_ACScriptSystem_StartScript(icpt->mobj->args[1], 0/*current-map*/,
+                                        &icpt->mobj->args[2], parm.useMobj, NULL, 0);
         icpt->mobj->special = 0;
 
         parm.activated = true;
diff --git a/doomsday/plugins/common/src/p_mapsetup.cpp b/doomsday/plugins/common/src/p_mapsetup.cpp
index 832afa14b6..11c4b168a6 100644
--- a/doomsday/plugins/common/src/p_mapsetup.cpp
+++ b/doomsday/plugins/common/src/p_mapsetup.cpp
@@ -20,27 +20,28 @@
  * 02110-1301 USA</small>
  */
 
+#include "common.h"
+#include "p_mapsetup.h"
+
 #include <cmath>
 #include <cctype>  // isspace
 #include <cstring>
-
-#include "common.h"
-
+#include "acs/script.h"
+#include "acs/system.h"
 #include "am_map.h"
+#include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "g_common.h"
 #include "gamesession.h"
-#include "r_common.h"
+#include "hu_pspr.h"
+#include "hu_stuff.h"
 #include "p_actor.h"
 #include "p_scroll.h"
 #include "p_start.h"
 #include "p_tick.h"
 #include "polyobjs.h"
-#include "hu_pspr.h"
-#include "hu_stuff.h"
-#include "d_net.h"
-
-#include "p_mapsetup.h"
+#include "r_common.h"
 
 #if __JDOOM64__
 # define TOLIGHTIDX(c) (!((c) >> 8)? 0 : ((c) - 0x100) + 1)
@@ -910,14 +911,23 @@ void P_FinalizeMapChange(uri_s const *mapUri_)
         lumpnum_t acsLumpNum = mapMarkerLumpNum + 11 /*ML_BEHAVIOR*/;
         if(acsLumpNum < CentralLumpIndex().size())
         {
-            ACScriptInterpreter &interp = Game_ACScriptInterpreter();
-
-            interp.loadBytecode(CentralLumpIndex()[acsLumpNum]);
+            acs::System &acscriptSys = Game_ACScriptSystem();
 
-            std::memset(interp.mapVars, 0, sizeof(interp.mapVars));
+            acscriptSys.loadBytecode(CentralLumpIndex()[acsLumpNum]);
+            acscriptSys.mapVars.fill(0);
 
             // Start all scripts flagged to begin immediately.
-            interp.startOpenScripts();
+            // (allow a 1 second delay for map initialization to complete).
+            acscriptSys.forAllScripts([] (acs::Script &script)
+            {
+                if(script.entryPoint().startWhenMapBegins)
+                {
+                    bool justStarted = script.start(acs::Script::Args()/*default args*/, nullptr, nullptr, 0, TICSPERSEC);
+                    DENG2_ASSERT(justStarted);
+                    DENG2_UNUSED(justStarted);
+                }
+                return LoopContinue;
+            });
         }
     }
 #endif
diff --git a/doomsday/plugins/common/src/p_mapspec.c b/doomsday/plugins/common/src/p_mapspec.c
deleted file mode 100644
index 2c80909bbc..0000000000
--- a/doomsday/plugins/common/src/p_mapspec.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/** @file p_mapspec.c World map utilities.
- *
- * Line Tag handling. Line and Sector groups. Specialized iterators, etc...
- *
- * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
- *
- * @par License
- * GPL: http://www.gnu.org/licenses/gpl.html
- *
- * <small>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 St, Fifth Floor, Boston, MA
- * 02110-1301 USA</small>
- */
-
-#include "common.h"
-#include "dmu_lib.h"
-#include "p_mapsetup.h"
-#include "p_mapspec.h"
-
-iterlist_t *spechit = 0; /// For crossed line specials.
-
-typedef struct {
-    Sector *baseSec;
-    int soundBlocks;
-    mobj_t *soundTarget;
-} spreadsoundtoneighbors_params_t;
-
-/// @return  0= continue iteration; otherwise stop.
-static int spreadSoundToNeighbors(void *ptr, void *context)
-{
-    spreadsoundtoneighbors_params_t *parm = (spreadsoundtoneighbors_params_t *) context;
-    Line *li = (Line *) ptr;
-    xline_t *xline = P_ToXLine(li);
-    Sector *frontSec, *backSec, *other;
-    LineOpening opening;
-
-    DENG_ASSERT(xline);
-
-    if(!(xline->flags & ML_TWOSIDED)) return false;
-
-    frontSec = P_GetPtrp(li, DMU_FRONT_SECTOR);
-    if(!frontSec) return false;
-
-    backSec  = P_GetPtrp(li, DMU_BACK_SECTOR);
-    if(!backSec) return false;
-
-    Line_Opening(li, &opening);
-    if(opening.range <= 0) return false;
-
-    other = (frontSec == parm->baseSec? backSec : frontSec);
-
-    if(xline->flags & ML_SOUNDBLOCK)
-    {
-        if(!parm->soundBlocks)
-            P_RecursiveSound(parm->soundTarget, other, 1);
-    }
-    else
-    {
-        P_RecursiveSound(parm->soundTarget, other, parm->soundBlocks);
-    }
-
-    return false; // Continue iteration.
-}
-
-void P_RecursiveSound(struct mobj_s *soundTarget, Sector *sec, int soundBlocks)
-{
-    spreadsoundtoneighbors_params_t parm;
-    xsector_t *xsec = P_ToXSector(sec);
-
-    // Wake up all monsters in this sector.
-    if(P_GetIntp(sec, DMU_VALID_COUNT) == VALIDCOUNT && xsec->soundTraversed <= soundBlocks + 1)
-        return; // Already flooded.
-
-    P_SetIntp(sec, DMU_VALID_COUNT, VALIDCOUNT);
-    xsec->soundTraversed = soundBlocks + 1;
-    xsec->soundTarget = soundTarget;
-
-    parm.baseSec = sec;
-    parm.soundBlocks = soundBlocks;
-    parm.soundTarget = soundTarget;
-    P_Iteratep(sec, DMU_LINE, spreadSoundToNeighbors, &parm);
-}
diff --git a/doomsday/plugins/common/src/p_mapspec.cpp b/doomsday/plugins/common/src/p_mapspec.cpp
new file mode 100644
index 0000000000..88a6364a72
--- /dev/null
+++ b/doomsday/plugins/common/src/p_mapspec.cpp
@@ -0,0 +1,146 @@
+/** @file p_mapspec.cpp  World map utilities.
+ *
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ *
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
+ *
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
+ */
+
+#include "common.h"
+#include "p_mapspec.h"
+
+#include "acs/system.h"
+#include "dmu_lib.h"
+#include "g_game.h"
+#include "p_mapsetup.h"
+
+using namespace de;
+
+iterlist_t *spechit;  ///< For crossed line specials.
+
+struct spreadsoundtoneighbors_params_t
+{
+    Sector *baseSec;
+    int soundBlocks;
+    mobj_t *soundTarget;
+};
+
+/// @return  0= continue iteration; otherwise stop.
+static int spreadSoundToNeighbors(void *ptr, void *context)
+{
+    Line *li = (Line *) ptr;
+    spreadsoundtoneighbors_params_t &parm = *(spreadsoundtoneighbors_params_t *) context;
+
+    xline_t *xline = P_ToXLine(li);
+    DENG2_ASSERT(xline);
+
+    if(!(xline->flags & ML_TWOSIDED)) return false;
+
+    Sector *frontSec = (Sector *) P_GetPtrp(li, DMU_FRONT_SECTOR);
+    if(!frontSec) return false;
+
+    Sector *backSec  = (Sector *) P_GetPtrp(li, DMU_BACK_SECTOR);
+    if(!backSec) return false;
+
+    LineOpening opening;
+    Line_Opening(li, &opening);
+    if(opening.range <= 0) return false;
+
+    Sector *other = (frontSec == parm.baseSec? backSec : frontSec);
+
+    if(xline->flags & ML_SOUNDBLOCK)
+    {
+        if(!parm.soundBlocks)
+            P_RecursiveSound(parm.soundTarget, other, 1);
+    }
+    else
+    {
+        P_RecursiveSound(parm.soundTarget, other, parm.soundBlocks);
+    }
+
+    return false; // Continue iteration.
+}
+
+void P_RecursiveSound(mobj_t *soundTarget, Sector *sec, int soundBlocks)
+{
+    xsector_t *xsec = P_ToXSector(sec);
+    DENG2_ASSERT(xsec);
+
+    if(P_GetIntp(sec, DMU_VALID_COUNT) == VALIDCOUNT)
+    {
+        // Already flooded?
+        if(xsec->soundTraversed <= soundBlocks + 1)
+            return;
+    }
+
+    // Wake up all monsters in this sector.
+
+    P_SetIntp(sec, DMU_VALID_COUNT, VALIDCOUNT);
+    xsec->soundTraversed = soundBlocks + 1;
+    xsec->soundTarget    = soundTarget;
+
+    spreadsoundtoneighbors_params_t parm; de::zap(parm);
+    parm.baseSec     = sec;
+    parm.soundBlocks = soundBlocks;
+    parm.soundTarget = soundTarget;
+    P_Iteratep(sec, DMU_LINE, spreadSoundToNeighbors, &parm);
+}
+
+dd_bool P_SectorTagIsBusy(int tag)
+{
+    /// @note The sector tag lists cannot be used here as an iteration at a higher
+    /// level may already be in progress.
+    for(int i = 0; i < numsectors; ++i)
+    {
+        xsector_t *xsec = P_ToXSector((Sector *) P_ToPtr(DMU_SECTOR, i));
+        if(xsec->tag == tag && xsec->specialData)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+void P_NotifySectorFinished(int tag)
+{
+#if __JHEXEN__
+    if(!P_SectorTagIsBusy(tag))
+    {
+        Game_ACScriptSystem().forAllScripts([&tag] (acs::Script &script)
+        {
+            script.sectorFinished(tag);
+            return LoopContinue;
+        });
+    }
+#else
+    DENG2_UNUSED(tag);
+#endif
+}
+
+void P_NotifyPolyobjFinished(int tag)
+{
+#if __JHEXEN__
+    if(!P_SectorTagIsBusy(tag))
+    {
+        Game_ACScriptSystem().forAllScripts([&tag] (acs::Script &script)
+        {
+            script.polyobjFinished(tag);
+            return LoopContinue;
+        });
+    }
+#else
+    DENG2_UNUSED(tag);
+#endif
+}
diff --git a/doomsday/plugins/common/src/p_plat.cpp b/doomsday/plugins/common/src/p_plat.cpp
index 57d440c429..e26e584968 100644
--- a/doomsday/plugins/common/src/p_plat.cpp
+++ b/doomsday/plugins/common/src/p_plat.cpp
@@ -58,10 +58,9 @@
  */
 static void stopPlat(plat_t *plat)
 {
-    P_ToXSector(plat->sector)->specialData = 0;
-#if __JHEXEN__
-    Game_ACScriptInterpreter().tagFinished(P_ToXSector(plat->sector)->tag);
-#endif
+    DENG2_ASSERT(plat);
+    P_ToXSector(plat->sector)->specialData = nullptr;
+    P_NotifySectorFinished(P_ToXSector(plat->sector)->tag);
     Thinker_Remove(&plat->thinker);
 }
 
diff --git a/doomsday/plugins/common/src/p_start.cpp b/doomsday/plugins/common/src/p_start.cpp
index b1f7e2e0cb..ee0a6656c1 100644
--- a/doomsday/plugins/common/src/p_start.cpp
+++ b/doomsday/plugins/common/src/p_start.cpp
@@ -29,6 +29,7 @@
 #include <de/NativePath>
 #include "am_map.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "gamesession.h"
 #include "g_common.h"
diff --git a/doomsday/plugins/common/src/p_user.c b/doomsday/plugins/common/src/p_user.c
index 30f7905732..e73352f345 100644
--- a/doomsday/plugins/common/src/p_user.c
+++ b/doomsday/plugins/common/src/p_user.c
@@ -30,20 +30,20 @@
  * Bobbing POV/weapon, movement, pending weapon...
  */
 
+#include "common.h"
+#include "p_user.h"
+
 #include <math.h>
 #include <string.h>
-
-#include "common.h"
 #include "fi_lib.h"
-#include "doomsday.h"
 #include "g_common.h"
+#include "d_net.h"
+#include "d_netcl.h"
 #include "player.h"
 #include "p_tick.h" // for Pause_IsPaused()
 #include "p_view.h"
-#include "d_net.h"
 #include "player.h"
 #include "p_map.h"
-#include "p_user.h"
 #include "g_common.h"
 #include "am_map.h"
 #include "hu_log.h"
diff --git a/doomsday/plugins/common/src/p_xgsave.cpp b/doomsday/plugins/common/src/p_xgsave.cpp
index 7e0480eeaa..756376b48c 100644
--- a/doomsday/plugins/common/src/p_xgsave.cpp
+++ b/doomsday/plugins/common/src/p_xgsave.cpp
@@ -22,6 +22,8 @@
 
 #include "common.h"
 #include "dmu_lib.h"
+#include "mapstatereader.h"
+#include "mapstatewriter.h"
 #include "p_mapsetup.h"
 #include "p_saveg.h"
 #include "p_xg.h"
diff --git a/doomsday/plugins/common/src/pause.cpp b/doomsday/plugins/common/src/pause.cpp
index d7637508cd..4d387b5cdf 100644
--- a/doomsday/plugins/common/src/pause.cpp
+++ b/doomsday/plugins/common/src/pause.cpp
@@ -21,10 +21,13 @@
 
 #include "common.h"
 #include "pause.h"
+
+#include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "g_common.h"
 #include "hu_menu.h"
 #include "hu_msg.h"
-#include "d_net.h"
 
 using namespace de;
 using namespace common;
diff --git a/doomsday/plugins/common/src/player.cpp b/doomsday/plugins/common/src/player.cpp
index 8b3e4f3dd1..4d01656e92 100644
--- a/doomsday/plugins/common/src/player.cpp
+++ b/doomsday/plugins/common/src/player.cpp
@@ -21,8 +21,9 @@
 #include "common.h"
 #include "player.h"
 
-#include "d_netsv.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "g_common.h"
 #include "gamesession.h"
diff --git a/doomsday/plugins/common/src/polyobjs.cpp b/doomsday/plugins/common/src/polyobjs.cpp
index e221e6cedd..2bdde94ddb 100644
--- a/doomsday/plugins/common/src/polyobjs.cpp
+++ b/doomsday/plugins/common/src/polyobjs.cpp
@@ -22,16 +22,14 @@
 #include "common.h"
 #include "polyobjs.h"
 
+#include "acs/script.h"
 #include "dmu_lib.h"
+#include "g_common.h"
 #include "p_actor.h"
-#include "p_mapsetup.h"
 #include "p_map.h"
+#include "p_mapspec.h"
+#include "p_mapsetup.h"
 #include "p_start.h"
-#include "g_common.h"
-
-#ifdef __JHEXEN__
-#  include "acscript.h"
-#endif
 
 #define POBJ_PERPETUAL  0xffffffffu  // -1
 
@@ -53,15 +51,6 @@ static int findMirrorPolyobj(int tag)
     return 0;
 }
 
-static void notifyPolyobjFinished(int tag)
-{
-#if __JHEXEN__
-    Game_ACScriptInterpreter().polyobjFinished(tag);
-#else
-    DENG_UNUSED(tag);
-#endif
-}
-
 static void startSoundSequence(Polyobj *poEmitter)
 {
 #if __JHEXEN__
@@ -126,7 +115,7 @@ void T_RotatePoly(void *polyThinker)
                 po->specialData = 0;
 
             stopSoundSequence(po);
-            notifyPolyobjFinished(po->tag);
+            P_NotifyPolyobjFinished(po->tag);
             Thinker_Remove(&pe->thinker);
             po->angleSpeed = 0;
         }
@@ -260,7 +249,7 @@ void T_MovePoly(void *polyThinker)
                 po->specialData = NULL;
 
             stopSoundSequence(po);
-            notifyPolyobjFinished(po->tag);
+            P_NotifyPolyobjFinished(po->tag);
             Thinker_Remove(&pe->thinker);
             po->speed = 0;
         }
@@ -504,7 +493,7 @@ void T_PolyDoor(void *polyDoorThinker)
                     if(po->specialData == pd)
                         po->specialData = NULL;
 
-                    notifyPolyobjFinished(po->tag);
+                    P_NotifyPolyobjFinished(po->tag);
                     Thinker_Remove(&pd->thinker);
                 }
             }
@@ -557,7 +546,7 @@ void T_PolyDoor(void *polyDoorThinker)
                     if(po->specialData == pd)
                         po->specialData = NULL;
 
-                    notifyPolyobjFinished(po->tag);
+                    P_NotifyPolyobjFinished(po->tag);
                     Thinker_Remove(&pd->thinker);
                 }
             }
diff --git a/doomsday/plugins/common/src/thinkerinfo.cpp b/doomsday/plugins/common/src/thinkerinfo.cpp
index d3fb8d140d..48b20589ff 100644
--- a/doomsday/plugins/common/src/thinkerinfo.cpp
+++ b/doomsday/plugins/common/src/thinkerinfo.cpp
@@ -21,6 +21,8 @@
 #include "common.h"
 #include "thinkerinfo.h"
 
+#include "acs/interpreter.h"
+#include "acs/script.h"
 #include "mobj.h"
 #include "p_ceiling.h"
 #include "p_door.h"
@@ -29,7 +31,6 @@
 #include "p_scroll.h"
 #include "p_switch.h"
 #if __JHEXEN__
-#  include "acscript.h"
 #  include "p_pillar.h"
 #  include "p_waggle.h"
 #endif
@@ -103,11 +104,11 @@ static ThinkerClassInfo thinkerInfo[] = {
 #if __JHEXEN__
     {
      TC_INTERPRET_ACS,
-     (thinkfunc_t) ACScript_Thinker,
+     (thinkfunc_t) acs_Interpreter_Think,
      0,
-     de::function_cast<WriteThinkerFunc>(writeThinkerAs<ACScript>),
-     de::function_cast<ReadThinkerFunc>(readThinkerAs<ACScript>),
-     sizeof(ACScript)
+     de::function_cast<WriteThinkerFunc>(writeThinkerAs<acs::Interpreter>),
+     de::function_cast<ReadThinkerFunc>(readThinkerAs<acs::Interpreter>),
+     sizeof(acs::Interpreter)
     },
     {
      TC_FLOOR_WAGGLE,
diff --git a/doomsday/plugins/doom/include/bossbrain.h b/doomsday/plugins/doom/include/bossbrain.h
index 3afd60916f..a67d43e158 100644
--- a/doomsday/plugins/doom/include/bossbrain.h
+++ b/doomsday/plugins/doom/include/bossbrain.h
@@ -29,9 +29,10 @@
 #endif
 
 #include "jdoom.h"
+
 #ifdef __cplusplus
-#include "mapstatereader.h"
-#include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 
 /**
  * Global state of boss brain.
diff --git a/doomsday/plugins/doom/include/p_mobj.h b/doomsday/plugins/doom/include/p_mobj.h
index 1532011488..fcfb6eba80 100644
--- a/doomsday/plugins/doom/include/p_mobj.h
+++ b/doomsday/plugins/doom/include/p_mobj.h
@@ -41,9 +41,10 @@
 #include "doomdata.h"
 #include "info.h"
 #include "tables.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 #define NOMOM_THRESHOLD     (0.0001) // (integer) 0
diff --git a/doomsday/plugins/doom/src/intermission.cpp b/doomsday/plugins/doom/src/intermission.cpp
index 67bde2e5c5..c57a264e3a 100644
--- a/doomsday/plugins/doom/src/intermission.cpp
+++ b/doomsday/plugins/doom/src/intermission.cpp
@@ -27,6 +27,8 @@
 #include <cstring>
 #include <QList>
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "gamesession.h"
 #include "hu_stuff.h"
 #include "p_mapsetup.h"
diff --git a/doomsday/plugins/doom/src/m_cheat.cpp b/doomsday/plugins/doom/src/m_cheat.cpp
index eea39ea448..0eadf8c6a2 100644
--- a/doomsday/plugins/doom/src/m_cheat.cpp
+++ b/doomsday/plugins/doom/src/m_cheat.cpp
@@ -28,6 +28,8 @@
 
 #include "jdoom.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "g_eventsequence.h"
 #include "g_defs.h"
diff --git a/doomsday/plugins/doom/src/p_inter.c b/doomsday/plugins/doom/src/p_inter.c
index 95b26a55b5..3a954bdd0d 100644
--- a/doomsday/plugins/doom/src/p_inter.c
+++ b/doomsday/plugins/doom/src/p_inter.c
@@ -32,9 +32,11 @@
 #endif
 
 #include "jdoom.h"
+#include "p_inter.h"
 
 #include "am_map.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "player.h"
 #include "p_user.h"
diff --git a/doomsday/plugins/doom/src/p_pspr.c b/doomsday/plugins/doom/src/p_pspr.c
index 6c9b4d8681..3d478af2d5 100644
--- a/doomsday/plugins/doom/src/p_pspr.c
+++ b/doomsday/plugins/doom/src/p_pspr.c
@@ -36,10 +36,12 @@
 
 // HEADER FILES ------------------------------------------------------------
 
-#include <math.h>
+#include "jdoom.h"
+#include "p_pspr.h"
 
-#include "common.h"
+#include <math.h>
 #include "d_net.h"
+#include "d_netcl.h"
 #include "player.h"
 #include "p_map.h"
 #include "p_tick.h"
diff --git a/doomsday/plugins/doom/src/p_spec.cpp b/doomsday/plugins/doom/src/p_spec.cpp
index 183e1addd5..17db12aea2 100644
--- a/doomsday/plugins/doom/src/p_spec.cpp
+++ b/doomsday/plugins/doom/src/p_spec.cpp
@@ -24,6 +24,7 @@
 
 #include "gamesession.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "m_argv.h"
 #include "p_ceiling.h"
diff --git a/doomsday/plugins/doom64/include/p_lights.h b/doomsday/plugins/doom64/include/p_lights.h
index fb4d86a779..e0cde6eb29 100644
--- a/doomsday/plugins/doom64/include/p_lights.h
+++ b/doomsday/plugins/doom64/include/p_lights.h
@@ -28,9 +28,10 @@
 #endif
 
 #include "doomsday.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 #define GLOWSPEED               (8)
diff --git a/doomsday/plugins/doom64/include/p_mobj.h b/doomsday/plugins/doom64/include/p_mobj.h
index 7af40baa54..1bd59be6e5 100644
--- a/doomsday/plugins/doom64/include/p_mobj.h
+++ b/doomsday/plugins/doom64/include/p_mobj.h
@@ -42,9 +42,10 @@
 #include "p_terraintype.h"
 #include "d_think.h"
 #include "info.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 #define NOMOM_THRESHOLD     (0.0001) // (integer) 0
diff --git a/doomsday/plugins/doom64/src/intermission.cpp b/doomsday/plugins/doom64/src/intermission.cpp
index 8175304f35..d1efae375d 100644
--- a/doomsday/plugins/doom64/src/intermission.cpp
+++ b/doomsday/plugins/doom64/src/intermission.cpp
@@ -22,13 +22,14 @@
 #include "jdoom64.h"
 #include "intermission.h"
 
-#include <cassert>
 #include <cstdio>
 #include <cctype>
 #include <cstring>
 
-#include "hu_stuff.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
+#include "hu_stuff.h"
 #include "p_mapsetup.h"
 #include "p_start.h"
 
diff --git a/doomsday/plugins/doom64/src/m_cheat.cpp b/doomsday/plugins/doom64/src/m_cheat.cpp
index a7166eb73f..4c01e11685 100644
--- a/doomsday/plugins/doom64/src/m_cheat.cpp
+++ b/doomsday/plugins/doom64/src/m_cheat.cpp
@@ -20,28 +20,29 @@
  * 02110-1301 USA</small>
  */
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-#ifdef UNIX
-# include <errno.h>
-#endif
-
 #include "jdoom64.h"
+#include "m_cheat.h"
 
-#include "gamesession.h"
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+#ifdef UNIX
+# include <cerrno>
+#endif
+#include "am_map.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
+#include "dmu_lib.h"
 #include "g_common.h"
-#include "player.h"
-#include "am_map.h"
+#include "gamesession.h"
 #include "hu_menu.h"
 #include "hu_msg.h"
-#include "dmu_lib.h"
-#include "p_user.h"
-#include "p_start.h"
-
+#include "player.h"
 #include "p_inventory.h"
+#include "p_start.h"
+#include "p_user.h"
 
 typedef struct {
     unsigned char *sequence;
diff --git a/doomsday/plugins/doom64/src/p_inter.c b/doomsday/plugins/doom64/src/p_inter.c
index 264ab69386..12cdc7389a 100644
--- a/doomsday/plugins/doom64/src/p_inter.c
+++ b/doomsday/plugins/doom64/src/p_inter.c
@@ -1,43 +1,34 @@
-/**\file
- *\section License
- * License: GPL
- * Online License Link: http://www.gnu.org/licenses/gpl.html
+/** @file p_inter.c  Handling interactions (i.e., collisions).
  *
- *\author Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- *\author Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
- *\author Copyright © 2003-2005 Samuel Villarreal <svkaiser@gmail.com>
- *\author Copyright © 1993-1996 by id Software, Inc.
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 2003-2005 Samuel Villarreal <svkaiser@gmail.com>
+ * @authors Copyright © 1993-1996 by id Software, Inc.
  *
- * 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.
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
  *
- * 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 St, Fifth Floor,
- * Boston, MA  02110-1301  USA
- */
-
-/**
- * p_inter.c: Handling interactions (i.e., collisions).
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
  */
 
 #ifdef MSVC
 #  pragma optimize("g", off)
 #endif
 
-// HEADER FILES ------------------------------------------------------------
-
 #include "jdoom64.h"
 
 #include "am_map.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "player.h"
 #include "p_map.h"
@@ -47,30 +38,12 @@
 #include "p_inventory.h"
 #include "p_start.h"
 
-// MACROS ------------------------------------------------------------------
-
 #define BONUSADD            (6)
 
-// TYPES -------------------------------------------------------------------
-
-// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
-
-// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
-
-// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
-
-// EXTERNAL DATA DECLARATIONS ----------------------------------------------
-
-// PUBLIC DATA DEFINITIONS -------------------------------------------------
-
 // A weapon is found with two clip loads, a big item has five clip loads.
 int maxAmmo[NUM_AMMO_TYPES] = { 200, 50, 300, 50 };
 int clipAmmo[NUM_AMMO_TYPES] = { 10, 4, 20, 1 };
 
-// PRIVATE DATA DEFINITIONS ------------------------------------------------
-
-// CODE --------------------------------------------------------------------
-
 /**
  * @param player        Player to be given ammo.
  * @param ammo          Type of ammo to be given.
diff --git a/doomsday/plugins/doom64/src/p_lights.cpp b/doomsday/plugins/doom64/src/p_lights.cpp
index 943ae7e840..a65b16c4d6 100644
--- a/doomsday/plugins/doom64/src/p_lights.cpp
+++ b/doomsday/plugins/doom64/src/p_lights.cpp
@@ -26,6 +26,8 @@
 #include "p_lights.h"
 
 #include "dmu_lib.h"
+#include "mapstatereader.h"
+#include "mapstatewriter.h"
 #include "p_mapsetup.h"
 #include "p_mapspec.h"
 
diff --git a/doomsday/plugins/doom64/src/p_spec.cpp b/doomsday/plugins/doom64/src/p_spec.cpp
index b26c13ccb4..2f92daee43 100644
--- a/doomsday/plugins/doom64/src/p_spec.cpp
+++ b/doomsday/plugins/doom64/src/p_spec.cpp
@@ -27,6 +27,7 @@
 #include <cstring>
 #include "gamesession.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "m_argv.h"
 #include "p_ceiling.h"
diff --git a/doomsday/plugins/heretic/include/p_lights.h b/doomsday/plugins/heretic/include/p_lights.h
index b5e055e428..3f8d4cba21 100644
--- a/doomsday/plugins/heretic/include/p_lights.h
+++ b/doomsday/plugins/heretic/include/p_lights.h
@@ -25,9 +25,10 @@
 #endif
 
 #include "doomsday.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 #define GLOWSPEED               (8)
diff --git a/doomsday/plugins/heretic/include/p_mobj.h b/doomsday/plugins/heretic/include/p_mobj.h
index 0ffba94af2..706cfd519f 100644
--- a/doomsday/plugins/heretic/include/p_mobj.h
+++ b/doomsday/plugins/heretic/include/p_mobj.h
@@ -38,9 +38,10 @@
 #include "p_terraintype.h"
 #include "h_think.h"
 #include "info.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 #define NOMOM_THRESHOLD     (0.0001) // (integer) 0
diff --git a/doomsday/plugins/heretic/src/intermission.cpp b/doomsday/plugins/heretic/src/intermission.cpp
index f24f92b8d4..6902b30842 100644
--- a/doomsday/plugins/heretic/src/intermission.cpp
+++ b/doomsday/plugins/heretic/src/intermission.cpp
@@ -24,6 +24,8 @@
 #include <cstring>
 #include "am_map.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "gamesession.h"
 #include "hu_stuff.h"
 #include "p_mapsetup.h"
diff --git a/doomsday/plugins/heretic/src/m_cheat.cpp b/doomsday/plugins/heretic/src/m_cheat.cpp
index 95ba473e7b..325acf35b3 100644
--- a/doomsday/plugins/heretic/src/m_cheat.cpp
+++ b/doomsday/plugins/heretic/src/m_cheat.cpp
@@ -1,4 +1,4 @@
-/** @file m_cheat.c Cheat code sequences
+/** @file m_cheat.cpp  Cheat code sequences
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
  * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
@@ -19,13 +19,15 @@
  * 02110-1301 USA</small>
  */
 
-#include <stdlib.h>
-#include <errno.h>
-
 #include "jheretic.h"
+#include "m_cheat.h"
 
+#include <cerrno>
+#include <cstdlib>
 #include "am_map.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "hu_msg.h"
 #include "g_eventsequence.h"
diff --git a/doomsday/plugins/heretic/src/p_inter.c b/doomsday/plugins/heretic/src/p_inter.c
index 8d63a70b58..95b5f46fb9 100644
--- a/doomsday/plugins/heretic/src/p_inter.c
+++ b/doomsday/plugins/heretic/src/p_inter.c
@@ -1,26 +1,22 @@
-/**\file
- *\section License
- * License: GPL
- * Online License Link: http://www.gnu.org/licenses/gpl.html
+/** @file p_inter.c  Handling interactions (i.e., collisions).
  *
- *\author Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- *\author Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
- *\author Copyright © 1999 Activision
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
  *
- * 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.
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
  *
- * 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 St, Fifth Floor,
- * Boston, MA  02110-1301  USA
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
  */
 
 #include <string.h>
@@ -29,6 +25,7 @@
 
 #include "am_map.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
 #include "player.h"
 #include "p_inventory.h"
diff --git a/doomsday/plugins/heretic/src/p_lights.cpp b/doomsday/plugins/heretic/src/p_lights.cpp
index eb3b4fa895..5eb875698a 100644
--- a/doomsday/plugins/heretic/src/p_lights.cpp
+++ b/doomsday/plugins/heretic/src/p_lights.cpp
@@ -24,6 +24,8 @@
 #include "jheretic.h"
 
 #include "dmu_lib.h"
+#include "mapstatereader.h"
+#include "mapstatewriter.h"
 #include "p_mapsetup.h"
 #include "p_mapspec.h"
 
diff --git a/doomsday/plugins/heretic/src/p_pspr.c b/doomsday/plugins/heretic/src/p_pspr.c
index 9852cf2b84..e07c1d3543 100644
--- a/doomsday/plugins/heretic/src/p_pspr.c
+++ b/doomsday/plugins/heretic/src/p_pspr.c
@@ -24,19 +24,19 @@
 #  pragma optimize("g", off)
 #endif
 
+#include "common.h"
+
 #include <math.h>
 #include <stdio.h>
 #include <string.h>
-
-#include "common.h"
-
 #include "d_net.h"
+#include "d_netcl.h"
 #include "g_defs.h"
-#include "player.h"
+#include "p_inventory.h"
 #include "p_map.h"
-#include "p_tick.h"
 #include "p_terraintype.h"
-#include "p_inventory.h"
+#include "p_tick.h"
+#include "player.h"
 
 #define LOWERSPEED          (6)
 #define RAISESPEED          (6)
diff --git a/doomsday/plugins/heretic/src/p_spec.cpp b/doomsday/plugins/heretic/src/p_spec.cpp
index 76e225beb2..f0c56426be 100644
--- a/doomsday/plugins/heretic/src/p_spec.cpp
+++ b/doomsday/plugins/heretic/src/p_spec.cpp
@@ -23,9 +23,10 @@
 #include "p_spec.h"
 
 #include <cstring>
-#include "gamesession.h"
 #include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
+#include "gamesession.h"
 #include "m_argv.h"
 #include "p_ceiling.h"
 #include "p_door.h"
diff --git a/doomsday/plugins/hexen/hexen.pro b/doomsday/plugins/hexen/hexen.pro
index 5f2058410f..ab06162622 100644
--- a/doomsday/plugins/hexen/hexen.pro
+++ b/doomsday/plugins/hexen/hexen.pro
@@ -28,7 +28,6 @@ INCLUDEPATH += include
 HEADERS += \
     include/a_action.h \
     include/acfnlink.h \
-    include/acscript.h \
     include/dstrings.h \
     include/g_game.h \
     include/h2def.h \
@@ -72,7 +71,6 @@ HEADERS += \
 SOURCES += \
     src/a_action.c \
     src/acfnlink.c \
-    src/acscript.cpp \
     src/h2_main.cpp \
     src/hconsole.cpp \
     src/hrefresh.cpp \
diff --git a/doomsday/plugins/hexen/include/acscript.h b/doomsday/plugins/hexen/include/acscript.h
deleted file mode 100644
index ce694fbcce..0000000000
--- a/doomsday/plugins/hexen/include/acscript.h
+++ /dev/null
@@ -1,299 +0,0 @@
-/** @file acscript.h  Hexen "ACS" scripting system.
- *
- * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
- * @authors Copyright © 1999 Activision
- *
- * @par License
- * GPL: http://www.gnu.org/licenses/gpl.html
- *
- * <small>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 St, Fifth Floor, Boston, MA
- * 02110-1301 USA</small>
- */
-
-#ifndef LIBHEXEN_PLAY_ACSCRIPT_H
-#define LIBHEXEN_PLAY_ACSCRIPT_H
-
-#ifndef __JHEXEN__
-#  error "Using jHexen headers without __JHEXEN__"
-#endif
-
-#include "jhexen.h"
-#include "p_mobj.h"
-#ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
-#  include <de/ISerializable>
-#  include <de/Reader>
-#  include <de/Writer>
-#  include <doomsday/filesys/file.h>
-#  include <doomsday/uri.h>
-#endif
-
-#define MAX_ACS_SCRIPT_VARS     10
-#define MAX_ACS_MAP_VARS        32
-#define MAX_ACS_WORLD_VARS      64
-#define ACS_STACK_DEPTH         32
-
-struct BytecodeScriptInfo;
-#ifdef __cplusplus
-class ACScriptInterpreter;
-#endif
-
-/**
- * Action script thinker.
- */
-typedef struct acscript_s {
-    thinker_t thinker;
-    mobj_t *activator;
-    Line *line;
-    int side;
-    struct BytecodeScriptInfo *_info;
-    int delayCount;
-    struct Stack { // Local value stack.
-        int values[ACS_STACK_DEPTH];
-        int height;
-
-#ifdef __cplusplus
-        void push(int value);
-        int pop();
-        int top() const;
-        void drop();
-#endif
-    } locals;
-    int vars[MAX_ACS_SCRIPT_VARS];
-    int const *pcodePtr;
-
-#ifdef __cplusplus
-    ACScriptInterpreter &interpreter() const;
-
-    BytecodeScriptInfo &info() const;
-
-    void runTick();
-
-    /**
-     * Serialize the thinker to the currently open save file.
-     */
-    void write(MapStateWriter *msw) const;
-
-    /**
-     * Deserialize the thinker from the currently open save file.
-     */
-    int read(MapStateReader *msr);
-#endif // __cplusplus
-} ACScript;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void ACScript_Thinker(ACScript *script);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#ifdef __cplusplus
-/**
- * Action-Code Script (ACS) bytecode interpreter.
- */
-class ACScriptInterpreter
-{
-public:
-    int mapVars[MAX_ACS_MAP_VARS];
-    int worldVars[MAX_ACS_WORLD_VARS];
-
-    /// Logical script states:
-    enum ScriptState {
-        Inactive,
-        Running,
-        Suspended,
-        WaitingForTag,
-        WaitingForPolyobj,
-        WaitingForScript,
-        Terminating
-    };
-
-public:
-    ACScriptInterpreter();
-
-    /**
-     * Load new ACS bytecode from the specified @a lump.
-     */
-    void loadBytecode(de::File1 &lump);
-
-    /**
-     * To be called when a new game session begins to reset the interpreter. The world state is
-     * discarded and any deferred tasks are cleared.
-     */
-    void reset();
-
-    /**
-     * Returns the total number of script entrypoints in the loaded bytecode.
-     */
-    int scriptCount() const;
-
-    /**
-     * Start all scripts flagged to begin immediately "on open".
-     */
-    void startOpenScripts();
-
-    /**
-     * Start/resume the specified script.
-     *
-     * @param map  Map number on which the script is to be started.
-     *             @c 0 = Current map. Otherwise 1-based index of the map to start on (deferred).
-     *
-     * @return  @c true iff a script was newly started (or deferred).
-     */
-    bool startScript(int scriptNumber, de::Uri const *mapUri, byte const args[4],
-                     mobj_t *activator = 0, Line *line = 0, int side = 0);
-
-    bool suspendScript(int scriptNumber, de::Uri const *mapUri);
-
-    bool terminateScript(int scriptNumber, de::Uri const *mapUri);
-
-    void tagFinished(int tag);
-    void polyobjFinished(int tag);
-
-    /**
-     * Returns @c true iff @a scriptNumber is a known entrypoint.
-     */
-    bool hasScriptEntrypoint(int scriptNumber);
-
-    /**
-     * Lookup the info structure for the specified @a scriptNumber (entrypoint).
-     */
-    BytecodeScriptInfo &scriptInfo(int scriptNumber);
-
-    inline BytecodeScriptInfo *scriptInfoPtr(int scriptNumber) {
-        return hasScriptEntrypoint(scriptNumber)? &scriptInfo(scriptNumber) : 0;
-    }
-
-    /**
-     * Provides readonly access to a string constant from the loaded bytecode.
-     */
-    Str const *string(int stringNumber) const;
-
-    /**
-     * Provides readonly access to the loaded bytecode.
-     */
-    byte const *bytecode() const;
-
-    void clearDeferredTasks();
-
-    /**
-     * To be called when the current map changes to activate any deferred scripts
-     * which should now begin/resume.
-     */
-    void runDeferredTasks(de::Uri const &mapUri);
-
-    /**
-     * To be called when the specified @a script is to be formally terminated.
-     * All other scripts waiting on this are notified.
-     *
-     * @param script  The script to be formally terminated. Note that the script
-     *                is considered free'd after calling this and pointers to it
-     *                should be considered invalid.
-     */
-    void scriptFinished(ACScript *script);
-
-    /**
-     * Composes the human-friendly, textual name of the identified @a scriptNumber.
-     */
-    AutoStr *scriptName(int scriptNumber);
-
-    /**
-     * Composes a human-friendly, styled, textual description of the current status
-     * of the identified @a scriptNumber.
-     */
-    AutoStr *scriptDescription(int scriptNumber);
-
-    de::Block serializeWorldState() const;
-    void readWorldState(de::Reader &from);
-
-    void writeMapState(MapStateWriter *msw);
-    void readMapState(MapStateReader *msr);
-
-public: /// @todo make private:
-    BytecodeScriptInfo &scriptInfoByIndex(int index);
-
-private:
-    /**
-     * Returns the logical index of a @a scriptNumber; otherwise @c -1.
-     */
-    int scriptInfoIndex(int scriptNumber);
-
-    ACScript *newACScript(BytecodeScriptInfo &info, byte const args[4], int delayCount = 0);
-
-    /**
-     * A deferred task is enqueued when a script is started on a map not currently loaded.
-     */
-    struct DeferredTask : public de::ISerializable
-    {
-        de::Uri mapUri;   ///< Target map.
-        int scriptNumber; ///< On the target map.
-        byte args[4];
-
-        DeferredTask();
-
-        /**
-         * @param mapUri        Unique identifier of the target map. A copy is made.
-         * @param scriptNumber  Script number to execute on the target map.
-         * @param args          Script arguments.
-         */
-        DeferredTask(de::Uri const &mapUri, int scriptNumber, byte const args[4]);
-
-        static DeferredTask *newFromReader(de::Reader &from);
-
-        void operator >> (de::Writer &to) const;
-        void operator << (de::Reader &from);
-    };
-
-    bool newDeferredTask(de::Uri const &mapUri, int scriptNumber, byte const args[4]);
-
-    byte const *_pcode; ///< Start of the loaded bytecode.
-
-    int _scriptCount; ///< Number of script entrypoints.
-    BytecodeScriptInfo *_scriptInfo;
-
-    int _stringCount;
-    Str *_strings;
-
-    int _deferredTasksSize;
-    DeferredTask **_deferredTasks;
-};
-
-/// @return  The game's global ACScript interpreter.
-ACScriptInterpreter &Game_ACScriptInterpreter();
-
-#endif
-
-// C wrapper API, for legacy modules -------------------------------------------
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-dd_bool Game_ACScriptInterpreter_StartScript(int scriptNumber, Uri const *mapUri,
-    byte const args[4], mobj_t *activator, Line *line, int side);
-
-dd_bool Game_ACScriptInterpreter_TerminateScript(int scriptNumber, Uri const *mapUri);
-
-dd_bool Game_ACScriptInterpreter_SuspendScript(int scriptNumber, Uri const *mapUri);
-
-void Game_ACScriptInterpreter_RunDeferredTasks(Uri const *mapUri);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif // LIBHEXEN_PLAY_ACSCRIPT_H
diff --git a/doomsday/plugins/hexen/include/intermission.h b/doomsday/plugins/hexen/include/intermission.h
index 941b2831d0..b9630ed0b5 100644
--- a/doomsday/plugins/hexen/include/intermission.h
+++ b/doomsday/plugins/hexen/include/intermission.h
@@ -19,17 +19,16 @@
 
 #ifndef LIBHEXEN_INTERMISSION_H
 #define LIBHEXEN_INTERMISSION_H
-#ifdef __cplusplus
 
-#ifndef __JHEXEN__
-#  error "Using jHexen headers without __JHEXEN__"
-#endif
+#include "jhexen.h"
+#include <doomsday/uri.h>
 
-#include "h2def.h"
+struct wbstartstruct_t;
+
+#ifdef __cplusplus
 
 struct wbstartstruct_t
 {
-    //de::Uri currentMap;
     de::Uri nextMap;
     uint nextMapEntryPoint;
 };
@@ -44,6 +43,9 @@ struct wbstartstruct_t
  */
 void IN_Begin(wbstartstruct_t const &wbstartstruct);
 
+extern "C" {
+#endif
+
 /**
  * End the current intermission.
  */
@@ -76,5 +78,8 @@ void IN_SkipToNext();
 /// To be called to register the console commands and variables of this module.
 void IN_ConsoleRegister();
 
-#endif // __cplusplus
-#endif // LIBHEXEN_INTERMISSION_H
+#ifdef __cplusplus
+} // extern "C
+#endif
+
+#endif  // LIBHEXEN_INTERMISSION_H
diff --git a/doomsday/plugins/hexen/include/jhexen.h b/doomsday/plugins/hexen/include/jhexen.h
index 4cd2834d2f..b9148837b8 100644
--- a/doomsday/plugins/hexen/include/jhexen.h
+++ b/doomsday/plugins/hexen/include/jhexen.h
@@ -35,7 +35,6 @@
 #include "../../hexen/include/x_api.h"
 #include "../../hexen/include/a_action.h"
 #include "../../hexen/include/acfnlink.h"
-#include "../../hexen/include/acscript.h"
 #include "../../hexen/include/g_game.h"
 #include "../../hexen/include/intermission.h"
 #include "../../hexen/include/m_cheat.h"
diff --git a/doomsday/plugins/hexen/include/p_mobj.h b/doomsday/plugins/hexen/include/p_mobj.h
index 09942823f7..2422a99201 100644
--- a/doomsday/plugins/hexen/include/p_mobj.h
+++ b/doomsday/plugins/hexen/include/p_mobj.h
@@ -35,9 +35,10 @@
 
 #include "doomsday.h"
 #include "p_terraintype.h"
+
 #ifdef __cplusplus
-#  include "mapstatereader.h"
-#  include "mapstatewriter.h"
+class MapStateReader;
+class MapStateWriter;
 #endif
 
 #define NOMOM_THRESHOLD     (0.0001) // (integer) 0
diff --git a/doomsday/plugins/hexen/include/p_spec.h b/doomsday/plugins/hexen/include/p_spec.h
index 01380e9b22..d9f7a8ad0e 100644
--- a/doomsday/plugins/hexen/include/p_spec.h
+++ b/doomsday/plugins/hexen/include/p_spec.h
@@ -42,8 +42,6 @@ void P_SpawnSectorSpecialThinkers(void);
 void P_SpawnLineSpecialThinkers(void);
 void P_SpawnAllSpecialThinkers(void);
 
-dd_bool P_SectorTagIsBusy(int tag);
-
 dd_bool P_ExecuteLineSpecial(int special, byte args[5], Line *line, int side, mobj_t *mo);
 
 dd_bool P_ActivateLine(Line *ld, mobj_t *mo, int side, int activationType);
diff --git a/doomsday/plugins/hexen/src/a_action.c b/doomsday/plugins/hexen/src/a_action.c
index 263e6d75a1..7df625acd5 100644
--- a/doomsday/plugins/hexen/src/a_action.c
+++ b/doomsday/plugins/hexen/src/a_action.c
@@ -19,13 +19,13 @@
  * 02110-1301 USA</small>
  */
 
-#include <string.h>
-#include <math.h>
-
 #include "jhexen.h"
 
-#include "p_map.h"
+#include <string.h>
+#include <math.h>
+#include "g_common.h"
 #include "mobj.h"
+#include "p_map.h"
 
 #define TELEPORT_LIFE           (1)
 
diff --git a/doomsday/plugins/hexen/src/acscript.cpp b/doomsday/plugins/hexen/src/acscript.cpp
deleted file mode 100644
index d5c2e76764..0000000000
--- a/doomsday/plugins/hexen/src/acscript.cpp
+++ /dev/null
@@ -1,1915 +0,0 @@
-/** @file acscript.cpp  Hexen "ACS" scripting system.
- *
- * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
- * @authors Copyright © 1999 Activision
- *
- * @par License
- * GPL: http://www.gnu.org/licenses/gpl.html
- *
- * <small>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 St, Fifth Floor, Boston, MA
- * 02110-1301 USA</small>
- */
-
-#include "jhexen.h"
-#include "acscript.h"
-
-#include "dmu_lib.h"
-#include "g_common.h"
-#include "gamesession.h"
-#include "player.h"
-#include "p_map.h"
-#include "p_saveg.h"
-#include "p_saveio.h"
-#include "p_sound.h"
-#include <cstring>
-#include <cstdio>
-
-/**
- * Bytecode header. Read directly from the map lump.
- */
-#pragma pack(1)
-struct BytecodeHeader
-{
-    int32_t marker;
-    int32_t infoOffset;
-    int32_t code;
-};
-#pragma pack()
-
-/**
- * Stores information about a script function entrypoint.
- */
-struct BytecodeScriptInfo
-{
-    enum Flag {
-        Open = 0x1
-    };
-
-    int flags;
-    int scriptNumber;
-    int const *pcodePtr;
-    int argCount;
-
-    // Current state:
-    /// @todo Move to a separate array, in ACScriptInterpreter
-    ACScriptInterpreter::ScriptState state;
-    int waitValue;
-};
-
-ACScriptInterpreter::DeferredTask::DeferredTask()
-    : scriptNumber(-1)
-{
-    de::zap(args);
-}
-
-ACScriptInterpreter::DeferredTask::DeferredTask(de::Uri const &mapUri, int scriptNumber, byte const args_[])
-    : mapUri      (mapUri)
-    , scriptNumber(scriptNumber)
-{
-    std::memcpy(args, args_, sizeof(args));
-}
-
-ACScriptInterpreter::DeferredTask *ACScriptInterpreter::DeferredTask::newFromReader(de::Reader &from) //static
-{
-    std::unique_ptr<DeferredTask> task(new DeferredTask);
-    from >> *task;
-    return task.release();
-}
-
-void ACScriptInterpreter::DeferredTask::operator >> (de::Writer &to) const
-{
-    to << mapUri.compose()
-       << scriptNumber;
-    for(int i = 0; i < 4; ++i)
-    {
-        to << args[i];
-    }
-}
-
-void ACScriptInterpreter::DeferredTask::operator << (de::Reader &from)
-{
-    de::String mapUriStr;
-    from >> mapUriStr;
-    mapUri = de::Uri(mapUriStr, RC_NULL);
-    mapUri.setScheme("Maps");
-    from >> scriptNumber;
-    for(int i = 0; i < 4; ++i)
-    {
-        from >> args[i];
-    }
-}
-
-int ACScriptInterpreter::scriptInfoIndex(int scriptNumber)
-{
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-        if(info.scriptNumber == scriptNumber)
-        {
-            return i;
-        }
-    }
-    return -1;
-}
-
-ACScript *ACScriptInterpreter::newACScript(BytecodeScriptInfo &info, byte const args[], int delayCount)
-{
-    // Is the script is already executing?
-    if(info.state != Inactive) return 0;
-
-    ACScript *script = (ACScript *) Z_Calloc(sizeof(*script), PU_MAP, 0);
-    script->thinker.function = (thinkfunc_t) ACScript_Thinker;
-
-    script->_info      = &info;
-    script->pcodePtr   = info.pcodePtr;
-    script->delayCount = delayCount;
-
-    for(int i = 0; i < info.argCount; ++i)
-    {
-        DENG2_ASSERT(args != 0);
-        script->vars[i] = args[i];
-    }
-
-    Thinker_Add(&script->thinker);
-
-    info.state = Running;
-
-    return script;
-}
-
-bool ACScriptInterpreter::newDeferredTask(de::Uri const &mapUri, int scriptNumber, byte const args[])
-{
-    // Don't allow duplicates.
-    for(int i = 0; i < _deferredTasksSize; ++i)
-    {
-        DeferredTask &task = *_deferredTasks[i];
-        if(task.scriptNumber == scriptNumber && task.mapUri == mapUri)
-        {
-            return false;
-        }
-    }
-
-    _deferredTasks = (DeferredTask **) Z_Realloc(_deferredTasks, sizeof(*_deferredTasks) * ++_deferredTasksSize, PU_GAMESTATIC);
-    _deferredTasks[_deferredTasksSize - 1] = new DeferredTask(mapUri, scriptNumber, args);
-    return true;
-}
-
-ACScriptInterpreter::ACScriptInterpreter()
-    : _pcode(0)
-    , _scriptCount(0)
-    , _scriptInfo(0)
-    , _stringCount(0)
-    , _strings(0)
-    , _deferredTasksSize(0)
-    , _deferredTasks(0)
-{}
-
-void ACScriptInterpreter::loadBytecode(de::File1 &lump)
-{
-#define OPEN_SCRIPTS_BASE 1000
-
-    DENG2_ASSERT(!IS_CLIENT);
-
-    App_Log(DE2_SCR_VERBOSE, "Loading ACS bytecode lump %s:%s...",
-            F_PrettyPath(lump.container().composePath().toUtf8().constData()),
-            lump.name().toUtf8().constData());
-
-    _scriptCount = 0;
-
-    int const *readBuf = 0;
-    if(lump.size() >= sizeof(BytecodeHeader))
-    {
-        void *region = Z_Malloc(lump.size(), PU_MAP, 0);
-        lump.read((uint8_t *)region);
-        BytecodeHeader const *header = (BytecodeHeader const *) region;
-        _pcode = (byte const *) header;
-
-        if(LONG(header->infoOffset) < (int)lump.size())
-        {
-            readBuf = (int *) ((byte const *) header + LONG(header->infoOffset));
-            _scriptCount = LONG(*readBuf++);
-        }
-    }
-
-    if(!_scriptCount)
-    {
-        // Empty/Invalid lump.
-        App_Log(DE2_SCR_WARNING, "Lump %s:%s does not appear to be valid ACS bytecode data",
-                F_PrettyPath(lump.container().composePath().toUtf8().constData()),
-                lump.name().toUtf8().constData());
-        return;
-    }
-
-    _scriptInfo = (BytecodeScriptInfo *) Z_Calloc(_scriptCount * sizeof(*_scriptInfo), PU_MAP, 0);
-
-    BytecodeScriptInfo *info = _scriptInfo;
-    for(int i = 0; i < _scriptCount; ++i, info++)
-    {
-        info->scriptNumber = LONG(*readBuf++);
-        info->pcodePtr     = (int const *)(_pcode + LONG(*readBuf++));
-        info->argCount     = LONG(*readBuf++);
-        info->state        = Inactive;
-
-        if(info->scriptNumber >= OPEN_SCRIPTS_BASE)
-        {
-            info->flags |= BytecodeScriptInfo::Open;
-            info->scriptNumber -= OPEN_SCRIPTS_BASE;
-        }
-
-        DENG2_ASSERT(info->argCount <= MAX_ACS_SCRIPT_VARS);
-    }
-
-    _stringCount = LONG(*readBuf++);
-    _strings = (Str *) Z_Malloc(_stringCount * sizeof(*_strings), PU_MAP, 0);
-    for(int i = 0; i < _stringCount; ++i)
-    {
-        Str_InitStatic(&_strings[i], (char const *)(_pcode + LONG(*readBuf++)));
-    }
-
-#undef OPEN_SCRIPTS_BASE
-}
-
-void ACScriptInterpreter::reset()
-{
-    de::zap(worldVars);
-    clearDeferredTasks();
-}
-
-int ACScriptInterpreter::scriptCount() const
-{
-    return _scriptCount;
-}
-
-void ACScriptInterpreter::startOpenScripts()
-{
-    DENG2_ASSERT(!IS_CLIENT);
-
-    // Each is allotted 1 second for initialization.
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-
-        if(info.flags & BytecodeScriptInfo::Open)
-        {
-            ACScript *script = newACScript(info, 0/*no args*/, TICSPERSEC);
-            DENG2_ASSERT(script != 0);
-            DENG2_UNUSED(script);
-        }
-    }
-}
-
-bool ACScriptInterpreter::startScript(int scriptNumber, de::Uri const *mapUri,
-    byte const args[], mobj_t *activator, Line *line, int side)
-{
-    DENG2_ASSERT(!IS_CLIENT);
-
-    if(mapUri)
-    {
-        if(COMMON_GAMESESSION->mapUri() != *mapUri)
-        {
-            // Script is not for the current map.
-            // Add it to the store to be started when that map is next entered.
-            return newDeferredTask(*mapUri, scriptNumber, args);
-        }
-    }
-
-    if(BytecodeScriptInfo *info = scriptInfoPtr(scriptNumber))
-    {
-        // Resume a suspended script?
-        if(info->state == Suspended)
-        {
-            info->state = Running;
-            return true;
-        }
-        else if(ACScript *script = newACScript(*info, args))
-        {
-            script->activator = activator;
-            script->line      = line;
-            script->side      = side;
-            return true;
-        }
-    }
-    else
-    {
-        // Script not found.
-        App_Log(DE2_SCR_WARNING, "ACS: Unknown script #%i", scriptNumber);
-    }
-
-    return false; // Perhaps its already executing?
-}
-
-bool ACScriptInterpreter::suspendScript(int scriptNumber, de::Uri const * /*mapUri*/)
-{
-    if(BytecodeScriptInfo *info = scriptInfoPtr(scriptNumber))
-    {
-        // Some states disallow suspension.
-        if(info->state != Inactive && info->state != Suspended &&
-           info->state != Terminating)
-        {
-            info->state = Suspended;
-            return true;
-        }
-    }
-    return false;
-}
-
-bool ACScriptInterpreter::terminateScript(int scriptNumber, de::Uri const * /*mapUri*/)
-{
-    if(BytecodeScriptInfo *info = scriptInfoPtr(scriptNumber))
-    {
-        // Some states disallow termination.
-        if(info->state != Inactive && info->state != Terminating)
-        {
-            info->state = Terminating;
-            return true;
-        }
-    }
-    return false;
-}
-
-void ACScriptInterpreter::tagFinished(int tag)
-{
-    if(P_SectorTagIsBusy(tag)) return;
-
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-        if(info.state == WaitingForTag && info.waitValue == tag)
-        {
-            info.state = Running;
-        }
-    }
-}
-
-void ACScriptInterpreter::polyobjFinished(int tag)
-{
-    if(P_SectorTagIsBusy(tag)) return;
-
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-        if(info.state == WaitingForPolyobj && info.waitValue == tag)
-        {
-            info.state = Running;
-        }
-    }
-}
-
-bool ACScriptInterpreter::hasScriptEntrypoint(int scriptNumber)
-{
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-        if(info.scriptNumber == scriptNumber)
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-BytecodeScriptInfo &ACScriptInterpreter::scriptInfo(int scriptNumber)
-{
-    return _scriptInfo[scriptInfoIndex(scriptNumber)];
-}
-
-Str const *ACScriptInterpreter::string(int stringNumber) const
-{
-    DENG2_ASSERT(stringNumber >= 0 && stringNumber < _stringCount);
-    return &_strings[stringNumber];
-}
-
-byte const *ACScriptInterpreter::bytecode() const
-{
-    return _pcode;
-}
-
-void ACScriptInterpreter::clearDeferredTasks()
-{
-    for(int i = 0; i < _deferredTasksSize; ++i)
-    {
-        delete _deferredTasks[i];
-    }
-    Z_Free(_deferredTasks); _deferredTasks = 0;
-    _deferredTasksSize = 0;
-}
-
-void ACScriptInterpreter::runDeferredTasks(de::Uri const &mapUri)
-{
-    if(COMMON_GAMESESSION->rules().deathmatch)
-    {
-        /// @todo Do we really want to disallow deferred ACS tasks in deathmatch?
-        /// What is the actual intention here? -ds
-        return;
-    }
-
-    int const origSize = _deferredTasksSize;
-
-    int i = 0;
-    while(i < _deferredTasksSize)
-    {
-        DeferredTask *task = _deferredTasks[i];
-        int scriptNumber = task->scriptNumber;
-
-        if(task->mapUri != mapUri)
-        {
-            i++;
-            continue;
-        }
-
-        if(BytecodeScriptInfo *info = scriptInfoPtr(scriptNumber))
-        {
-            // Resume a suspended script?
-            if(info->state == Suspended)
-            {
-                info->state = Running;
-            }
-            else
-            {
-                newACScript(*info, task->args, TICSPERSEC);
-            }
-        }
-        else
-        {
-            App_Log(DE2_SCR_WARNING, "ACS: Unknown script #%i", scriptNumber);
-        }
-
-        delete _deferredTasks[i];
-
-        _deferredTasksSize -= 1;
-        if(i == _deferredTasksSize)
-            break;
-
-        std::memmove(&_deferredTasks[i], &_deferredTasks[i + 1], sizeof(*_deferredTasks) * (_deferredTasksSize - i));
-    }
-
-    if(_deferredTasksSize < origSize)
-    {
-        if(_deferredTasksSize)
-        {
-            _deferredTasks = (DeferredTask **) Z_Realloc(_deferredTasks, sizeof(*_deferredTasks) * _deferredTasksSize, PU_GAMESTATIC);
-        }
-        else
-        {
-            Z_Free(_deferredTasks);
-            _deferredTasks = 0;
-        }
-    }
-}
-
-void ACScriptInterpreter::scriptFinished(ACScript *script)
-{
-    if(!script) return;
-
-    // This script has now finished.
-    script->info().state = Inactive;
-
-    // Notify any scripts which are waiting for this script to finish.
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-        if(info.state == WaitingForScript && info.waitValue == script->info().scriptNumber)
-        {
-            info.state = Running;
-        }
-    }
-
-    Thinker_Remove(&script->thinker);
-}
-
-de::Block ACScriptInterpreter::serializeWorldState() const
-{
-    de::Block data;
-    de::Writer writer(data);
-
-    // Write the world-global variable namespace.
-    for(int i = 0; i < MAX_ACS_WORLD_VARS; ++i)
-    {
-        writer << worldVars[i];
-    }
-
-    // Write the deferred task queue.
-    writer << _deferredTasksSize;
-    for(int i = 0; i < _deferredTasksSize; ++i)
-    {
-        writer << *_deferredTasks[i];
-    }
-
-    return data;
-}
-
-void ACScriptInterpreter::readWorldState(de::Reader &from)
-{
-    // Read the world-global variable namespace.
-    for(int i = 0; i < MAX_ACS_WORLD_VARS; ++i)
-    {
-        from >> worldVars[i];
-    }
-
-    // Read the deferred task queue.
-    clearDeferredTasks();
-    from >> _deferredTasksSize;
-    if(_deferredTasksSize)
-    {
-        _deferredTasks = (DeferredTask **) Z_Realloc(_deferredTasks, sizeof(*_deferredTasks) * _deferredTasksSize, PU_GAMESTATIC);
-        for(int i = 0; i < _deferredTasksSize; ++i)
-        {
-            _deferredTasks[i] = DeferredTask::newFromReader(from);
-        }
-    }
-}
-
-void ACScriptInterpreter::writeMapState(MapStateWriter *msw)
-{
-    Writer *writer = msw->writer();
-
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-        Writer_WriteInt16(writer, info.state);
-        Writer_WriteInt16(writer, info.waitValue);
-    }
-
-    for(int i = 0; i < MAX_ACS_MAP_VARS; ++i)
-    {
-        Writer_WriteInt32(writer, mapVars[i]);
-    }
-}
-
-void ACScriptInterpreter::readMapState(MapStateReader *msr)
-{
-    Reader *reader = msr->reader();
-
-    for(int i = 0; i < _scriptCount; ++i)
-    {
-        BytecodeScriptInfo &info = _scriptInfo[i];
-
-        info.state     = ScriptState( Reader_ReadInt16(reader) );
-        info.waitValue = Reader_ReadInt16(reader);
-    }
-
-    for(int i = 0; i < MAX_ACS_MAP_VARS; ++i)
-    {
-        mapVars[i] = Reader_ReadInt32(reader);
-    }
-}
-
-BytecodeScriptInfo &ACScriptInterpreter::scriptInfoByIndex(int index)
-{
-    DENG_ASSERT(index >= 0 && index < _scriptCount);
-    return _scriptInfo[index];
-}
-
-AutoStr *ACScriptInterpreter::scriptName(int scriptNumber)
-{
-    BytecodeScriptInfo *info = scriptInfoPtr(scriptNumber);
-    if(!info)
-    {
-        return AutoStr_FromTextStd("(invalid-scriptnumber)");
-    }
-    bool const open = (info->flags & BytecodeScriptInfo::Open) != 0;
-    return Str_Appendf(AutoStr_NewStd(), "#%i%s", scriptNumber, open? " (Open)" : "");
-}
-
-AutoStr *ACScriptInterpreter::scriptDescription(int scriptNumber)
-{
-    BytecodeScriptInfo *info = scriptInfoPtr(scriptNumber);
-    if(!info)
-    {
-        return AutoStr_FromTextStd("(invalid-scriptnumber)");
-    }
-
-    static char const *stateLabels[] = {
-        "Inactive",
-        "Running",
-        "Suspended",
-        "Waiting for tag",
-        "Waiting for polyobj",
-        "Waiting for script",
-        "Terminating"
-    };
-
-    return Str_Appendf(AutoStr_NewStd(), "ACScript " DE2_ESC(b) "%s\n"
-                                         DE2_ESC(l) "State: " DE2_ESC(.) DE2_ESC(i) "%s" DE2_ESC(.)
-                                         DE2_ESC(l) " Wait-for: " DE2_ESC(.) DE2_ESC(i) "%i",
-                                         Str_Text(scriptName(scriptNumber)),
-                                         stateLabels[info->state], info->waitValue);
-}
-
-static byte SpecArgs[5];
-
-#define PRINT_BUFFER_SIZE 256
-static char PrintBuffer[PRINT_BUFFER_SIZE];
-
-/// Bytecode command return value.
-enum CommandResult
-{
-    Continue,
-    Stop,
-    Terminate
-};
-
-typedef CommandResult (*CommandFunc) (ACScript &acs);
-
-/// Helper macro for declaring an ACS command function.
-#define ACS_COMMAND(Name) CommandResult cmd##Name(ACScript &acs)
-
-ACS_COMMAND(NOP)
-{
-    DENG_UNUSED(acs);
-    return Continue;
-}
-
-ACS_COMMAND(Terminate)
-{
-    DENG_UNUSED(acs);
-    return Terminate;
-}
-
-ACS_COMMAND(Suspend)
-{
-    acs.info().state = ACScriptInterpreter::Suspended;
-    return Stop;
-}
-
-ACS_COMMAND(PushNumber)
-{
-    acs.locals.push(LONG(*acs.pcodePtr++));
-    return Continue;
-}
-
-ACS_COMMAND(LSpec1)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[0] = acs.locals.pop();
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side, acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec2)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[1] = acs.locals.pop();
-    SpecArgs[0] = acs.locals.pop();
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side, acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec3)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[2] = acs.locals.pop();
-    SpecArgs[1] = acs.locals.pop();
-    SpecArgs[0] = acs.locals.pop();
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side, acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec4)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[3] = acs.locals.pop();
-    SpecArgs[2] = acs.locals.pop();
-    SpecArgs[1] = acs.locals.pop();
-    SpecArgs[0] = acs.locals.pop();
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side, acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec5)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[4] = acs.locals.pop();
-    SpecArgs[3] = acs.locals.pop();
-    SpecArgs[2] = acs.locals.pop();
-    SpecArgs[1] = acs.locals.pop();
-    SpecArgs[0] = acs.locals.pop();
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side,
-                         acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec1Direct)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[0] = LONG(*acs.pcodePtr++);
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side,
-                         acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec2Direct)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[0] = LONG(*acs.pcodePtr++);
-    SpecArgs[1] = LONG(*acs.pcodePtr++);
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side,
-                         acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec3Direct)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[0] = LONG(*acs.pcodePtr++);
-    SpecArgs[1] = LONG(*acs.pcodePtr++);
-    SpecArgs[2] = LONG(*acs.pcodePtr++);
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side,
-                         acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec4Direct)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[0] = LONG(*acs.pcodePtr++);
-    SpecArgs[1] = LONG(*acs.pcodePtr++);
-    SpecArgs[2] = LONG(*acs.pcodePtr++);
-    SpecArgs[3] = LONG(*acs.pcodePtr++);
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side,
-                         acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(LSpec5Direct)
-{
-    int special = LONG(*acs.pcodePtr++);
-    SpecArgs[0] = LONG(*acs.pcodePtr++);
-    SpecArgs[1] = LONG(*acs.pcodePtr++);
-    SpecArgs[2] = LONG(*acs.pcodePtr++);
-    SpecArgs[3] = LONG(*acs.pcodePtr++);
-    SpecArgs[4] = LONG(*acs.pcodePtr++);
-    P_ExecuteLineSpecial(special, SpecArgs, acs.line, acs.side,
-                         acs.activator);
-
-    return Continue;
-}
-
-ACS_COMMAND(Add)
-{
-    acs.locals.push(acs.locals.pop() + acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(Subtract)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() - operand2);
-    return Continue;
-}
-
-ACS_COMMAND(Multiply)
-{
-    acs.locals.push(acs.locals.pop() * acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(Divide)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() / operand2);
-    return Continue;
-}
-
-ACS_COMMAND(Modulus)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() % operand2);
-    return Continue;
-}
-
-ACS_COMMAND(EQ)
-{
-    acs.locals.push(acs.locals.pop() == acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(NE)
-{
-    acs.locals.push(acs.locals.pop() != acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(LT)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() < operand2);
-    return Continue;
-}
-
-ACS_COMMAND(GT)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() > operand2);
-    return Continue;
-}
-
-ACS_COMMAND(LE)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() <= operand2);
-    return Continue;
-}
-
-ACS_COMMAND(GE)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() >= operand2);
-    return Continue;
-}
-
-ACS_COMMAND(AssignScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)] = acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(AssignMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)] = acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(AssignWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)] = acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(PushScriptVar)
-{
-    acs.locals.push(acs.vars[LONG(*acs.pcodePtr++)]);
-    return Continue;
-}
-
-ACS_COMMAND(PushMapVar)
-{
-    acs.locals.push(acs.interpreter().mapVars[LONG(*acs.pcodePtr++)]);
-    return Continue;
-}
-
-ACS_COMMAND(PushWorldVar)
-{
-    acs.locals.push(acs.interpreter().worldVars[LONG(*acs.pcodePtr++)]);
-    return Continue;
-}
-
-ACS_COMMAND(AddScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)] += acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(AddMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)] += acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(AddWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)] += acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(SubScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)] -= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(SubMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)] -= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(SubWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)] -= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(MulScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)] *= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(MulMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)] *= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(MulWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)] *= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(DivScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)] /= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(DivMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)] /= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(DivWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)] /= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(ModScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)] %= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(ModMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)] %= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(ModWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)] %= acs.locals.pop();
-    return Continue;
-}
-
-ACS_COMMAND(IncScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)]++;
-    return Continue;
-}
-
-ACS_COMMAND(IncMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)]++;
-    return Continue;
-}
-
-ACS_COMMAND(IncWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)]++;
-    return Continue;
-}
-
-ACS_COMMAND(DecScriptVar)
-{
-    acs.vars[LONG(*acs.pcodePtr++)]--;
-    return Continue;
-}
-
-ACS_COMMAND(DecMapVar)
-{
-    acs.interpreter().mapVars[LONG(*acs.pcodePtr++)]--;
-    return Continue;
-}
-
-ACS_COMMAND(DecWorldVar)
-{
-    acs.interpreter().worldVars[LONG(*acs.pcodePtr++)]--;
-    return Continue;
-}
-
-ACS_COMMAND(Goto)
-{
-    acs.pcodePtr = (int *) (acs.interpreter().bytecode() + LONG(*acs.pcodePtr));
-    return Continue;
-}
-
-ACS_COMMAND(IfGoto)
-{
-    if(acs.locals.pop())
-    {
-        acs.pcodePtr = (int *) (acs.interpreter().bytecode() + LONG(*acs.pcodePtr));
-    }
-    else
-    {
-        acs.pcodePtr++;
-    }
-    return Continue;
-}
-
-ACS_COMMAND(Drop)
-{
-    acs.locals.drop();
-    return Continue;
-}
-
-ACS_COMMAND(Delay)
-{
-    acs.delayCount = acs.locals.pop();
-    return Stop;
-}
-
-ACS_COMMAND(DelayDirect)
-{
-    acs.delayCount = LONG(*acs.pcodePtr++);
-    return Stop;
-}
-
-ACS_COMMAND(Random)
-{
-    int high = acs.locals.pop();
-    int low  = acs.locals.pop();
-    acs.locals.push(low + (P_Random() % (high - low + 1)));
-    return Continue;
-}
-
-ACS_COMMAND(RandomDirect)
-{
-    int low  = LONG(*acs.pcodePtr++);
-    int high = LONG(*acs.pcodePtr++);
-    acs.locals.push(low + (P_Random() % (high - low + 1)));
-    return Continue;
-}
-
-ACS_COMMAND(ThingCount)
-{
-    int tid  = acs.locals.pop();
-    int type = acs.locals.pop();
-    // Anything to count?
-    if(type + tid)
-    {
-        acs.locals.push(P_MobjCount(type, tid));
-    }
-    return Continue;
-}
-
-ACS_COMMAND(ThingCountDirect)
-{
-    int type = LONG(*acs.pcodePtr++);
-    int tid  = LONG(*acs.pcodePtr++);
-    // Anything to count?
-    if(type + tid)
-    {
-        acs.locals.push(P_MobjCount(type, tid));
-    }
-    return Continue;
-}
-
-ACS_COMMAND(TagWait)
-{
-    acs.info().waitValue = acs.locals.pop();
-    acs.info().state = ACScriptInterpreter::WaitingForTag;
-    return Stop;
-}
-
-ACS_COMMAND(TagWaitDirect)
-{
-    acs.info().waitValue = LONG(*acs.pcodePtr++);
-    acs.info().state = ACScriptInterpreter::WaitingForTag;
-    return Stop;
-}
-
-ACS_COMMAND(PolyWait)
-{
-    acs.info().waitValue = acs.locals.pop();
-    acs.info().state = ACScriptInterpreter::WaitingForPolyobj;
-    return Stop;
-}
-
-ACS_COMMAND(PolyWaitDirect)
-{
-    acs.info().waitValue = LONG(*acs.pcodePtr++);
-    acs.info().state = ACScriptInterpreter::WaitingForPolyobj;
-    return Stop;
-}
-
-ACS_COMMAND(ChangeFloor)
-{
-    AutoStr *path = Str_PercentEncode(Str_Copy(AutoStr_New(), acs.interpreter().string(acs.locals.pop())));
-    Uri *uri = Uri_NewWithPath3("Flats", Str_Text(path));
-
-    Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
-    Uri_Delete(uri);
-
-    int tag = acs.locals.pop();
-
-    if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Sector *sec;
-        while((sec = (Sector *) IterList_MoveIterator(list)))
-        {
-            P_SetPtrp(sec, DMU_FLOOR_MATERIAL, mat);
-        }
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(ChangeFloorDirect)
-{
-    int tag = LONG(*acs.pcodePtr++);
-
-    AutoStr *path = Str_PercentEncode(Str_Copy(AutoStr_New(), acs.interpreter().string(LONG(*acs.pcodePtr++))));
-    Uri *uri = Uri_NewWithPath3("Flats", Str_Text(path));
-
-    Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
-    Uri_Delete(uri);
-
-    if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Sector *sec;
-        while((sec = (Sector *) IterList_MoveIterator(list)))
-        {
-            P_SetPtrp(sec, DMU_FLOOR_MATERIAL, mat);
-        }
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(ChangeCeiling)
-{
-    AutoStr *path = Str_PercentEncode(Str_Copy(AutoStr_New(), acs.interpreter().string(acs.locals.pop())));
-    Uri *uri = Uri_NewWithPath3("Flats", Str_Text(path));
-
-    Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
-    Uri_Delete(uri);
-
-    int tag = acs.locals.pop();
-
-    if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Sector *sec;
-        while((sec = (Sector *) IterList_MoveIterator(list)))
-        {
-            P_SetPtrp(sec, DMU_CEILING_MATERIAL, mat);
-        }
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(ChangeCeilingDirect)
-{
-    int tag = LONG(*acs.pcodePtr++);
-
-    AutoStr *path = Str_PercentEncode(Str_Copy(AutoStr_New(), acs.interpreter().string(LONG(*acs.pcodePtr++))));
-    Uri *uri = Uri_NewWithPath3("Flats", Str_Text(path));
-
-    Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
-    Uri_Delete(uri);
-
-    if(iterlist_t *list = P_GetSectorIterListForTag(tag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Sector *sec;
-        while((sec = (Sector *) IterList_MoveIterator(list)))
-        {
-            P_SetPtrp(sec, DMU_CEILING_MATERIAL, mat);
-        }
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(Restart)
-{
-    acs.pcodePtr = acs.info().pcodePtr;
-    return Continue;
-}
-
-ACS_COMMAND(AndLogical)
-{
-    acs.locals.push(acs.locals.pop() && acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(OrLogical)
-{
-    acs.locals.push(acs.locals.pop() || acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(AndBitwise)
-{
-    acs.locals.push(acs.locals.pop() & acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(OrBitwise)
-{
-    acs.locals.push(acs.locals.pop() | acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(EorBitwise)
-{
-    acs.locals.push(acs.locals.pop() ^ acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(NegateLogical)
-{
-    acs.locals.push(!acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(LShift)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() << operand2);
-    return Continue;
-}
-
-ACS_COMMAND(RShift)
-{
-    int operand2 = acs.locals.pop();
-    acs.locals.push(acs.locals.pop() >> operand2);
-    return Continue;
-}
-
-ACS_COMMAND(UnaryMinus)
-{
-    acs.locals.push(-acs.locals.pop());
-    return Continue;
-}
-
-ACS_COMMAND(IfNotGoto)
-{
-    if(acs.locals.pop())
-    {
-        acs.pcodePtr++;
-    }
-    else
-    {
-        acs.pcodePtr = (int *) (acs.interpreter().bytecode() + LONG(*acs.pcodePtr));
-    }
-    return Continue;
-}
-
-ACS_COMMAND(LineSide)
-{
-    acs.locals.push(acs.side);
-    return Continue;
-}
-
-ACS_COMMAND(ScriptWait)
-{
-    acs.info().waitValue = acs.locals.pop();
-    acs.info().state = ACScriptInterpreter::WaitingForScript;
-    return Stop;
-}
-
-ACS_COMMAND(ScriptWaitDirect)
-{
-    acs.info().waitValue = LONG(*acs.pcodePtr++);
-    acs.info().state = ACScriptInterpreter::WaitingForScript;
-    return Stop;
-}
-
-ACS_COMMAND(ClearLineSpecial)
-{
-    if(acs.line)
-    {
-        P_ToXLine(acs.line)->special = 0;
-    }
-    return Continue;
-}
-
-ACS_COMMAND(CaseGoto)
-{
-    if(acs.locals.top() == LONG(*acs.pcodePtr++))
-    {
-        acs.pcodePtr = (int *) (acs.interpreter().bytecode() + LONG(*acs.pcodePtr));
-        acs.locals.drop();
-    }
-    else
-    {
-        acs.pcodePtr++;
-    }
-    return Continue;
-}
-
-ACS_COMMAND(BeginPrint)
-{
-    DENG_UNUSED(acs);
-    *PrintBuffer = 0;
-    return Continue;
-}
-
-ACS_COMMAND(EndPrint)
-{
-    if(acs.activator && acs.activator->player)
-    {
-        P_SetMessage(acs.activator->player, 0, PrintBuffer);
-    }
-    else
-    {
-        // Send to everybody.
-        for(int i = 0; i < MAXPLAYERS; ++i)
-        {
-            if(players[i].plr->inGame)
-            {
-                P_SetMessage(&players[i], 0, PrintBuffer);
-            }
-        }
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(EndPrintBold)
-{
-    DENG_UNUSED(acs);
-    for(int i = 0; i < MAXPLAYERS; ++i)
-    {
-        if(players[i].plr->inGame)
-        {
-            P_SetYellowMessage(&players[i], 0, PrintBuffer);
-        }
-    }
-    return Continue;
-}
-
-ACS_COMMAND(PrintString)
-{
-    strcat(PrintBuffer, Str_Text(acs.interpreter().string(acs.locals.pop())));
-    return Continue;
-}
-
-ACS_COMMAND(PrintNumber)
-{
-    char tempStr[16];
-    sprintf(tempStr, "%d", acs.locals.pop());
-    strcat(PrintBuffer, tempStr);
-    return Continue;
-}
-
-ACS_COMMAND(PrintCharacter)
-{
-    char *bufferEnd = PrintBuffer + strlen(PrintBuffer);
-    *bufferEnd++ = acs.locals.pop();
-    *bufferEnd = 0;
-    return Continue;
-}
-
-ACS_COMMAND(PlayerCount)
-{
-    int count = 0;
-    for(int i = 0; i < MAXPLAYERS; ++i)
-    {
-        count += players[i].plr->inGame;
-    }
-    acs.locals.push(count);
-    return Continue;
-}
-
-ACS_COMMAND(GameType)
-{
-    int gametype;
-
-    if(!IS_NETGAME)
-    {
-        gametype = 0; // singleplayer
-    }
-    else if(COMMON_GAMESESSION->rules().deathmatch)
-    {
-        gametype = 2; // deathmatch
-    }
-    else
-    {
-        gametype = 1; // cooperative
-    }
-    acs.locals.push(gametype);
-
-    return Continue;
-}
-
-ACS_COMMAND(GameSkill)
-{
-    acs.locals.push((int)COMMON_GAMESESSION->rules().skill);
-    return Continue;
-}
-
-ACS_COMMAND(Timer)
-{
-    acs.locals.push(mapTime);
-    return Continue;
-}
-
-ACS_COMMAND(SectorSound)
-{
-    mobj_t *mobj = 0;
-    if(acs.line)
-    {
-        Sector *front = (Sector *) P_GetPtrp(acs.line, DMU_FRONT_SECTOR);
-        mobj = (mobj_t *) P_GetPtrp(front, DMU_EMITTER);
-    }
-    int volume = acs.locals.pop();
-
-    S_StartSoundAtVolume(S_GetSoundID(Str_Text(acs.interpreter().string(acs.locals.pop()))), mobj, volume / 127.0f);
-    return Continue;
-}
-
-ACS_COMMAND(ThingSound)
-{
-    int volume   = acs.locals.pop();
-    int sound    = S_GetSoundID(Str_Text(acs.interpreter().string(acs.locals.pop())));
-    int tid      = acs.locals.pop();
-    int searcher = -1;
-
-    mobj_t *mobj;
-    while(sound && (mobj = P_FindMobjFromTID(tid, &searcher)))
-    {
-        S_StartSoundAtVolume(sound, mobj, volume / 127.0f);
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(AmbientSound)
-{
-    mobj_t *mobj = 0; // For 3D positioning.
-    mobj_t *plrmo = players[DISPLAYPLAYER].plr->mo;
-
-    int volume = acs.locals.pop();
-
-    // If we are playing 3D sounds, create a temporary source mobj for the sound.
-    if(Con_GetInteger("sound-3d") && plrmo)
-    {
-        // SpawnMobj calls P_Random. We don't want that the random generator gets
-        // out of sync.
-        if((mobj = P_SpawnMobjXYZ(MT_CAMERA,
-                                  plrmo->origin[VX] + ((M_Random() - 127) * 2),
-                                  plrmo->origin[VY] + ((M_Random() - 127) * 2),
-                                  plrmo->origin[VZ] + ((M_Random() - 127) * 2),
-                                  0, 0)))
-        {
-            mobj->tics = 5 * TICSPERSEC; // Five seconds should be enough.
-        }
-    }
-
-    int sound = S_GetSoundID(Str_Text(acs.interpreter().string(acs.locals.pop())));
-    S_StartSoundAtVolume(sound, mobj, volume / 127.0f);
-
-    return Continue;
-}
-
-ACS_COMMAND(SoundSequence)
-{
-    mobj_t *mobj = 0;
-    if(acs.line)
-    {
-        Sector *front = (Sector *) P_GetPtrp(acs.line, DMU_FRONT_SECTOR);
-        mobj = (mobj_t *) P_GetPtrp(front, DMU_EMITTER);
-    }
-    SN_StartSequenceName(mobj, Str_Text(acs.interpreter().string(acs.locals.pop())));
-
-    return Continue;
-}
-
-ACS_COMMAND(SetLineTexture)
-{
-#define TEXTURE_TOP 0
-#define TEXTURE_MIDDLE 1
-#define TEXTURE_BOTTOM 2
-
-    AutoStr *path = Str_PercentEncode(Str_Copy(AutoStr_New(), acs.interpreter().string(acs.locals.pop())));
-    Uri *uri = Uri_NewWithPath3("Textures", Str_Text(path));
-
-    Material *mat = (Material *) P_ToPtr(DMU_MATERIAL, Materials_ResolveUri(uri));
-    Uri_Delete(uri);
-
-    int position = acs.locals.pop();
-    int side     = acs.locals.pop();
-    int lineTag  = acs.locals.pop();
-
-    if(iterlist_t *list = P_GetLineIterListForTag(lineTag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Line *line;
-        while((line = (Line *) IterList_MoveIterator(list)))
-        {
-            Side *sdef = (Side *) P_GetPtrp(line, (side == 0? DMU_FRONT : DMU_BACK));
-
-            if(position == TEXTURE_MIDDLE)
-            {
-                P_SetPtrp(sdef, DMU_MIDDLE_MATERIAL, mat);
-            }
-            else if(position == TEXTURE_BOTTOM)
-            {
-                P_SetPtrp(sdef, DMU_BOTTOM_MATERIAL, mat);
-            }
-            else // TEXTURE_TOP
-            {
-                P_SetPtrp(sdef, DMU_TOP_MATERIAL, mat);
-            }
-        }
-    }
-
-    return Continue;
-
-#undef TEXTURE_BOTTOM
-#undef TEXTURE_MIDDLE
-#undef TEXTURE_TOP
-}
-
-ACS_COMMAND(SetLineBlocking)
-{
-    int lineFlags = acs.locals.pop()? DDLF_BLOCKING : 0;
-    int lineTag   = acs.locals.pop();
-
-    if(iterlist_t *list = P_GetLineIterListForTag(lineTag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Line *line;
-        while((line = (Line *) IterList_MoveIterator(list)))
-        {
-            P_SetIntp(line, DMU_FLAGS, (P_GetIntp(line, DMU_FLAGS) & ~DDLF_BLOCKING) | lineFlags);
-        }
-    }
-
-    return Continue;
-}
-
-ACS_COMMAND(SetLineSpecial)
-{
-    int arg5    = acs.locals.pop();
-    int arg4    = acs.locals.pop();
-    int arg3    = acs.locals.pop();
-    int arg2    = acs.locals.pop();
-    int arg1    = acs.locals.pop();
-    int special = acs.locals.pop();
-    int lineTag = acs.locals.pop();
-
-    if(iterlist_t *list = P_GetLineIterListForTag(lineTag, false))
-    {
-        IterList_SetIteratorDirection(list, ITERLIST_FORWARD);
-        IterList_RewindIterator(list);
-
-        Line *line;
-        while((line = (Line *) IterList_MoveIterator(list)))
-        {
-            xline_t *xline = P_ToXLine(line);
-
-            xline->special = special;
-            xline->arg1 = arg1;
-            xline->arg2 = arg2;
-            xline->arg3 = arg3;
-            xline->arg4 = arg4;
-            xline->arg5 = arg5;
-        }
-    }
-
-    return Continue;
-}
-
-static CommandFunc pcodeCmds[] =
-{
-    cmdNOP, cmdTerminate, cmdSuspend, cmdPushNumber, cmdLSpec1, cmdLSpec2,
-    cmdLSpec3, cmdLSpec4, cmdLSpec5, cmdLSpec1Direct, cmdLSpec2Direct,
-    cmdLSpec3Direct, cmdLSpec4Direct, cmdLSpec5Direct, cmdAdd,
-    cmdSubtract, cmdMultiply, cmdDivide, cmdModulus, cmdEQ, cmdNE,
-    cmdLT, cmdGT, cmdLE, cmdGE, cmdAssignScriptVar, cmdAssignMapVar,
-    cmdAssignWorldVar, cmdPushScriptVar, cmdPushMapVar,
-    cmdPushWorldVar, cmdAddScriptVar, cmdAddMapVar, cmdAddWorldVar,
-    cmdSubScriptVar, cmdSubMapVar, cmdSubWorldVar, cmdMulScriptVar,
-    cmdMulMapVar, cmdMulWorldVar, cmdDivScriptVar, cmdDivMapVar,
-    cmdDivWorldVar, cmdModScriptVar, cmdModMapVar, cmdModWorldVar,
-    cmdIncScriptVar, cmdIncMapVar, cmdIncWorldVar, cmdDecScriptVar,
-    cmdDecMapVar, cmdDecWorldVar, cmdGoto, cmdIfGoto, cmdDrop,
-    cmdDelay, cmdDelayDirect, cmdRandom, cmdRandomDirect,
-    cmdThingCount, cmdThingCountDirect, cmdTagWait, cmdTagWaitDirect,
-    cmdPolyWait, cmdPolyWaitDirect, cmdChangeFloor,
-    cmdChangeFloorDirect, cmdChangeCeiling, cmdChangeCeilingDirect,
-    cmdRestart, cmdAndLogical, cmdOrLogical, cmdAndBitwise,
-    cmdOrBitwise, cmdEorBitwise, cmdNegateLogical, cmdLShift,
-    cmdRShift, cmdUnaryMinus, cmdIfNotGoto, cmdLineSide, cmdScriptWait,
-    cmdScriptWaitDirect, cmdClearLineSpecial, cmdCaseGoto,
-    cmdBeginPrint, cmdEndPrint, cmdPrintString, cmdPrintNumber,
-    cmdPrintCharacter, cmdPlayerCount, cmdGameType, cmdGameSkill,
-    cmdTimer, cmdSectorSound, cmdAmbientSound, cmdSoundSequence,
-    cmdSetLineTexture, cmdSetLineBlocking, cmdSetLineSpecial,
-    cmdThingSound, cmdEndPrintBold
-};
-
-ACScriptInterpreter &ACScript::interpreter() const
-{
-    return Game_ACScriptInterpreter();
-}
-
-BytecodeScriptInfo &ACScript::info() const
-{
-    DENG_ASSERT(_info != 0);
-    return *_info;
-}
-
-void ACScript::runTick()
-{
-    ACScriptInterpreter &interp = interpreter();
-    if(info().state == ACScriptInterpreter::Terminating)
-    {
-        interp.scriptFinished(this);
-        return;
-    }
-
-    if(info().state != ACScriptInterpreter::Running)
-    {
-        return;
-    }
-
-    if(delayCount)
-    {
-        delayCount--;
-        return;
-    }
-
-    int action;
-    while((action = pcodeCmds[LONG(*pcodePtr++)](*this)) == Continue)
-    {}
-
-    if(action == Terminate)
-    {
-        interp.scriptFinished(this);
-    }
-}
-
-void ACScript::Stack::push(int value)
-{
-    if(height == ACS_STACK_DEPTH)
-        App_Log(DE2_SCR_ERROR, "ACScript::Stack::push: Overflow");
-    values[height++] = value;
-}
-
-int ACScript::Stack::pop()
-{
-    if(height == 0)
-        App_Log(DE2_SCR_ERROR, "ACScript::Stack::pop: Underflow");
-    return values[--height];
-}
-
-int ACScript::Stack::top() const
-{
-    if(height == 0)
-        App_Log(DE2_SCR_ERROR, "ACScript::Stack::top: Underflow");
-    return values[height - 1];
-}
-
-void ACScript::Stack::drop()
-{
-    if(height == 0)
-        App_Log(DE2_SCR_ERROR, "ACScript::Stack::drop: Underflow");
-    height--;
-}
-
-void ACScript::write(MapStateWriter *msw) const
-{
-    Writer *writer = msw->writer();
-
-    Writer_WriteByte(writer, 2); // Write a version byte.
-
-    Writer_WriteInt32(writer, msw->serialIdFor(activator));
-    Writer_WriteInt32(writer, P_ToIndex(line));
-    Writer_WriteInt32(writer, side);
-    Writer_WriteInt32(writer, info().scriptNumber);
-    Writer_WriteInt32(writer, delayCount);
-    for(uint i = 0; i < ACS_STACK_DEPTH; ++i)
-    {
-        Writer_WriteInt32(writer, locals.values[i]);
-    }
-    Writer_WriteInt32(writer, locals.height);
-    for(uint i = 0; i < MAX_ACS_SCRIPT_VARS; ++i)
-    {
-        Writer_WriteInt32(writer, vars[i]);
-    }
-    Writer_WriteInt32(writer, ((byte const *)pcodePtr) - interpreter().bytecode());
-}
-
-int ACScript::read(MapStateReader *msr)
-{
-    Reader *reader = msr->reader();
-    int mapVersion = msr->mapVersion();
-
-    if(mapVersion >= 4)
-    {
-        // Note: the thinker class byte has already been read.
-        int ver = Reader_ReadByte(reader); // version byte.
-
-        // Activator.
-        activator = INT2PTR(mobj_t, Reader_ReadInt32(reader));
-        activator = msr->mobj(PTR2INT(activator), &activator);
-
-        // Line.
-        int lineIndex = Reader_ReadInt32(reader);
-        if(lineIndex >= 0)
-        {
-            line = (Line *) P_ToPtr(DMU_LINE, lineIndex);
-            DENG_ASSERT(line != 0);
-        }
-        else
-        {
-            line = 0;
-        }
-
-        // Side index.
-        side  = Reader_ReadInt32(reader);
-
-        // Script number.
-        int scriptNumber = Reader_ReadInt32(reader);
-        _info = interpreter().scriptInfoPtr(scriptNumber);
-
-        // Obsolete ignored value in the old format?
-        if(ver < 2)
-        {
-            /*infoIndex =*/ Reader_ReadInt32(reader);
-        }
-
-        delayCount = Reader_ReadInt32(reader);
-
-        for(uint i = 0; i < ACS_STACK_DEPTH; ++i)
-        {
-            locals.values[i] = Reader_ReadInt32(reader);
-        }
-        locals.height = Reader_ReadInt32(reader);
-
-        for(uint i = 0; i < MAX_ACS_SCRIPT_VARS; ++i)
-        {
-            vars[i] = Reader_ReadInt32(reader);
-        }
-
-        pcodePtr   = (int *) (interpreter().bytecode() + Reader_ReadInt32(reader));
-    }
-    else
-    {
-        // Its in the old pre V4 format which serialized acs_t
-        // Padding at the start (an old thinker_t struct)
-        byte junk[16]; // sizeof thinker_t
-        Reader_Read(reader, junk, 16);
-
-        // Start of used data members.
-        activator  = INT2PTR(mobj_t, Reader_ReadInt32(reader));
-        activator  = msr->mobj(PTR2INT(activator), &activator);
-
-        int temp = Reader_ReadInt32(reader);
-        if(temp >= 0)
-        {
-            line   = (Line *)P_ToPtr(DMU_LINE, temp);
-            DENG_ASSERT(line != 0);
-        }
-        else
-        {
-            line   = 0;
-        }
-
-        side       = Reader_ReadInt32(reader);
-        _info      = interpreter().scriptInfoPtr(Reader_ReadInt32(reader));
-        /*infoIndex  =*/ Reader_ReadInt32(reader);
-        delayCount = Reader_ReadInt32(reader);
-
-        for(uint i = 0; i < ACS_STACK_DEPTH; ++i)
-        {
-            locals.values[i] = Reader_ReadInt32(reader);
-        }
-        locals.height = Reader_ReadInt32(reader);
-
-        for(uint i = 0; i < MAX_ACS_SCRIPT_VARS; ++i)
-        {
-            vars[i] = Reader_ReadInt32(reader);
-        }
-
-        pcodePtr   = (int *) (interpreter().bytecode() + Reader_ReadInt32(reader));
-    }
-
-    thinker.function = (thinkfunc_t) ACScript_Thinker;
-
-    return true; // Add this thinker.
-}
-
-/// The One ACS interpreter instance.
-static ACScriptInterpreter interp;
-
-ACScriptInterpreter &Game_ACScriptInterpreter()
-{
-    return interp;
-}
-
-void Game_ACScriptInterpreter_RunDeferredTasks(Uri const *mapUri)
-{
-    if(!mapUri) return;
-    interp.runDeferredTasks(*reinterpret_cast<de::Uri const *>(mapUri));
-}
-
-dd_bool Game_ACScriptInterpreter_StartScript(int scriptNumber, Uri const *mapUri,
-    byte const args[], mobj_t *activator, Line *line, int side)
-{
-    return interp.startScript(scriptNumber, reinterpret_cast<de::Uri const *>(mapUri),
-                              args, activator, line, side);
-}
-
-dd_bool Game_ACScriptInterpreter_TerminateScript(int scriptNumber, Uri const *mapUri)
-{
-    return interp.terminateScript(scriptNumber, reinterpret_cast<de::Uri const *>(mapUri));
-}
-
-dd_bool Game_ACScriptInterpreter_SuspendScript(int scriptNumber, Uri const *mapUri)
-{
-    return interp.suspendScript(scriptNumber, reinterpret_cast<de::Uri const *>(mapUri));
-}
-
-void ACScript_Thinker(ACScript *script)
-{
-    DENG_ASSERT(script != 0);
-    script->runTick();
-}
-
-D_CMD(InspectACScript)
-{
-    DENG_UNUSED(src);
-    DENG_UNUSED(argc);
-
-    if(!interp.scriptCount())
-    {
-        App_Log(DE2_SCR_MSG, "No ACScripts are currently loaded.");
-        return true;
-    }
-
-    int whichOne = atoi(argv[1]);
-    if(!interp.hasScriptEntrypoint(whichOne))
-    {
-        App_Log(DE2_SCR_WARNING, "Unknown ACScript #%i", whichOne);
-        return false;
-    }
-
-    App_Log(DE2_SCR_MSG, "%s", Str_Text(interp.scriptDescription(whichOne)));
-    return true;
-}
-
-D_CMD(ListACScripts)
-{
-    DENG_UNUSED(src);
-    DENG_UNUSED(argc);
-    DENG_UNUSED(argv);
-
-    if(!interp.scriptCount())
-    {
-        App_Log(DE2_SCR_MSG, "No ACScripts are currently loaded.");
-        return true;
-    }
-    
-    App_Log(DE2_SCR_MSG, "World variables:");
-    for(int i = 0; i < MAX_ACS_WORLD_VARS; ++i)
-    {
-        App_Log(DE2_SCR_MSG, "  #%i: %i", i, interp.worldVars[i]);
-    }
-
-    App_Log(DE2_SCR_MSG, "Map variables:");
-    for(int i = 0; i < MAX_ACS_MAP_VARS; ++i)
-    {
-        App_Log(DE2_SCR_MSG, "  #%i: %i", i, interp.mapVars[i]);
-    }
-
-    App_Log(DE2_SCR_MSG, "Available ACScripts:");
-    for(int i = 0; i < interp.scriptCount(); ++i)
-    {
-        BytecodeScriptInfo &info = interp.scriptInfoByIndex(i);
-        App_Log(DE2_SCR_MSG, "  %s - args: %i",
-                             Str_Text(interp.scriptName(info.scriptNumber)), info.argCount);
-    }
-
-    return true;
-}
diff --git a/doomsday/plugins/hexen/src/hconsole.cpp b/doomsday/plugins/hexen/src/hconsole.cpp
index 0ff409b2df..28e30a8630 100644
--- a/doomsday/plugins/hexen/src/hconsole.cpp
+++ b/doomsday/plugins/hexen/src/hconsole.cpp
@@ -40,8 +40,6 @@ D_CMD(CheatRunScript);
 D_CMD(CheatSuicide);
 D_CMD(CheatWhere);
 D_CMD(CycleSpy);
-D_CMD(InspectACScript);
-D_CMD(ListACScripts);
 D_CMD(MakeLocal);
 D_CMD(MovePlane);
 D_CMD(PrintPlayerCoords);
@@ -153,7 +151,5 @@ void G_ConsoleRegistration()
 
     C_CMD("pig",         NULL,   CheatMorph);
     C_CMD("runscript",   "i*",   CheatRunScript);
-    C_CMD("scriptinfo",  "i",    InspectACScript);
-    C_CMD("scriptinfo",  "",     ListACScripts);
     C_CMD("class",       "i*",   CheatShadowcaster);
 }
diff --git a/doomsday/plugins/hexen/src/intermission.cpp b/doomsday/plugins/hexen/src/intermission.cpp
index 386d3dd329..3dbd786063 100644
--- a/doomsday/plugins/hexen/src/intermission.cpp
+++ b/doomsday/plugins/hexen/src/intermission.cpp
@@ -24,6 +24,8 @@
 
 #include <cstdio>
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
 #include "hu_stuff.h"
 #include "hu_menu.h"
 #include "g_common.h"
diff --git a/doomsday/plugins/hexen/src/m_cheat.cpp b/doomsday/plugins/hexen/src/m_cheat.cpp
index a72f72612c..571485d1f1 100644
--- a/doomsday/plugins/hexen/src/m_cheat.cpp
+++ b/doomsday/plugins/hexen/src/m_cheat.cpp
@@ -19,21 +19,24 @@
  * 02110-1301 USA</small>
  */
 
-#include <stdlib.h>
-#include <errno.h>
-
 #include "jhexen.h"
+#include "m_cheat.h"
 
+#include <cerrno>
+#include <cstdlib>
+#include "acs/system.h"
+#include "am_map.h"
 #include "d_net.h"
+#include "d_netcl.h"
+#include "d_netsv.h"
+#include "dmu_lib.h"
 #include "g_common.h"
+#include "g_eventsequence.h"
 #include "gamesession.h"
-#include "player.h"
-#include "am_map.h"
 #include "hu_msg.h"
-#include "dmu_lib.h"
-#include "p_user.h"
 #include "p_inventory.h"
-#include "g_eventsequence.h"
+#include "p_user.h"
+#include "player.h"
 
 typedef eventsequencehandler_t cheatfunc_t;
 
@@ -49,6 +52,11 @@ typedef eventsequencehandler_t cheatfunc_t;
 /// Helper macro for registering new cheat event sequence command handlers.
 #define ADDCHEATCMD(name, cmdTemplate) G_AddEventSequenceCommand((name), cmdTemplate)
 
+static inline acs::System &acsScriptSys()
+{
+    return Game_ACScriptSystem();
+}
+
 CHEAT_FUNC(Class);
 CHEAT_FUNC(IDKFA);
 CHEAT_FUNC(Init);
@@ -805,13 +813,14 @@ D_CMD(CheatRunScript)
             /// @todo Don't do this here.
             if(scriptNum < 1 || scriptNum > 99) return false;
 
-            byte scriptArgs[3]; /// @todo Only 3 args?? -ds
-            scriptArgs[0] = scriptArgs[1] = scriptArgs[2] = 0;
-            if(Game_ACScriptInterpreter_StartScript(scriptNum, 0/*current-map*/,
-                                                    scriptArgs, plr->plr->mo, NULL, 0))
+            if(acsScriptSys().hasScript(scriptNum))
             {
-                AutoStr *cmd = Str_Appendf(AutoStr_NewStd(), "Running script %i", scriptNum);
-                P_SetMessage(plr, LMF_NO_HIDE, Str_Text(cmd));
+                if(acsScriptSys().script(scriptNum).start(acs::Script::Args()/*default args*/,
+                                                          plr->plr->mo, nullptr, 0))
+                {
+                    de::String msg = de::String("Running script %1").arg(scriptNum);
+                    P_SetMessage(plr, LMF_NO_HIDE, msg.toUtf8().constData());
+                }
             }
 
             S_LocalSound(SFX_PLATFORM_STOP, NULL);
diff --git a/doomsday/plugins/hexen/src/p_enemy.c b/doomsday/plugins/hexen/src/p_enemy.c
index 7e6feb42b6..7a73f2af2d 100644
--- a/doomsday/plugins/hexen/src/p_enemy.c
+++ b/doomsday/plugins/hexen/src/p_enemy.c
@@ -1,49 +1,38 @@
-/**\file
- *\section License
- * License: GPL
- * Online License Link: http://www.gnu.org/licenses/gpl.html
+/** @file p_enemy.c  Enemy thinking, AI.
  *
- *\author Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- *\author Copyright © 2005-2013 Daniel Swanson <danij@dengine.net>
- *\author Copyright © 1999 Activision
+ * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
+ * @authors Copyright © 2005-2015 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 1999 Activision
  *
- * 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.
+ * @par License
+ * GPL: http://www.gnu.org/licenses/gpl.html
  *
- * 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 St, Fifth Floor,
- * Boston, MA  02110-1301  USA
- */
-
-/**
- * p_enemy.c: Enemy thinking, AI.
- *
- * Action Pointer Functions that are associated with states/frames.
+ * <small>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 St, Fifth Floor, Boston, MA
+ * 02110-1301 USA</small>
  */
 
-// HEADER FILES ------------------------------------------------------------
-
 #include <string.h>
 #include <math.h>
 #include <assert.h>
 
 #include "jhexen.h"
+#include "p_enemy.h"
 
+#include "acs/system.h"
+#include "d_net.h"
+#include "d_netsv.h"
 #include "dmu_lib.h"
-#include "p_mapspec.h"
-#include "p_map.h"
 #include "g_common.h"
-#include "d_net.h"
-
-// MACROS ------------------------------------------------------------------
+#include "p_map.h"
+#include "p_mapspec.h"
 
 #define MONS_LOOK_RANGE             (16*64)
 #define MONS_LOOK_LIMIT             64
@@ -93,20 +82,8 @@
 #define KORAX_ARM5_HEIGHT           (86)
 #define KORAX_ARM6_HEIGHT           (53)
 
-// TYPES -------------------------------------------------------------------
-
-// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
-
-// PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
-
-// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
-
 void KSpiritInit(mobj_t *spirit, mobj_t *korax);
 
-// EXTERNAL DATA DECLARATIONS ----------------------------------------------
-
-// PUBLIC DATA DEFINITIONS -------------------------------------------------
-
 int maulatorSeconds = 25;
 //dd_bool fastMonsters = false;
 
@@ -130,10 +107,6 @@ int corpseQueueSlot;
 mobj_t *bodyque[BODYQUESIZE];
 int bodyqueslot;
 
-// PRIVATE DATA DEFINITIONS ------------------------------------------------
-
-// CODE --------------------------------------------------------------------
-
 void P_ClearBodyQueue(void)
 {
     memset(bodyque, 0, sizeof(bodyque));
@@ -4259,7 +4232,7 @@ void C_DECL A_KoraxChase(mobj_t *actor)
             P_Teleport(actor, spot->origin[VX], spot->origin[VY], spot->angle, true);
         }
 
-        Game_ACScriptInterpreter_StartScript(249, 0/*current-map*/, args, actor, NULL, 0);
+        Game_ACScriptSystem_StartScript(249, 0/*current-map*/, args, actor, NULL, 0);
         actor->special2 = 1; // Don't run again.
 
         return;
@@ -4336,7 +4309,7 @@ void C_DECL A_KoraxBonePop(mobj_t* actor)
     if(mo)
         KSpiritInit(mo, actor);
 
-    Game_ACScriptInterpreter_StartScript(255, 0/*current-map*/, args, actor, NULL, 0); // Death script.
+    Game_ACScriptSystem_StartScript(255, 0/*current-map*/, args, actor, NULL, 0); // Death script.
 }
 
 void KSpiritInit(mobj_t* spirit, mobj_t* korax)
@@ -4524,7 +4497,7 @@ void C_DECL A_KoraxCommand(mobj_t* mo)
     }
 
     assert(scriptNumber >= 0);
-    Game_ACScriptInterpreter_StartScript(scriptNumber, 0/*current-map*/, args, mo, NULL, 0);
+    Game_ACScriptSystem_StartScript(scriptNumber, 0/*current-map*/, args, mo, NULL, 0);
 }
 
 void C_DECL A_KSpiritWeave(mobj_t* mo)
diff --git a/doomsday/plugins/hexen/src/p_inter.c b/doomsday/plugins/hexen/src/p_inter.c
index 8a3146ca62..bc8d6dedb7 100644
--- a/doomsday/plugins/hexen/src/p_inter.c
+++ b/doomsday/plugins/hexen/src/p_inter.c
@@ -19,19 +19,22 @@
  * 02110-1301 USA</small>
  */
 
+#include <string.h>
+#include <math.h>
+
 #include "jhexen.h"
 #include "p_inter.h"
 
+#include "acs/system.h"
 #include "am_map.h"
-#include "p_inventory.h"
+#include "d_netsv.h"
+#include "g_common.h"
 #include "hu_inventory.h"
-#include "player.h"
-#include "p_map.h"
 #include "mobj.h"
+#include "p_inventory.h"
+#include "p_map.h"
 #include "p_user.h"
-
-#include <string.h>
-#include <math.h>
+#include "player.h"
 
 #define BONUSADD                (6)
 
@@ -1451,7 +1454,7 @@ void P_KillMobj(mobj_t *source, mobj_t *target)
         if(target->type == MT_SORCBOSS)
         {
             dummy = 0;
-            Game_ACScriptInterpreter_StartScript(target->special, 0/*current-map*/,
+            Game_ACScriptSystem_StartScript(target->special, 0/*current-map*/,
                                                  (byte *) &dummy, target, NULL, 0);
         }
         else
diff --git a/doomsday/plugins/hexen/src/p_mobj.c b/doomsday/plugins/hexen/src/p_mobj.c
index 379cf7d37e..2a3b9261bd 100644
--- a/doomsday/plugins/hexen/src/p_mobj.c
+++ b/doomsday/plugins/hexen/src/p_mobj.c
@@ -1,4 +1,4 @@
-/** @file p_mobj.c World map object interaction.
+/** @file p_mobj.c  World map object interaction.
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
  * @authors Copyright © 2006-2013 Daniel Swanson <danij@dengine.net>
@@ -23,15 +23,17 @@
 #  pragma optimize("g", off)
 #endif
 
+#include "jhexen.h"
+#include "p_mobj.h"
+
 #include <math.h>
 #include <string.h>
 #include <de/binangle.h>
-
-#include "jhexen.h"
+#include "d_netcl.h"
 #include "dmu_lib.h"
+#include "g_common.h"
 #include "p_map.h"
 #include "player.h"
-#include "g_common.h"
 
 #define MAX_BOB_OFFSET          8
 
diff --git a/doomsday/plugins/hexen/src/p_pillar.cpp b/doomsday/plugins/hexen/src/p_pillar.cpp
index 51e75a4750..4221e59569 100644
--- a/doomsday/plugins/hexen/src/p_pillar.cpp
+++ b/doomsday/plugins/hexen/src/p_pillar.cpp
@@ -1,7 +1,7 @@
 /** @file p_pillar.cpp
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2006-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 2006-2015 Daniel Swanson <danij@dengine.net>
  * @authors Copyright © 1999 Activision
  *
  * @par License
@@ -28,7 +28,7 @@
 
 void T_BuildPillar(pillar_t *pillar)
 {
-    DENG_ASSERT(pillar != 0);
+    DENG2_ASSERT(pillar);
 
     // First, raise the floor
     result_e res1 = T_MovePlane(pillar->sector, pillar->floorSpeed, pillar->floorDest, pillar->crush, 0, pillar->direction); // floorOrCeiling, direction
@@ -38,7 +38,7 @@ void T_BuildPillar(pillar_t *pillar)
     {
         P_ToXSector(pillar->sector)->specialData = 0;
         SN_StopSequenceInSec(pillar->sector);
-        Game_ACScriptInterpreter().tagFinished(P_ToXSector(pillar->sector)->tag);
+        P_NotifySectorFinished(P_ToXSector(pillar->sector)->tag);
         Thinker_Remove(&pillar->thinker);
     }
 }
diff --git a/doomsday/plugins/hexen/src/p_pspr.c b/doomsday/plugins/hexen/src/p_pspr.c
index 1158344cca..ced55c32b6 100644
--- a/doomsday/plugins/hexen/src/p_pspr.c
+++ b/doomsday/plugins/hexen/src/p_pspr.c
@@ -1,9 +1,7 @@
-/** @file p_pspr.c Weapon sprite animation.
- *
- * Weapon sprite animation, weapon objects. Action functions for weapons.
+/** @file p_pspr.c  Weapon sprite animation.
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2006-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 2006-2015 Daniel Swanson <danij@dengine.net>
  * @authors Copyright © 1999 Activision
  *
  * @par License
@@ -21,15 +19,17 @@
  * 02110-1301 USA</small>
  */
 
-#include <math.h>
+#include "jhexen.h"
+#include "p_pspr.h"
 
-#include "common.h"
-#include "r_common.h"
-
-#include "player.h"
-#include "p_map.h"
+#include <math.h>
+#include "d_netcl.h"
+#include "g_common.h"
 #include "mobj.h"
 #include "p_inventory.h"
+#include "p_map.h"
+#include "player.h"
+#include "r_common.h"
 
 #define LOWERSPEED          (6)
 #define RAISESPEED          (6)
diff --git a/doomsday/plugins/hexen/src/p_spec.cpp b/doomsday/plugins/hexen/src/p_spec.cpp
index 3123964aea..167263816e 100644
--- a/doomsday/plugins/hexen/src/p_spec.cpp
+++ b/doomsday/plugins/hexen/src/p_spec.cpp
@@ -19,12 +19,14 @@
  * 02110-1301 USA</small>
  */
 
-#include <cstring>
-#include <cstdio>
-
 #include "jhexen.h"
+#include "p_spec.h"
 
+#include <cstdio>
+#include <cstring>
+#include "acs/system.h"
 #include "dmu_lib.h"
+#include "d_netsv.h"
 #include "g_common.h"
 #include "gamesession.h"
 #include "lightninganimator.h"
@@ -45,6 +47,11 @@
 using namespace de;
 using namespace common;
 
+static inline acs::System &acsScriptSys()
+{
+    return Game_ACScriptSystem();
+}
+
 LightningAnimator lightningAnimator;
 
 ThinkerT<mobj_t> lavaInflictor;
@@ -118,40 +125,25 @@ dd_bool EV_LineSearchForPuzzleItem(Line *line, byte * /*args*/, mobj_t *mo)
 
 static de::Uri getMapUriForWarpNumber(int warpNumber)
 {
-    if(!warpNumber)
-    {
-        return COMMON_GAMESESSION->mapUri(); // Current map URI.
-    }
-    return TranslateMapWarpNumber(COMMON_GAMESESSION->episodeId(), warpNumber);
-}
-
-dd_bool P_StartLockedACS(Line *line, byte *args, mobj_t *mo, int side)
-{
-    DENG2_ASSERT(args != 0 && mo != 0);
-
-    if(!mo->player) return false;
-
-    if(int lock = args[4])
-    {
-        if(!(mo->player->keys & (1 << (lock - 1))))
-        {
-            char LockedBuffer[80];
-            sprintf(LockedBuffer, "YOU NEED THE %s\n", GET_TXT(TextKeyMessages[lock - 1]));
-            P_SetMessage(mo->player, 0, LockedBuffer);
-            S_StartSound(SFX_DOOR_LOCKED, mo);
-            return false;
-        }
-    }
-
-    byte newArgs[5];
-    for(int i = 0; i < 4; ++i)
+    /// @c <= 0 means the current map.
+    if(warpNumber <= 0) return COMMON_GAMESESSION->mapUri();
+
+    // See if a translation exists for this.
+    String episodeId = COMMON_GAMESESSION->episodeId();
+    de::Uri mapUri   = TranslateMapWarpNumber(episodeId, warpNumber);
+    if(!mapUri.isEmpty()) return mapUri;
+
+    // If the episode ID is a number - interpret this as a map number
+    // for vanilla compat (ugh...).
+    bool isNumber;
+    int oldEpisodeNum = episodeId.toInt(&isNumber);
+    if(isNumber && oldEpisodeNum > 0)
     {
-        newArgs[i] = args[i];
+        return G_ComposeMapUri(oldEpisodeNum - 1, warpNumber - 1);
     }
-    newArgs[4] = 0;
 
-    de::Uri mapUri = getMapUriForWarpNumber(newArgs[1]);
-    return Game_ACScriptInterpreter().startScript(newArgs[0], &mapUri, &newArgs[2], mo, line, side);
+    // There is no auto-logical translation possible.
+    return de::Uri();
 }
 
 dd_bool P_ExecuteLineSpecial(int special, byte args[5], Line *line, int side, mobj_t *mo)
@@ -429,23 +421,70 @@ dd_bool P_ExecuteLineSpecial(int special, byte args[5], Line *line, int side, mo
         break;
 
     case 80: /* ACS_Execute */ {
-        de::Uri mapUri = getMapUriForWarpNumber(args[1]);
-        success = Game_ACScriptInterpreter().startScript(args[0], &mapUri, &args[2], mo, line, side);
+        int scriptNumber = args[0];
+        de::Uri mapUri   = getMapUriForWarpNumber(args[1]);
+        acs::Script::Args scriptArgs(&args[2], 3);
+        if(COMMON_GAMESESSION->mapUri() == mapUri)
+        {
+            if(acsScriptSys().hasScript(scriptNumber))
+            {
+               success = acsScriptSys().script(scriptNumber).start(scriptArgs, mo, line, side);
+            }
+        }
+        else
+        {
+            success = acsScriptSys().deferScriptStart(mapUri, scriptNumber, scriptArgs);
+        }
         break; }
 
     case 81: /* ACS_Suspend */ {
-        de::Uri mapUri = getMapUriForWarpNumber(args[1]);
-        success = Game_ACScriptInterpreter().suspendScript(args[0], &mapUri);
+        int scriptNumber = args[0];
+        //de::Uri mapUri   = getMapUriForWarpNumber(args[1]);
+        if(acsScriptSys().hasScript(scriptNumber))
+        {
+            success = acsScriptSys().script(scriptNumber).suspend();
+        }
         break; }
 
     case 82: /* ACS_Terminate */ {
-        de::Uri mapUri = getMapUriForWarpNumber(args[1]);
-        success = Game_ACScriptInterpreter().terminateScript(args[0], &mapUri);
+        int scriptNumber = args[0];
+        //de::Uri mapUri   = getMapUriForWarpNumber(args[1]);
+        if(acsScriptSys().hasScript(scriptNumber))
+        {
+            success = acsScriptSys().script(scriptNumber).terminate();
+        }
         break; }
 
-    case 83: // ACS_LockedExecute
-        success = P_StartLockedACS(line, args, mo, side);
-        break;
+    case 83: /* ACS_LockedExecute */ {
+        if(!mo->player) break;
+
+        if(int lock = args[4])
+        {
+            if(!(mo->player->keys & (1 << (lock - 1))))
+            {
+                char LockedBuffer[80];
+                sprintf(LockedBuffer, "YOU NEED THE %s\n", GET_TXT(TextKeyMessages[lock - 1]));
+                P_SetMessage(mo->player, 0, LockedBuffer);
+                S_StartSound(SFX_DOOR_LOCKED, mo);
+                break;
+            }
+        }
+
+        int scriptNumber = args[0];
+        de::Uri mapUri   = getMapUriForWarpNumber(args[1]);
+        acs::Script::Args scriptArgs(args, 4);
+        if(COMMON_GAMESESSION->mapUri() == mapUri)
+        {
+            if(acsScriptSys().hasScript(scriptNumber))
+            {
+                success = acsScriptSys().script(scriptNumber).start(scriptArgs, mo, line, side);
+            }
+        }
+        else
+        {
+            success = acsScriptSys().deferScriptStart(mapUri, scriptNumber, scriptArgs);
+        }
+        break; }
 
     case 90: // Poly Rotate Left Override
         success = EV_RotatePoly(line, args, 1, true);
@@ -770,21 +809,6 @@ void P_SpawnAllSpecialThinkers()
     P_SpawnLineSpecialThinkers();
 }
 
-dd_bool P_SectorTagIsBusy(int tag)
-{
-    /// @note The sector tag lists cannot be used here as an iteration at a higher
-    /// level may already be in progress.
-    for(int i = 0; i < numsectors; ++i)
-    {
-        xsector_t *xsec = P_ToXSector((Sector *) P_ToPtr(DMU_SECTOR, i));
-        if(xsec->tag == tag && xsec->specialData)
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
 void P_InitLightning()
 {
     ::lightningAnimator.initForMap();
diff --git a/doomsday/plugins/hexen/src/p_things.c b/doomsday/plugins/hexen/src/p_things.c
index 10a6aeabe0..e231d8ea85 100644
--- a/doomsday/plugins/hexen/src/p_things.c
+++ b/doomsday/plugins/hexen/src/p_things.c
@@ -20,9 +20,11 @@
  */
 
 #include "jhexen.h"
+#include "p_things.h"
 
-#include "p_map.h"
+#include "g_common.h"
 #include "mobj.h"
+#include "p_map.h"
 
 static dd_bool ActivateThing(mobj_t *mobj);
 static dd_bool DeactivateThing(mobj_t *mobj);
diff --git a/doomsday/plugins/hexen/src/p_waggle.cpp b/doomsday/plugins/hexen/src/p_waggle.cpp
index 24649be345..98d6691a68 100644
--- a/doomsday/plugins/hexen/src/p_waggle.cpp
+++ b/doomsday/plugins/hexen/src/p_waggle.cpp
@@ -1,7 +1,7 @@
 /** @file p_waggle.cpp
  *
  * @authors Copyright © 2003-2013 Jaakko Keränen <jaakko.keranen@iki.fi>
- * @authors Copyright © 2006-2013 Daniel Swanson <danij@dengine.net>
+ * @authors Copyright © 2006-2015 Daniel Swanson <danij@dengine.net>
  * @authors Copyright © 1999 Activision
  *
  * @par License
@@ -58,8 +58,8 @@ void T_FloorWaggle(waggle_t *waggle)
             // Remove.
             P_SetDoublep(waggle->sector, DMU_FLOOR_HEIGHT, waggle->originalHeight);
             P_ChangeSector(waggle->sector, 1 /*crush damage*/);
-            P_ToXSector(waggle->sector)->specialData = NULL;
-            Game_ACScriptInterpreter().tagFinished(P_ToXSector(waggle->sector)->tag);
+            P_ToXSector(waggle->sector)->specialData = nullptr;
+            P_NotifySectorFinished(P_ToXSector(waggle->sector)->tag);
             Thinker_Remove(&waggle->thinker);
             return;
         }