Add variables concept to expressions

This also includes the necessary setup work for using "position" and
"direction" in action expressions.

.github/workflows/build-nightly.yaml

@@ -65,7 +65,7 @@ jobs:
     name: Build Linux distribution zip
     needs: build_linux
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     steps:
       - uses: actions/checkout@v1
         name: Checkout
@@ -171,7 +171,7 @@ jobs:
     name: Build Windows distribution zip
     needs: build_windows
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     strategy:
       matrix:
         arch: [Win32, x64]

.github/workflows/build-release.yaml

@@ -89,7 +89,7 @@ jobs:
     name: Build Linux distribution zip
     needs: build_linux
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     steps:
       - uses: actions/checkout@v1
         name: Checkout
@@ -126,8 +126,7 @@ jobs:
           upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
           asset_path: ${{ steps.generate_package.outputs.package_path }}
           asset_name: ${{ steps.generate_package.outputs.package_name }}
-          # All builds are zips at the moment so this is fine for now
-          asset_content_type: application/zip
+          asset_content_type: ${{ steps.generate_package.outputs.package_mime }}
 
   build_windows:
     strategy:
@@ -207,7 +206,7 @@ jobs:
     name: Build Windows distribution zip
     needs: build_windows
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     strategy:
       matrix:
         arch: [Win32, x64]
@@ -252,8 +251,7 @@ jobs:
           upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
           asset_path: ${{ steps.generate_package.outputs.package_path }}
           asset_name: ${{ steps.generate_package.outputs.package_name }}
-          # All builds are zips at the moment so this is fine for now
-          asset_content_type: application/zip
+          asset_content_type: ${{ steps.generate_package.outputs.package_mime }}
       - name: Upload debug symbols
         uses: actions/upload-release-asset@v1
         env:
@@ -262,5 +260,4 @@ jobs:
           upload_url: ${{ steps.extractUploadUrl.outputs.upload_url }}
           asset_path: ${{ steps.generate_package.outputs.debug_path }}
           asset_name: ${{ steps.generate_package.outputs.debug_name }}
-          # All builds are zips at the moment so this is fine for now
-          asset_content_type: application/zip
+          asset_content_type: ${{ steps.generate_package.outputs.debug_mime }}

.github/workflows/build-test.yaml

@@ -71,7 +71,7 @@ jobs:
     name: Build Linux distribution zip
     needs: build_linux
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     steps:
       - uses: actions/checkout@v2
         name: Checkout
@@ -184,7 +184,7 @@ jobs:
     name: Build Windows distribution zip
     needs: build_windows
     runs-on: ubuntu-latest
-    container: ghcr.io/scp-fs2open/sftp_upload:sha-dd9d8cf
+    container: ghcr.io/scp-fs2open/sftp_upload:sha-748b19d
     strategy:
       matrix:
         arch: [Win32, x64]

.github/workflows/pr-workflow.yaml

@@ -8,6 +8,7 @@ env:
 jobs:
   build_linux:
     strategy:
+      fail-fast: false
       matrix:
         configuration: [Debug, Release]
         compiler: [gcc-5, gcc-10, clang-9]

CMakeLists.txt

@@ -44,9 +44,14 @@ PROJECT(FS2_Open)
 find_program(CCACHE_PROGRAM ccache)
 # Currently only GCC support ccache properly without generating additional warnings
 if(CCACHE_PROGRAM AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	message(STATUS "Using ccache for compilation: ${CCACHE_PROGRAM}")
-	set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE_PROGRAM}")
-	set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK "${CCACHE_PROGRAM}")
+	if(NOT CMAKE_C_COMPILER_LAUNCHER)
+		message(STATUS "Using ccache for C compilation: ${CCACHE_PROGRAM}")
+		SET(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
+	endif()
+	if(NOT CMAKE_CXX_COMPILER_LAUNCHER)
+		message(STATUS "Using ccache for C++ compilation: ${CCACHE_PROGRAM}")
+		SET(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
+	endif()
 endif()
 
 IF(CMAKE_CROSSCOMPILING)

ci/linux/configure_cmake.sh

@@ -32,4 +32,5 @@ export LD_LIBRARY_PATH
 
 cmake -G Ninja -DFSO_FATAL_WARNINGS=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON $CMAKE_OPTIONS \
     -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DFSO_BUILD_APPIMAGE=ON -DCMAKE_BUILD_TYPE=$CONFIGURATION \
-    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON ..
+    -DFFMPEG_USE_PRECOMPILED=ON -DFSO_BUILD_TESTS=ON -DFSO_BUILD_INCLUDED_LIBS=ON -DFSO_BUILD_QTFRED=ON \
+    -DSHADERS_ENABLE_COMPILATION=ON ..

ci/linux/create_dist_pack.sh

@@ -12,16 +12,19 @@ if [ "$OS" = "Linux" ]; then
 
     echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-Linux.tar.gz"
     echo "::set-output name=package_name::$(get_package_name)-builds-Linux.tar.gz"
+    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-Linux.tar.gz")"
 elif [ "$OS" = "Windows" ]; then
     7z a -xr'!*.pdb' "$(get_package_name)-builds-$ARCH-$SIMD.zip" "*"
 
     echo "::set-output name=package_path::$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip"
     echo "::set-output name=package_name::$(get_package_name)-builds-$ARCH-$SIMD.zip"
+    echo "::set-output name=package_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-builds-$ARCH-$SIMD.zip")"
 
     7z a "$(get_package_name)-debug-$ARCH-$SIMD.7z" "*.pdb"
 
-    echo "::set-output name=debug_path::$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.zip"
-    echo "::set-output name=debug_name::$(get_package_name)-debug-$ARCH-$SIMD.zip"
+    echo "::set-output name=debug_path::$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z"
+    echo "::set-output name=debug_name::$(get_package_name)-debug-$ARCH-$SIMD.7z"
+    echo "::set-output name=debug_mime::$(file -b --mime-type "$(pwd)/$(get_package_name)-debug-$ARCH-$SIMD.7z")"
 else
     echo "Invalid OS: $OS"
 fi

code/CMakeLists.txt

@@ -63,6 +63,8 @@ ENDIF(FSO_USE_SPEECH)
 
 TARGET_LINK_LIBRARIES(code PUBLIC jansson)
 
+target_link_libraries(code PUBLIC variant)
+
 # Headers for standalone "gui" on UNIX
 IF(UNIX)
 	TARGET_LINK_LIBRARIES(code PUBLIC ${MONGOOSE_LIBS})

code/actions/Action.cpp

@@ -0,0 +1,8 @@
+
+#include "Action.h"
+
+namespace actions {
+
+Action::~Action() = default;
+
+}

code/actions/Action.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "common.h"
+
+namespace actions {
+
+enum class ActionResult
+{
+	Finished,
+	Errored,
+	Wait
+};
+
+class Action {
+  public:
+	virtual ~Action() = 0;
+
+	virtual ActionResult execute(ProgramLocals& locals) const = 0;
+
+	virtual std::unique_ptr<Action> clone() const = 0;
+};
+
+} // namespace actions

code/actions/ActionDefinition.cpp

@@ -0,0 +1,20 @@
+
+#include "ActionDefinition.h"
+
+namespace actions {
+
+ActionDefinition::ActionDefinition(SCP_string name, SCP_vector<ActionParameter> parameters)
+	: m_name(std::move(name)), m_parameters(std::move(parameters))
+{
+}
+
+const SCP_string& ActionDefinition::getName() const
+{
+	return m_name;
+}
+const SCP_vector<ActionParameter>& ActionDefinition::getParameters() const
+{
+	return m_parameters;
+}
+
+} // namespace actions

code/actions/ActionDefinition.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "Action.h"
+
+#include "actions/expression/ActionExpression.h"
+#include "actions/expression/Value.h"
+
+namespace actions {
+
+struct ActionParameter {
+	SCP_string name;
+	expression::ValueType type;
+};
+
+class ActionDefinition {
+  public:
+	ActionDefinition(SCP_string name, SCP_vector<ActionParameter> parameters);
+
+	const SCP_string& getName() const;
+	const SCP_vector<actions::ActionParameter>& getParameters() const;
+
+	virtual flagset<ProgramContextFlags> getRequiredContext() const = 0;
+
+	virtual std::unique_ptr<Action> createAction(
+		const SCP_unordered_map<SCP_string, expression::ActionExpression>& parameterExpressions) const = 0;
+
+  private:
+	SCP_string m_name;
+	SCP_vector<ActionParameter> m_parameters;
+};
+
+} // namespace actions

code/actions/ActionDefinitionManager.cpp

@@ -0,0 +1,148 @@
+
+#include "ActionDefinitionManager.h"
+
+#include "BuiltinActionDefinition.h"
+
+#include "actions/types/MoveToSubmodel.h"
+#include "actions/types/ParticleEffectAction.h"
+#include "actions/types/PlaySoundAction.h"
+#include "actions/types/SetDirectionAction.h"
+#include "actions/types/SetPositionAction.h"
+#include "actions/types/WaitAction.h"
+#include "utils/join_string.h"
+
+namespace actions {
+namespace {
+
+void parseActionParameters(const SCP_vector<ActionParameter>& params,
+	SCP_unordered_map<SCP_string, expression::ActionExpression>& parameterExpressions,
+	const expression::ParseContext& context)
+{
+	// We do not impose a set order of the parameters so we need to do something similar to the outer loop and
+	// check for every possibility in a loop.
+	for (size_t i = 0; i < params.size(); ++i) {
+		// We might be doing some empty loops here in case of errors but there is a bound so this will finish
+		// eventually
+		for (const auto& parameter : params) {
+			// Do not check for parameters which we already found
+			if (parameterExpressions.find(parameter.name) != parameterExpressions.end()) {
+				continue;
+			}
+
+			const auto paramString = "+" + parameter.name + ":";
+
+			if (!optional_string(paramString.c_str())) {
+				continue;
+			}
+
+			// We found our parameter!
+			parameterExpressions[parameter.name] =
+				expression::ActionExpression::parseFromTable(parameter.type, context);
+			break;
+		}
+	}
+}
+
+} // namespace
+
+const ActionDefinitionManager& ActionDefinitionManager::instance()
+{
+	static const ActionDefinitionManager manager = []() {
+		ActionDefinitionManager newManager;
+
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::MoveToSubmodel>("Move To Subobject")));
+		newManager.addDefinition(std::unique_ptr<ActionDefinition>(
+			new BuiltinActionDefinition<types::ParticleEffectAction>("Start Particle Effect")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::PlaySoundAction>("Play 3D Sound")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetDirectionAction>("Set Direction")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::SetPositionAction>("Set Position")));
+		newManager.addDefinition(
+			std::unique_ptr<ActionDefinition>(new BuiltinActionDefinition<types::WaitAction>("Wait")));
+
+		return newManager;
+	}();
+	return manager;
+}
+void ActionDefinitionManager::addDefinition(std::unique_ptr<ActionDefinition> def)
+{
+	m_definitions.push_back(std::move(def));
+}
+std::unique_ptr<Action> ActionDefinitionManager::parseAction(const flagset<ProgramContextFlags>& context_flags,
+	const expression::ParseContext& context) const
+{
+	// We search through all definitions for every time we want to check for an action. This is not the most efficient
+	// way to handle this since it results in an O(n^2) runtime. A better alternative would be to either construct a
+	// regex with all the accepted actions as alternatives (although runtime of this is also doubtful) or peek at the
+	// next token, extract the relevant part (The stuff between "+" and ":") and then look that up in a map. Then we
+	// would get down to O(n).
+	// Since this only happens at parse time, this is good enough for now.
+	for (const auto& actionDef : m_definitions) {
+		const auto parseString = "+" + actionDef->getName() + ":";
+
+		if (!optional_string(parseString.c_str())) {
+			continue;
+		}
+
+		SCP_unordered_map<SCP_string, expression::ActionExpression> parameterExpressions;
+		const auto& params = actionDef->getParameters();
+
+		if (params.size() == 1) {
+			// Single parameters are expected to be placed directly after the action name
+			parameterExpressions[params.front().name] =
+				expression::ActionExpression::parseFromTable(params.front().type, context);
+		} else {
+			parseActionParameters(params, parameterExpressions, context);
+
+			if (parameterExpressions.size() != params.size()) {
+				SCP_vector<ActionParameter> missingParameters;
+				std::copy_if(params.cbegin(),
+					params.cend(),
+					std::back_inserter(missingParameters),
+					[&parameterExpressions](const ActionParameter& param) {
+						const auto iter = parameterExpressions.find(param.name);
+						return iter == parameterExpressions.cend();
+					});
+
+				SCP_vector<SCP_string> missingParameterNames;
+				std::transform(missingParameters.cbegin(),
+					missingParameters.cend(),
+					std::back_inserter(missingParameterNames),
+					[](const ActionParameter& param) { return "+" + param.name; });
+
+				const auto namesList = util::join_container(missingParameterNames, ", ");
+
+				error_display(0, "Missing parameters for action '%s': %s", parseString.c_str(), namesList.c_str());
+
+				// Fix up the parameter list so that we can continue parsing
+				for (const auto& missingParam : missingParameters) {
+					parameterExpressions[missingParam.name] = expression::ActionExpression();
+				}
+			}
+		}
+
+		auto actionInstance = actionDef->createAction(parameterExpressions);
+
+		const auto requiredFlags = actionDef->getRequiredContext();
+
+		if ((context_flags & requiredFlags) != requiredFlags) {
+			// We are missing at least one context flag so this action is not valid here. We still return the action
+			// here though since that is the only way we can keep parsing the table without throwing random error
+			// messages at the user. However, this will trigger an Assertion (in debug) or crashes when the action is
+			// actually run later.
+			error_display(0,
+				"The action %s is not available in the current context. This will lead to an Assertion failure when "
+				"this action is triggered.",
+				parseString.c_str());
+		}
+
+		return actionInstance;
+	}
+
+	return std::unique_ptr<Action>();
+}
+
+} // namespace actions

code/actions/ActionDefinitionManager.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "ActionDefinition.h"
+
+namespace actions {
+
+class ActionDefinitionManager {
+  public:
+	// This type is supposed to be global so it may not be copied
+	ActionDefinitionManager(const ActionDefinitionManager&) = delete;
+	ActionDefinitionManager& operator=(const ActionDefinitionManager&) = delete;
+
+	ActionDefinitionManager(ActionDefinitionManager&&) noexcept = default;
+	ActionDefinitionManager& operator=(ActionDefinitionManager&&) noexcept = default;
+
+	std::unique_ptr<Action> parseAction(const flagset<ProgramContextFlags>& context_flags,
+		const expression::ParseContext& context) const;
+
+	static const ActionDefinitionManager& instance();
+
+  private:
+	ActionDefinitionManager() = default;
+
+	void addDefinition(std::unique_ptr<ActionDefinition> def);
+
+	SCP_vector<std::unique_ptr<ActionDefinition>> m_definitions;
+};
+
+} // namespace actions

code/actions/BuiltinActionDefinition.cpp

@@ -0,0 +1,2 @@
+
+#include "BuiltinActionDefinition.h"

code/actions/BuiltinActionDefinition.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "ActionDefinition.h"
+
+#include "expression/Value.h"
+
+namespace actions {
+
+template <typename TAction>
+class BuiltinActionDefinition : public ActionDefinition {
+	using ActionValueType = typename TAction::ValueType;
+
+  public:
+	BuiltinActionDefinition(SCP_string name)
+		: ActionDefinition(std::move(name), {{"parameter", expression::ValueTypeTraits<ActionValueType>::type}})
+	{
+	}
+
+	flagset<ProgramContextFlags> getRequiredContext() const override
+	{
+		return flagset<ProgramContextFlags>(TAction::getRequiredExecutionContextFlags());
+	}
+
+	std::unique_ptr<Action> createAction(
+		const SCP_unordered_map<SCP_string, expression::ActionExpression>& parameterExpressions) const override
+	{
+		const auto paramIter = parameterExpressions.find("parameter");
+
+		// This should have been caught earlier
+		Assertion(paramIter != parameterExpressions.cend(), "Could not find built-in parameter!");
+
+		return std::unique_ptr<Action>(new TAction(paramIter->second.template asTyped<ActionValueType>()));
+	}
+};
+
+} // namespace actions

code/actions/Program.cpp

@@ -0,0 +1,174 @@
+
+#include "Program.h"
+
+#include "Action.h"
+
+#include "actions/ActionDefinitionManager.h"
+#include "executor/global_executors.h"
+#include "tracing/Monitor.h"
+#include "tracing/categories.h"
+#include "tracing/tracing.h"
+
+namespace {
+using namespace actions;
+
+tracing::Monitor<int> RunningProgramsMonitor("RunningPrograms", 0);
+
+struct ProgramRunner {
+	tracing::RunningCounter runningCounter{RunningProgramsMonitor};
+
+	ProgramInstance instance;
+
+	explicit ProgramRunner(const ProgramInstance& _instance) : instance(_instance) {}
+
+	executor::Executor::CallbackResult operator()()
+	{
+		TRACE_SCOPE(tracing::ProgramStepOne);
+
+		auto res = instance.step();
+
+		switch (res) {
+		case ProgramState::Running:
+			// If the program is still running then we need to reschedule our execution
+			return executor::Executor::CallbackResult::Reschedule;
+		case ProgramState::Done:
+		case ProgramState::Errored:
+		default:
+			return executor::Executor::CallbackResult::Done;
+		}
+	}
+};
+
+} // namespace
+
+namespace actions {
+
+ProgramInstance::ProgramInstance(const actions::Program* program) : _program(program) {}
+
+ProgramState ProgramInstance::step()
+{
+	if (!_locals.host.IsValid()) {
+		return ProgramState::Done;
+	}
+
+	auto& actions = _program->getActions();
+
+	for (; _currentInstruction < actions.size(); ++_currentInstruction) {
+		auto& action = actions[_currentInstruction];
+
+		auto result = action->execute(_locals);
+
+		if (result == ActionResult::Errored) {
+			return ProgramState::Errored;
+		}
+
+		if (result == ActionResult::Wait) {
+			// Action is not done yet, call again next frame
+			return ProgramState::Running;
+		}
+
+		// Action finished, run next action in program
+	}
+
+	// End of program reached, we are done now
+	return ProgramState::Done;
+}
+ProgramLocals& ProgramInstance::locals()
+{
+	return _locals;
+}
+const ProgramLocals& ProgramInstance::locals() const
+{
+	return _locals;
+}
+
+const SCP_vector<std::unique_ptr<actions::Action>>& Program::getActions() const
+{
+	return _actions;
+}
+
+Program::Program() = default;
+
+ProgramInstance Program::newInstance() const
+{
+	return ProgramInstance(this);
+}
+
+void Program::parseActions(const flagset<ProgramContextFlags>& context_flags, const expression::ParseContext& context)
+{
+	while (true) {
+		auto action = ActionDefinitionManager::instance().parseAction(context_flags, context);
+
+		if (!action) {
+			break;
+		}
+
+		_actions.push_back(std::move(action));
+	}
+}
+
+Program::Program(const Program& other) { *this = other; }
+Program& Program::operator=(const Program& other)
+{
+	_actions.clear();
+	_actions.reserve(other._actions.size());
+
+	for (auto& action : other._actions) {
+		_actions.emplace_back(action->clone());
+	}
+
+	return *this;
+}
+
+Program& Program::operator=(Program&&) noexcept = default;
+Program::Program(Program&&) noexcept = default;
+
+const SCP_vector<actions::Program>& ProgramSet::getPrograms() const
+{
+	return _programs;
+}
+
+ProgramSet::ProgramSet() = default;
+
+ProgramSet::ProgramSet(const flagset<ProgramContextFlags>& context_flags) : _contextFlags(context_flags) {}
+
+void ProgramSet::start(object* objp, const vec3d* local_pos, const matrix* local_orient, int submodel) const
+{
+	if (_contextFlags[ProgramContextFlags::HasObject]) {
+		Assertion(objp != nullptr, "Invalid object pointer supplied.");
+	}
+	if (_contextFlags[ProgramContextFlags::HasSubobject]) {
+		Assertion(submodel >= 0, "Invalid subobject supplied.");
+	}
+
+	for (const auto& prog : _programs) {
+		auto instance = prog.newInstance();
+
+		instance.locals().host = object_h(objp);
+		instance.locals().localPosition = *local_pos;
+		instance.locals().localOrient = *local_orient;
+		instance.locals().hostSubobject = submodel;
+		instance.locals().variables = getDefaultTableVariables();
+
+		// Just use the executor system to take care of running this program
+		executor::OnSimulationExecutor->post(ProgramRunner(instance));
+	}
+}
+
+ProgramSet ProgramSet::parseProgramSet(const char* tag, const flagset<ProgramContextFlags>& context_flags)
+{
+	ProgramSet set(context_flags);
+
+	const auto parseContext = getTableParseContext();
+
+	while (optional_string(tag)) {
+		Program p;
+		p.parseActions(context_flags, parseContext);
+
+		set._programs.push_back(std::move(p));
+	}
+
+	return set;
+}
+
+} // namespace actions

code/actions/Program.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include "globalincs/pstypes.h"
+
+#include "Action.h"
+#include "common.h"
+
+namespace actions {
+
+class Program;
+class ProgramSet;
+
+enum class ProgramState
+{
+	Running,
+	Done,
+	Errored
+};
+
+/**
+ * @brief An instance of a program execution
+ *
+ * A program instance contains all information related to a single execution of a program. A program instance is
+ * independent from other instances. Local variables used by actions are stored in a specific structure which can be
+ * used by actions to keep track of state in this specific instance.
+ */
+class ProgramInstance {
+	size_t _currentInstruction = 0;
+	ProgramLocals _locals;
+	const Program* _program = nullptr;
+
+  public:
+	explicit ProgramInstance(const Program* program);
+
+	ProgramState step();
+
+	ProgramLocals& locals();
+	const ProgramLocals& locals() const;
+};
+
+/**
+ * @brief A program specified in a table
+ *
+ * A program is a sequential collection of Actions which are executed in sequence.
+ */
+class Program {
+	SCP_vector<std::unique_ptr<Action>> _actions;
+
+  public:
+	Program();
+
+	Program(const Program& other);
+	Program& operator=(const Program& other);
+
+	Program(Program&& other) noexcept;
+	Program& operator=(Program&& other) noexcept;
+
+	const SCP_vector<std::unique_ptr<actions::Action>>& getActions() const;
+
+	/**
+	 * @brief Creates a new program instance from this program
+	 *
+	 * The program instance is initialized to its initial values.
+	 *
+	 * @return The new program instance
+	 */
+	ProgramInstance newInstance() const;
+
+	void parseActions(const flagset<ProgramContextFlags>& context_flags, const expression::ParseContext& context);
+};
+
+/**
+ * @brief A set of parsed programs
+ *
+ * Programs are parsed in sets of zero or more programs to make it possible for the content creator to split up
+ * programs.
+ */
+class ProgramSet {
+	flagset<ProgramContextFlags> _contextFlags;
+
+	SCP_vector<Program> _programs;
+
+  public:
+	ProgramSet();
+	explicit ProgramSet(const flagset<ProgramContextFlags>& context_flags);
+
+	const SCP_vector<actions::Program>& getPrograms() const;
+
+	/**
+	 * @brief Starts the execution of all programs within this set with the specified parameters
+	 * @param objp The object on which this program is executed
+	 * @param local_pos The local position relative to the object or the subsystem if specified
+	 * @param local_orien The local orientation relative to the object or the subsystem if specified
+	 * @param submodel The submodel of the model to which this program is attached to.
+	 */
+	void start(object* objp, const vec3d* local_pos, const matrix* local_orient, int submodel = -1) const;
+
+	/**
+	 * @brief Parses a program set of zero or more programs
+	 *
+	 * The tag is entirely optional and if it doesn't appear in the current table then an empty set will be returned
+	 * which does nothing if started.
+	 *
+	 * @param tag The tag which is required before a program can be specified
+	 * @param context_flags A set of flags which specify in which environment the program will be used. This is used
+	 * mainly for validating the used actions.
+	 * @return The parsed program set.
+	 */
+	static ProgramSet parseProgramSet(const char* tag, const flagset<ProgramContextFlags>& context_flags = {});
+};
+
+} // namespace actions

code/actions/common.cpp

@@ -0,0 +1,27 @@
+
+#include "common.h"
+
+namespace actions {
+
+expression::ParseContext getTableParseContext()
+{
+	expression::ParseContext ctx;
+
+	auto& locals = ctx.variables.addScope("locals");
+
+	locals.addMember("position", expression::ValueType::Vector);
+	locals.addMember("direction", expression::ValueType::Vector);
+
+	return ctx;
+}
+expression::ProgramVariables getDefaultTableVariables()
+{
+	expression::ProgramVariables vars;
+
+	vars.setValue({"locals", "position"}, expression::Value(vmd_zero_vector));
+	vars.setValue({"locals", "direction"}, expression::Value(vmd_zero_vector));
+
+	return vars;
+}
+
+} // namespace actions

code/actions/common.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "globalincs/flagset.h"
+
+#include "actions/expression/ParseContext.h"
+#include "actions/expression/ProgramVariables.h"
+#include "math/vecmat.h"
+#include "object/object.h"
+
+class object;
+class ship_subsys;
+
+namespace actions {
+
+struct ProgramLocals {
+	object_h host;
+	vec3d localPosition = vmd_zero_vector;
+	matrix localOrient = vmd_identity_matrix;
+	int hostSubobject = -1;
+
+	int waitTimestamp = 0;
+
+	expression::ProgramVariables variables;
+};
+
+/**
+ * @brief A list of flags for altering the program parsing behavior
+ *
+ * This should be used for differentiating between different program environments when validating the program (e.g. a
+ * particle effect requires an object host).
+ */
+// clang-format off
+FLAG_LIST(ProgramContextFlags) {
+	HasObject = 0, //!< The program will be started with an object host
+	HasSubobject,  //!< The program will be started with a subobject host
+
+	NUM_VALUES
+};
+// clang-format on
+
+/**
+ * @brief Constructs the "table" parse context
+ *
+ * This is the context that is available when parsing a program from an external table (e.g. ships or weapons).
+ *
+ * @return The parse context
+ */
+expression::ParseContext getTableParseContext();
+
+/**
+ * @brief Gets a program variables instance initialized with the default values
+ *
+ * The values are consistent with what is required for the default table parse context;
+ *
+ * @return The program variables
+ */
+expression::ProgramVariables getDefaultTableVariables();
+
+} // namespace actions

code/actions/expression/ActionExpression.cpp

@@ -0,0 +1,66 @@
+
+#include "ActionExpression.h"
+
+#include "ExpressionParser.h"
+#include "TypeDefinition.h"
+
+#include "actions/expression/nodes/AbstractExpression.h"
+
+namespace actions {
+namespace expression {
+namespace {
+
+SCP_string getTypeName(ValueType type)
+{
+	const auto& typeDef = TypeDefinition::forValueType(type);
+	return typeDef.getName();
+}
+
+} // namespace
+
+ActionExpression ActionExpression::parseFromTable(ValueType expectedReturnType, const ParseContext& context)
+{
+	SCP_string expressionText;
+
+	stuff_string(expressionText, F_NAME);
+
+	ExpressionParser parser(expressionText);
+
+	auto expression = parser.parse(context);
+
+	if (!expression) {
+		error_display(0, "Failed to parse action expression:\n%s", parser.getErrorText().c_str());
+		return ActionExpression();
+	}
+
+	auto type = expression->getExpressionType();
+
+	// Check if the type this evaluates to matches what we expect
+	if (!checkTypeWithImplicitConversion(type, expectedReturnType)) {
+		error_display(0,
+			"Expression evaluates to type <%s> but <%s> was expected!",
+			getTypeName(type).c_str(),
+			getTypeName(expectedReturnType).c_str());
+		return ActionExpression();
+	}
+
+	// Everything is valid
+	return ActionExpression(expression);
+}
+
+Value ActionExpression::execute(const ProgramVariables& variables) const
+{
+	// Do not crash on invalid expressions
+	if (!isValid()) {
+		return Value();
+	}
+
+	return m_expression->execute(variables);
+}
+bool ActionExpression::isValid() const
+{
+	return m_expression != nullptr;
+}
+
+} // namespace expression
+} // namespace actions

code/actions/expression/ActionExpression.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "ParseContext.h"
+#include "ProgramVariables.h"
+#include "TypeDefinition.h"
+
+#include "parse/parselo.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+class AbstractExpression;
+}
+template <typename T>
+class TypedActionExpression;
+
+class ActionExpression {
+  public:
+	ActionExpression() = default;
+
+	Value execute(const ProgramVariables& variables) const;
+
+	bool isValid() const;
+
+	template <typename T>
+	TypedActionExpression<T> asTyped() const;
+
+	static ActionExpression parseFromTable(ValueType expectedReturnType, const ParseContext& context);
+
+  protected:
+	explicit ActionExpression(std::shared_ptr<nodes::AbstractExpression> expression)
+		: m_expression(std::move(expression))
+	{
+	}
+
+	std::shared_ptr<nodes::AbstractExpression> m_expression;
+};
+
+template <typename T>
+class TypedActionExpression {
+  public:
+	explicit TypedActionExpression(ActionExpression expression) : m_expression(std::move(expression)) {}
+
+	T execute(const ProgramVariables& variables) const
+	{
+		// Do not crash on invalid expressions
+		if (!m_expression.isValid()) {
+			return T();
+		}
+
+		return m_expression.execute(variables).template get<T>();
+	}
+
+	static TypedActionExpression<T> parseFromTable(const ParseContext& context)
+	{
+		return ActionExpression::parseFromTable(ValueTypeTraits<T>::type, context).template asTyped<T>();
+	}
+
+  private:
+	ActionExpression m_expression;
+};
+
+template <typename T>
+TypedActionExpression<T> ActionExpression::asTyped() const
+{
+	return TypedActionExpression<T>(*this);
+}
+
+} // namespace expression
+} // namespace actions

code/actions/expression/ExpressionParser.cpp

@@ -0,0 +1,194 @@
+
+#include "ExpressionParser.h"
+
+#include "actions/expression/nodes/FunctionCallExpression.h"
+#include "actions/expression/nodes/LiteralExpression.h"
+#include "actions/expression/nodes/RandomRangeExpression.h"
+#include "actions/expression/nodes/VariableReferenceExpression.h"
+#include "actions/expression/nodes/VectorConstructorExpression.h"
+#include "libs/antlr/ErrorListener.h"
+
+PUSH_SUPPRESS_WARNINGS
+#include "action_expression/generated/ActionExpressionLexer.h"
+#include "action_expression/generated/ActionExpressionParser.h"
+#include "action_expression/generated/ActionExpressionVisitor.h"
+POP_SUPPRESS_WARNINGS
+
+namespace actions {
+namespace expression {
+
+namespace {
+
+class ExpressionBuilderVisitor : public ActionExpressionVisitor {
+  public:
+	antlrcpp::Any visitExpression_main(ActionExpressionParser::Expression_mainContext* context) override
+	{
+		return visit(context->expression());
+	}
+	antlrcpp::Any visitExpression(ActionExpressionParser::ExpressionContext* context) override
+	{
+		if (context->value_expression() != nullptr) {
+			return visit(context->value_expression());
+		}
+		if (context->parenthesis_expression()) {
+			return visit(context->parenthesis_expression());
+		}
+		if (context->random_range_expression()) {
+			return visit(context->random_range_expression());
+		}
+		if (context->variable_reference_expression()) {
+			return visit(context->variable_reference_expression());
+		}
+
+		// This is an operator so treat it as one.
+		antlr4::Token* operatorTok;
+		SCP_string operatorText;
+		if (context->PLUS() != nullptr) {
+			operatorTok = context->PLUS()->getSymbol();
+			operatorText = context->PLUS()->getText();
+		} else {
+			operatorTok = context->MINUS()->getSymbol();
+			operatorText = context->MINUS()->getText();
+		}
+
+		const auto leftExpr = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		const auto rightExpr = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();
+
+		auto operatorExpression = std::make_shared<nodes::FunctionCallExpression>(operatorTok,
+			true,
+			std::move(operatorText),
+			SCP_vector<std::shared_ptr<nodes::AbstractExpression>>{leftExpr, rightExpr});
+		return std::static_pointer_cast<nodes::AbstractExpression>(operatorExpression);
+	}
+	antlrcpp::Any visitVariable_reference_expression(
+		ActionExpressionParser::Variable_reference_expressionContext* context) override
+	{
+		const auto identifiers = context->IDENTIFIER();
+
+		SCP_vector<SCP_string> partNames;
+		partNames.reserve(identifiers.size());
+
+		std::transform(identifiers.begin(),
+			identifiers.end(),
+			std::back_inserter(partNames),
+			[](antlr4::tree::TerminalNode* node) { return node->getText(); });
+
+		SCP_vector<antlr4::Token*> partTokens;
+		partTokens.reserve(identifiers.size());
+
+		std::transform(identifiers.begin(),
+			identifiers.end(),
+			std::back_inserter(partTokens),
+			[](antlr4::tree::TerminalNode* node) { return node->getSymbol(); });
+
+		auto expression =
+			std::make_shared<nodes::VariableReferenceExpression>(std::move(partNames), std::move(partTokens));
+		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
+	}
+	antlrcpp::Any visitRandom_range_expression(ActionExpressionParser::Random_range_expressionContext* context) override
+	{
+		auto expression = std::make_shared<nodes::RandomRangeExpression>(context->RAND_L_PAREN()->getSymbol(),
+			visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>(),
+			visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>());
+		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
+	}
+	antlrcpp::Any visitLiteral_expression(ActionExpressionParser::Literal_expressionContext* context) override
+	{
+		std::shared_ptr<nodes::LiteralExpression> expression;
+
+		if (context->FLOAT() != nullptr) {
+			expression = std::make_shared<nodes::LiteralExpression>(context->FLOAT()->getSymbol(),
+				Value(std::stof(context->FLOAT()->getText())));
+		} else if (context->INT() != nullptr) {
+			expression = std::make_shared<nodes::LiteralExpression>(context->INT()->getSymbol(),
+				Value(std::stoi(context->INT()->getText())));
+		} else {
+			const auto idText = context->STRING()->getText();
+
+			// Cut off the first and last characters since those are the < > braces
+			expression = std::make_shared<nodes::LiteralExpression>(context->STRING()->getSymbol(),
+				Value(idText.substr(1, idText.size() - 2)));
+		}
+
+		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
+	}
+	antlrcpp::Any visitParenthesis_expression(ActionExpressionParser::Parenthesis_expressionContext* context) override
+	{
+		return visit(context->expression());
+	}
+	antlrcpp::Any visitValue_expression(ActionExpressionParser::Value_expressionContext* context) override
+	{
+		return visitChildren(context);
+	}
+	antlrcpp::Any visitVec3d_constructor(ActionExpressionParser::Vec3d_constructorContext* context) override
+	{
+		auto xExpression = visit(context->expression(0)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		auto yExpression = visit(context->expression(1)).as<std::shared_ptr<nodes::AbstractExpression>>();
+		auto zExpression = visit(context->expression(2)).as<std::shared_ptr<nodes::AbstractExpression>>();
+
+		auto expression = std::make_shared<nodes::VectorConstructorExpression>(context->L_PAREN()->getSymbol(),
+			xExpression,
+			yExpression,
+			zExpression);
+
+		return std::static_pointer_cast<nodes::AbstractExpression>(expression);
+	}
+};
+
+} // namespace
+
+ExpressionParser::ExpressionParser(SCP_string expressionText) : m_expressionText(std::move(expressionText)) {}
+
+std::shared_ptr<nodes::AbstractExpression> ExpressionParser::parse(const ParseContext& context)
+{
+	antlr4::ANTLRInputStream input(m_expressionText);
+	ActionExpressionLexer lexer(&input);
+	antlr4::CommonTokenStream tokens(&lexer);
+
+	::ActionExpressionParser parser(&tokens);
+	// By default we log to stderr which we do not want
+	parser.removeErrorListeners();
+	libs::antlr::ErrorListener errListener;
+	parser.addErrorListener(&errListener);
+
+	antlr4::tree::ParseTree* tree = parser.expression_main();
+
+	std::shared_ptr<nodes::AbstractExpression> exprReturn;
+	if (errListener.diagnostics.empty()) {
+		// Only do semantic checking if syntax is valid
+		ExpressionBuilderVisitor builder;
+		exprReturn = tree->accept(&builder).as<std::shared_ptr<nodes::AbstractExpression>>();
+
+		if (!exprReturn->validate(&parser, context)) {
+			exprReturn = nullptr;
+		} else {
+			exprReturn->validationDone();
+		}
+	}
+
+	if (!errListener.diagnostics.empty()) {
+		SCP_stringstream outStream;
+		for (const auto& diag : errListener.diagnostics) {
+			SCP_string tokenUnderline;
+			if (diag.tokenLength > 1) {
+				tokenUnderline = SCP_string(diag.tokenLength - 1, '~');
+			}
+			outStream << m_expressionText << "\n"
+					  << SCP_string(diag.columnInLine, ' ') << "^" << tokenUnderline << "\n"
+					  << diag.errorMessage << "\n";
+		}
+
+		m_errorText = outStream.str();
+		return nullptr;
+	}
+
+	return exprReturn;
+}
+
+const SCP_string& ExpressionParser::getErrorText() const
+{
+	return m_errorText;
+}
+
+} // namespace expression
+} // namespace actions

code/actions/expression/ExpressionParser.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "globalincs/pstypes.h"
+
+#include "ParseContext.h"
+
+#include "actions/expression/nodes/AbstractExpression.h"
+
+namespace actions {
+namespace expression {
+
+class ExpressionParser {
+  public:
+	ExpressionParser(SCP_string expressionText);
+
+	std::shared_ptr<nodes::AbstractExpression> parse(const ParseContext& context);
+
+	const SCP_string& getErrorText() const;
+
+  private:
+	SCP_string m_expressionText;
+
+	SCP_string m_errorText;
+};
+
+} // namespace expression
+} // namespace actions

code/actions/expression/FunctionManager.cpp

@@ -0,0 +1,93 @@
+
+#include "FunctionManager.h"
+
+#include "TypeDefinition.h"
+
+#include "math/vecmat.h"
+
+namespace actions {
+namespace expression {
+namespace {
+template <typename T>
+Value value_plus(const SCP_vector<Value>& parameters)
+{
+	return Value(parameters[0].get<T>() + parameters[1].get<T>());
+}
+template <typename T>
+Value value_minus(const SCP_vector<Value>& parameters)
+{
+	return Value(parameters[0].get<T>() - parameters[1].get<T>());
+}
+} // namespace
+
+const FunctionManager& FunctionManager::instance()
+{
+	static const FunctionManager manager = []() {
+		FunctionManager newManager;
+
+		newManager.addOperator("+", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_plus<int>);
+		newManager.addOperator("+", {ValueType::Float, ValueType::Float}, ValueType::Float, value_plus<float>);
+		newManager.addOperator("+", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_plus<vec3d>);
+
+		newManager.addOperator("-", {ValueType::Integer, ValueType::Integer}, ValueType::Integer, value_minus<int>);
+		newManager.addOperator("-", {ValueType::Float, ValueType::Float}, ValueType::Float, value_minus<float>);
+		newManager.addOperator("-", {ValueType::Vector, ValueType::Vector}, ValueType::Vector, value_minus<vec3d>);
+
+		return newManager;
+	}();
+	return manager;
+}
+void FunctionManager::addOperator(const SCP_string& name,
+	std::initializer_list<ValueType> parameterTypes,
+	ValueType returnType,
+	FunctionImplementation implementation)
+{
+	m_operators[name].push_back({name, parameterTypes, returnType, std::move(implementation)});
+}
+const FunctionDefinition* FunctionManager::findOperator(const SCP_string& name,
+	const SCP_vector<ValueType>& parameters) const
+{
+	const auto iter = m_operators.find(name);
+
+	if (iter == m_operators.end()) {
+		return nullptr;
+	}
+
+	// Prefer exact matches
+	for (const auto& funcDef : iter->second) {
+		if (funcDef.parameterTypes == parameters) {
+			return &funcDef;
+		}
+	}
+
+	// Now check if there are matches with implicit conversions
+	for (const auto& funcDef : iter->second) {
+		// Reject functions with different amount of elements
+		if (funcDef.parameterTypes.size() != parameters.size()) {
+			continue;
+		}
+
+		auto funcParamIter = funcDef.parameterTypes.cbegin();
+		auto actualParamIter = parameters.cbegin();
+
+		bool match = true;
+		for (; funcParamIter != funcDef.parameterTypes.cend(); ++funcParamIter, ++actualParamIter) {
+			if (!checkTypeWithImplicitConversion(*actualParamIter, *funcParamIter)) {
+				// Also doesn't match with implicit conversions
+				match = false;
+				break;
+			}
+		}
+
+		if (match) {
+			return &funcDef;
+		}
+	}
+
+	return nullptr;
+}
+
+FunctionManager::FunctionManager() = default;
+
+} // namespace expression
+} // namespace actions

code/actions/expression/FunctionManager.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "Value.h"
+
+namespace actions {
+namespace expression {
+
+using FunctionImplementation = std::function<Value(const SCP_vector<Value>& parameters)>;
+
+struct FunctionDefinition {
+	SCP_string name;
+
+	SCP_vector<ValueType> parameterTypes;
+
+	ValueType returnType;
+
+	FunctionImplementation implementation;
+};
+
+class FunctionManager {
+  public:
+	// This type is supposed to be global so it may not be copied
+	FunctionManager(const FunctionManager&) = delete;
+	FunctionManager& operator=(const FunctionManager&) = delete;
+
+	FunctionManager(FunctionManager&&) noexcept = default;
+	FunctionManager& operator=(FunctionManager&&) noexcept = default;
+
+	void addOperator(const SCP_string& name,
+		std::initializer_list<ValueType> parameterTypes,
+		ValueType returnType,
+		FunctionImplementation implementation);
+
+	const FunctionDefinition* findOperator(const SCP_string& name, const SCP_vector<ValueType>& parameterTypes) const;
+
+	static const FunctionManager& instance();
+
+  private:
+	FunctionManager();
+
+	SCP_unordered_map<SCP_string, SCP_vector<FunctionDefinition>> m_operators;
+};
+
+} // namespace expression
+} // namespace actions

code/actions/expression/ParseContext.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "ProgramVariables.h"
+
+namespace actions {
+namespace expression {
+
+struct ParseContext {
+	ProgramVariablesDefinition variables;
+};
+
+} // namespace expression
+} // namespace actions

code/actions/expression/ProgramVariables.cpp

@@ -0,0 +1,61 @@
+
+#include "ProgramVariables.h"
+
+namespace actions {
+namespace expression {
+
+ProgramVariablesDefinition& ProgramVariablesDefinition::addScope(const SCP_string& name)
+{
+	auto scope = std::unique_ptr<ProgramVariablesDefinition>(new ProgramVariablesDefinition());
+
+	auto scopePtr = scope.get();
+
+	m_scopes.insert(std::make_pair(name, std::move(scope)));
+
+	return *scopePtr;
+}
+void ProgramVariablesDefinition::addMember(const SCP_string& name, ValueType type)
+{
+	m_memberTypes[name] = type;
+}
+ProgramVariablesDefinition* ProgramVariablesDefinition::getScope(const SCP_string& name) const
+{
+	const auto iter = m_scopes.find(name);
+
+	if (iter == m_scopes.cend()) {
+		return nullptr;
+	}
+
+	return iter->second.get();
+}
+ValueType ProgramVariablesDefinition::getMemberType(const SCP_string& name) const
+{
+	const auto iter = m_memberTypes.find(name);
+
+	if (iter == m_memberTypes.cend()) {
+		return ValueType::Invalid;
+	}
+
+	return iter->second;
+}
+
+Value ProgramVariables::getValue(std::initializer_list<const char*> memberPathParts) const
+{
+	return getValue<decltype(memberPathParts)>(memberPathParts);
+}
+void ProgramVariables::setValue(std::initializer_list<const char*> memberPathParts, Value value)
+{
+	setValue<decltype(memberPathParts)>(memberPathParts, std::move(value));
+}
+Value ProgramVariables::getValue(const SCP_string& fullMemberName) const
+{
+	const auto iter = m_values.find(fullMemberName);
+
+	// This should have been validated earlier
+	Assertion(iter != m_values.end(), "Could not find member %s in variables!", fullMemberName.c_str());
+
+	return iter->second;
+}
+
+} // namespace expression
+} // namespace actions

code/actions/expression/ProgramVariables.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "Value.h"
+
+#include "utils/join_string.h"
+
+namespace actions {
+namespace expression {
+
+struct ProgramVariables {
+  public:
+	template <typename TContainer>
+	static SCP_string getMemberName(const TContainer& memberPathParts)
+	{
+		return util::join_container(memberPathParts, ".");
+	}
+
+	template <typename TContainer>
+	Value getValue(const TContainer& memberPathParts) const
+	{
+		const auto name = getMemberName(memberPathParts);
+
+		return getValue(name);
+	}
+
+	Value getValue(std::initializer_list<const char*> memberPathParts) const;
+
+	Value getValue(const SCP_string& fullMemberName) const;
+
+	template <typename TContainer>
+	void setValue(const TContainer& memberPathParts, Value value)
+	{
+		const auto name = getMemberName(memberPathParts);
+
+		m_values[name] = std::move(value);
+	}
+
+	void setValue(std::initializer_list<const char*> memberPathParts, Value value);
+
+  private:
+	SCP_unordered_map<SCP_string, Value> m_values;
+};
+
+class ProgramVariablesDefinition {
+  public:
+	ProgramVariablesDefinition& addScope(const SCP_string& name);
+
+	void addMember(const SCP_string& name, ValueType type);
+
+	ProgramVariablesDefinition* getScope(const SCP_string& name) const;
+
+	ValueType getMemberType(const SCP_string& name) const;
+
+  private:
+	SCP_unordered_map<SCP_string, std::unique_ptr<ProgramVariablesDefinition>> m_scopes;
+
+	SCP_unordered_map<SCP_string, ValueType> m_memberTypes;
+};
+
+} // namespace expression
+} // namespace actions

code/actions/expression/TypeDefinition.cpp

@@ -0,0 +1,60 @@
+
+#include "TypeDefinition.h"
+
+namespace actions {
+namespace expression {
+
+// Integers can be safely converted to floats (for the most part)
+TypeDefinition TypeDefinition::s_integer("Integer", {ValueType::Float});
+// No implicit conversions here
+TypeDefinition TypeDefinition::s_float("Float", {});
+TypeDefinition TypeDefinition::s_vector("Vector", {});
+// Identifiers are a technicality needed for making non-math values work but they have no further use other than their
+// string content
+TypeDefinition TypeDefinition::s_identifier("Identifier", {});
+
+TypeDefinition::TypeDefinition(SCP_string name, SCP_vector<actions::expression::ValueType> allowedImplicitConversion)
+	: m_name(std::move(name)), m_allowedImplicitConversions(std::move(allowedImplicitConversion))
+{
+}
+
+const SCP_string& TypeDefinition::getName() const
+{
+	return m_name;
+}
+const SCP_vector<actions::expression::ValueType>& TypeDefinition::getAllowedImplicitConversions() const
+{
+	return m_allowedImplicitConversions;
+}
+const TypeDefinition& TypeDefinition::forValueType(ValueType type)
+{
+	switch (type) {
+	case ValueType::Integer:
+		return s_integer;
+	case ValueType::Float:
+		return s_float;
+	case ValueType::Vector:
+		return s_vector;
+	case ValueType::String:
+		return s_identifier;
+	default:
+		UNREACHABLE("Invalid value type!");
+		return s_integer; // Make compiler happy
+	}
+}
+
+bool checkTypeWithImplicitConversion(ValueType currentType, ValueType expectedType)
+{
+	if (currentType == expectedType) {
+		// No need to consider implicit conversions;
+		return true;
+	}
+
+	const auto& currentTypeDef = TypeDefinition::forValueType(currentType);
+	const auto& allowedConversions = currentTypeDef.getAllowedImplicitConversions();
+
+	// For now, no transitiv conversions are allowed
+	return std::find(allowedConversions.cbegin(), allowedConversions.cend(), expectedType) != allowedConversions.cend();
+}
+} // namespace expression
+} // namespace actions

code/actions/expression/TypeDefinition.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "Value.h"
+
+namespace actions {
+namespace expression {
+
+class TypeDefinition {
+  public:
+	TypeDefinition(SCP_string name, SCP_vector<actions::expression::ValueType> allowedImplicitConversion);
+
+	const SCP_string& getName() const;
+
+	const SCP_vector<actions::expression::ValueType>& getAllowedImplicitConversions() const;
+
+	static const TypeDefinition& forValueType(ValueType type);
+
+	// This type is supposed to be global so it may not be copied
+	TypeDefinition(const TypeDefinition&) = delete;
+	TypeDefinition& operator=(const TypeDefinition&) = delete;
+
+	TypeDefinition(TypeDefinition&&) = delete;
+	TypeDefinition& operator=(TypeDefinition&&) = delete;
+
+  private:
+	SCP_string m_name;
+
+	// The types this type is allowed to implicitly convert to
+	SCP_vector<ValueType> m_allowedImplicitConversions;
+
+	static TypeDefinition s_integer;
+	static TypeDefinition s_float;
+	static TypeDefinition s_vector;
+	static TypeDefinition s_identifier;
+};
+
+bool checkTypeWithImplicitConversion(ValueType currentType, ValueType expectedType);
+
+} // namespace expression
+} // namespace actions

code/actions/expression/Value.cpp

@@ -0,0 +1,80 @@
+
+#include "Value.h"
+#include "math/vecmat.h"
+
+namespace actions {
+namespace expression {
+
+Value::Value(int val) : m_value(val) {}
+Value::Value(float val) : m_value(val) {}
+Value::Value(const vec3d& val) : m_value(val) {}
+Value::Value(SCP_string val) : m_value(std::move(val)) {}
+
+ValueType actions::expression::Value::getType() const
+{
+	switch (m_value.index()) {
+	case 1:
+		return ValueType::Integer;
+	case 2:
+		return ValueType::Float;
+	case 3:
+		return ValueType::Vector;
+	case 4:
+		return ValueType::String;
+	default:
+		return ValueType::Invalid;
+	}
+}
+
+int Value::getInteger() const
+{
+	return get<int>();
+}
+float Value::getFloat() const
+{
+	return get<float>();
+}
+vec3d Value::getVector() const
+{
+	return get<vec3d>();
+}
+SCP_string Value::getIdentifier() const
+{
+	return get<SCP_string>();
+}
+bool operator==(const Value& lhs, const Value& rhs)
+{
+	return lhs.m_value == rhs.m_value;
+}
+bool operator!=(const Value& lhs, const Value& rhs)
+{
+	return !(rhs == lhs);
+}
+std::ostream& operator<<(std::ostream& os, const Value& value)
+{
+	os << "Value<";
+
+	switch (value.getType()) {
+	case ValueType::Invalid:
+		os << "INVALID";
+		break;
+	case ValueType::Integer:
+		os << value.get<int>();
+		break;
+	case ValueType::Float:
+		os << value.get<float>();
+		break;
+	case ValueType::Vector:
+		os << value.get<vec3d>();
+		break;
+	case ValueType::String:
+		os << value.get<SCP_string>();
+		break;
+	}
+
+	os << ">";
+	return os;
+}
+
+} // namespace expression
+} // namespace actions

code/actions/expression/Value.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include "globalincs/pstypes.h"
+
+#include <mpark/variant.hpp>
+
+namespace actions {
+namespace expression {
+
+namespace detail {
+template <typename ToType>
+struct implicit_conversion {
+	template <typename T>
+	ToType operator()(const T&)
+	{
+		throw std::runtime_error("Invalid implicit conversion.");
+	}
+};
+
+template<>
+struct implicit_conversion<float> {
+	inline float operator()(int val) {
+		return i2fl(val);
+	}
+
+	template <typename T>
+	float operator()(const T&)
+	{
+		throw std::runtime_error("Invalid implicit conversion.");
+	}
+};
+
+} // namespace detail
+
+enum class ValueType
+{
+	Invalid,
+	Integer,
+	Float,
+	Vector,
+	String,
+};
+
+template <typename T>
+struct ValueTypeTraits;
+
+template <>
+struct ValueTypeTraits<int> {
+	static constexpr ValueType type = ValueType::Integer;
+};
+template <>
+struct ValueTypeTraits<float> {
+	static constexpr ValueType type = ValueType::Float;
+};
+template <>
+struct ValueTypeTraits<vec3d> {
+	static constexpr ValueType type = ValueType::Vector;
+};
+template <>
+struct ValueTypeTraits<SCP_string> {
+	static constexpr ValueType type = ValueType::String;
+};
+
+class Value {
+  public:
+	Value() = default;
+
+	explicit Value(int val);
+	explicit Value(float val);
+	explicit Value(const vec3d& val);
+	explicit Value(SCP_string val);
+
+	ValueType getType() const;
+
+	int getInteger() const;
+	float getFloat() const;
+	vec3d getVector() const;
+	SCP_string getIdentifier() const;
+
+	template <typename T>
+	T get() const
+	{
+		const auto currentType = getType();
+		const auto expectedType = ValueTypeTraits<T>::type;
+
+		if (currentType == expectedType) {
+			// No conversion necessary
+			return mpark::get<T>(m_value);
+		}
+
+		return mpark::visit(detail::implicit_conversion<T>{}, m_value);
+	}
+
+	friend bool operator==(const Value& lhs, const Value& rhs);
+	friend bool operator!=(const Value& lhs, const Value& rhs);
+
+	friend std::ostream& operator<<(std::ostream& os, const Value& value);
+
+  private:
+	mpark::variant<mpark::monostate, int, float, vec3d, SCP_string> m_value;
+};
+
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/AbstractExpression.cpp

@@ -0,0 +1,31 @@
+
+#include "AbstractExpression.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+AbstractExpression::AbstractExpression(antlr4::Token* token) : m_token(token) {}
+AbstractExpression::~AbstractExpression() = default;
+
+antlr4::Token* AbstractExpression::getToken() const
+{
+	return m_token;
+}
+ValueType AbstractExpression::getExpressionType() const
+{
+	// Since expressions are immutable, caching this will be more efficient
+	if (m_cachedType == ValueType::Invalid) {
+		m_cachedType = determineReturnType();
+	}
+	return m_cachedType;
+}
+void AbstractExpression::validationDone()
+{
+	// This pointer will become invalid after this so reset it now to avoid issues
+	m_token = nullptr;
+}
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/AbstractExpression.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "actions/expression/ParseContext.h"
+#include "actions/expression/Value.h"
+
+#include <Parser.h>
+#include <Token.h>
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+class AbstractExpression {
+  public:
+	AbstractExpression(antlr4::Token* token);
+	virtual ~AbstractExpression();
+
+	virtual Value execute(const ProgramVariables& variables) const = 0;
+
+	virtual bool validate(antlr4::Parser* parser, const ParseContext& context) = 0;
+
+	virtual void validationDone();
+
+	ValueType getExpressionType() const;
+
+	antlr4::Token* getToken() const;
+
+  protected:
+	virtual ValueType determineReturnType() const = 0;
+
+	antlr4::Token* m_token = nullptr;
+
+	mutable ValueType m_cachedType = ValueType::Invalid;
+};
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/FunctionCallExpression.cpp

@@ -0,0 +1,95 @@
+
+#include "FunctionCallExpression.h"
+
+#include "actions/expression/TypeDefinition.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+FunctionCallExpression::FunctionCallExpression(antlr4::Token* token,
+	bool isOperator,
+	SCP_string functionName,
+	SCP_vector<std::shared_ptr<AbstractExpression>> parameterExpressions)
+	: AbstractExpression(token), m_isOperator(isOperator), m_functionName(std::move(functionName)),
+	  m_parameterExpressions(std::move(parameterExpressions))
+{
+}
+FunctionCallExpression::~FunctionCallExpression() = default;
+
+Value FunctionCallExpression::execute(const ProgramVariables& variables) const
+{
+	SCP_vector<Value> parameterValues;
+	parameterValues.reserve(m_parameterExpressions.size());
+
+	std::transform(m_parameterExpressions.cbegin(),
+		m_parameterExpressions.cend(),
+		std::back_inserter(parameterValues),
+		[&variables](const std::shared_ptr<AbstractExpression>& expression) { return expression->execute(variables); });
+
+	return m_functionDef->implementation(parameterValues);
+}
+bool FunctionCallExpression::validate(antlr4::Parser* parser, const ParseContext& context)
+{
+	bool valid = true;
+
+	for (const auto& paramExpression : m_parameterExpressions) {
+		valid &= paramExpression->validate(parser, context);
+	}
+
+	if (!valid) {
+		// Exit early if there were errors since the values below are meaningless otherwise
+		return false;
+	}
+
+	Assertion(m_isOperator, "Non-operator functions are not supported yet!");
+
+	SCP_vector<ValueType> parameterTypes;
+
+	std::transform(m_parameterExpressions.cbegin(),
+		m_parameterExpressions.cend(),
+		std::back_inserter(parameterTypes),
+		[](const std::shared_ptr<AbstractExpression>& expression) { return expression->getExpressionType(); });
+
+	const auto functionDef = FunctionManager::instance().findOperator(m_functionName, parameterTypes);
+
+	if (functionDef == nullptr) {
+		SCP_stringstream paramListStream;
+		if (!parameterTypes.empty()) {
+			paramListStream << "<" << TypeDefinition::forValueType(parameterTypes.front()).getName() << ">";
+
+			for (auto iter = parameterTypes.cbegin() + 1; iter != parameterTypes.cend(); ++iter) {
+				paramListStream << ", <" << TypeDefinition::forValueType(*iter).getName() << ">";
+			}
+		}
+
+		parser->notifyErrorListeners(m_token,
+			SCP_string("Could not find a definition for the ") + (m_isOperator ? "operator" : "function") + " '" +
+				m_functionName + "' with parameters (" + paramListStream.str() + ")",
+			nullptr);
+		return false;
+	}
+
+	m_functionDef = functionDef;
+	return true;
+}
+ValueType FunctionCallExpression::determineReturnType() const
+{
+	return m_functionDef->returnType;
+}
+void FunctionCallExpression::validationDone()
+{
+	AbstractExpression::validationDone();
+
+	// We no longer need this so we can save some memory
+	m_functionName.clear();
+	m_functionName.shrink_to_fit();
+
+	for (const auto& paramExpression : m_parameterExpressions) {
+		paramExpression->validationDone();
+	}
+}
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/FunctionCallExpression.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "AbstractExpression.h"
+
+#include "actions/expression/FunctionManager.h"
+#include "actions/expression/Value.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+class FunctionCallExpression : public AbstractExpression {
+  public:
+	FunctionCallExpression(antlr4::Token* token,
+		bool isOperator,
+		SCP_string functionName,
+		SCP_vector<std::shared_ptr<AbstractExpression>> parameterExpressions);
+	~FunctionCallExpression() override;
+
+	Value execute(const ProgramVariables& variables) const override;
+	bool validate(antlr4::Parser* parser, const ParseContext& context) override;
+	void validationDone() override;
+
+  protected:
+	ValueType determineReturnType() const override;
+
+  private:
+	bool m_isOperator;
+	SCP_string m_functionName;
+
+	const FunctionDefinition* m_functionDef = nullptr;
+
+	SCP_vector<std::shared_ptr<AbstractExpression>> m_parameterExpressions;
+};
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/LiteralExpression.cpp

@@ -0,0 +1,30 @@
+
+#include "LiteralExpression.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+LiteralExpression::LiteralExpression(antlr4::Token* token, Value literalValue)
+	: AbstractExpression(token), m_literalValue(std::move(literalValue))
+{
+}
+LiteralExpression::~LiteralExpression() = default;
+
+Value LiteralExpression::execute(const ProgramVariables& /*variables*/) const
+{
+	return m_literalValue;
+}
+bool LiteralExpression::validate(antlr4::Parser* /*parser*/, const ParseContext& /*context*/)
+{
+	// Literals are always valid
+	return true;
+}
+ValueType LiteralExpression::determineReturnType() const
+{
+	return m_literalValue.getType();
+}
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/LiteralExpression.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "AbstractExpression.h"
+
+#include "actions/expression/Value.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+class LiteralExpression : public AbstractExpression {
+  public:
+	LiteralExpression(antlr4::Token* token, Value literalValue);
+	~LiteralExpression() override;
+
+	Value execute(const ProgramVariables& variables) const override;
+	bool validate(antlr4::Parser* parser, const ParseContext& context) override;
+
+  protected:
+	ValueType determineReturnType() const override;
+
+  private:
+	Value m_literalValue;
+};
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/RandomRangeExpression.cpp

@@ -0,0 +1,108 @@
+
+#include "RandomRangeExpression.h"
+
+#include "actions/expression/TypeDefinition.h"
+#include "utils/RandomRange.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+namespace {
+
+template <typename T>
+Value executeHelper(const Value& leftVal, const Value& rightVal)
+{
+	auto leftContentVal = leftVal.get<T>();
+	auto rightContentVal = rightVal.get<T>();
+
+	if (leftContentVal == rightContentVal) {
+		// no need to do random stuff here
+		return Value(rightContentVal);
+	}
+
+	if (rightContentVal < leftContentVal) {
+		// We can fix this issue
+		std::swap(leftContentVal, rightContentVal);
+	}
+
+	// Might be a bit inefficient not to cache this somehow but the bounds can be dynamic
+	return Value(util::UniformRange<T>(leftContentVal, rightContentVal).next());
+}
+} // namespace
+
+RandomRangeExpression::RandomRangeExpression(antlr4::Token* token,
+	std::shared_ptr<AbstractExpression> leftExpression,
+	std::shared_ptr<AbstractExpression> rightExpression)
+	: AbstractExpression(token), m_leftExpression(std::move(leftExpression)),
+	  m_rightExpression(std::move(rightExpression))
+{
+}
+RandomRangeExpression::~RandomRangeExpression() = default;
+
+Value RandomRangeExpression::execute(const ProgramVariables& variables) const
+{
+	const auto leftVal = m_leftExpression->execute(variables);
+	const auto rightVal = m_rightExpression->execute(variables);
+
+	if (leftVal.getType() == ValueType::Integer) {
+		return executeHelper<int>(leftVal, rightVal);
+	} else {
+		return executeHelper<float>(leftVal, rightVal);
+	}
+}
+bool RandomRangeExpression::validate(antlr4::Parser* parser, const ParseContext& context)
+{
+	bool valid = true;
+
+	valid &= m_leftExpression->validate(parser, context);
+	valid &= m_rightExpression->validate(parser, context);
+
+	if (!valid) {
+		// Exit early if there were errors since the values below are meaningless otherwise
+		return false;
+	}
+
+	const auto leftType = m_leftExpression->getExpressionType();
+	const auto rightType = m_rightExpression->getExpressionType();
+
+	const auto& leftTypedef = TypeDefinition::forValueType(leftType);
+	const auto& rightTypedef = TypeDefinition::forValueType(rightType);
+
+	// Both values must be the same
+	if (leftType != rightType) {
+		parser->notifyErrorListeners(m_rightExpression->getToken(),
+			"Inconsistent types for random range. Must be the same but got <" + leftTypedef.getName() + "> and <" +
+				rightTypedef.getName() + ">.",
+			nullptr);
+		return false;
+	}
+
+	// And we only support floats or integers
+	if (leftType != ValueType::Float && leftType != ValueType::Integer) {
+		parser->notifyErrorListeners(m_leftExpression->getToken(),
+			"Invalid parameter type for random range. Must be <Float> or <Integer> but got <" + leftTypedef.getName() +
+				">.",
+			nullptr);
+		return false;
+	}
+
+	// Everything is fine.
+	return true;
+}
+ValueType RandomRangeExpression::determineReturnType() const
+{
+	// Return type is the same as the contained return types
+	return m_leftExpression->getExpressionType();
+}
+void RandomRangeExpression::validationDone()
+{
+	AbstractExpression::validationDone();
+
+	m_leftExpression->validationDone();
+	m_rightExpression->validationDone();
+}
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/RandomRangeExpression.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "AbstractExpression.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+class RandomRangeExpression : public AbstractExpression {
+  public:
+	RandomRangeExpression(antlr4::Token* token,
+		std::shared_ptr<AbstractExpression> leftExpression,
+		std::shared_ptr<AbstractExpression> rightExpression);
+	~RandomRangeExpression() override;
+
+	Value execute(const ProgramVariables& variables) const override;
+	bool validate(antlr4::Parser* parser, const ParseContext& context) override;
+	void validationDone() override;
+
+  protected:
+	ValueType determineReturnType() const override;
+
+  private:
+	std::shared_ptr<AbstractExpression> m_leftExpression;
+	std::shared_ptr<AbstractExpression> m_rightExpression;
+};
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/VariableReferenceExpression.cpp

@@ -0,0 +1,69 @@
+
+#include "VariableReferenceExpression.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+VariableReferenceExpression::VariableReferenceExpression(SCP_vector<SCP_string> references,
+	SCP_vector<antlr4::Token*> referenceTokens)
+	: AbstractExpression(referenceTokens.back()), m_references(std::move(references)),
+	  m_referenceTokens(std::move(referenceTokens))
+{
+}
+VariableReferenceExpression::~VariableReferenceExpression() = default;
+
+Value VariableReferenceExpression::execute(const ProgramVariables& variables) const
+{
+	return variables.getValue(m_fullVariablePath);
+}
+bool VariableReferenceExpression::validate(antlr4::Parser* parser, const ParseContext& context)
+{
+	// Start out in the global scope
+	auto currentScope = &context.variables;
+	SCP_string currentScopeName("<global>");
+
+	for (size_t i = 0; i < m_references.size() - 1; ++i) {
+		const auto nextScope = currentScope->getScope(m_references[i]);
+
+		if (nextScope == nullptr) {
+			parser->notifyErrorListeners(m_referenceTokens[i],
+				"Could not find scope " + m_references[i] + " in scope " + currentScopeName + ".",
+				nullptr);
+			return false;
+		}
+
+		currentScope = nextScope;
+		currentScopeName = m_references[i];
+	}
+
+	auto variableType = currentScope->getMemberType(m_references.back());
+
+	if (variableType == ValueType::Invalid) {
+		parser->notifyErrorListeners(m_referenceTokens.back(),
+			"Could not find variable " + m_references.back() + " in scope " + currentScopeName + ".",
+			nullptr);
+		return false;
+	}
+
+	// Cache this so we don't duplicate all this code in determineReturnType()
+	m_variableType = variableType;
+	m_fullVariablePath = ProgramVariables::getMemberName(m_references);
+	return true;
+}
+ValueType VariableReferenceExpression::determineReturnType() const
+{
+	return m_variableType;
+}
+void VariableReferenceExpression::validationDone()
+{
+	AbstractExpression::validationDone();
+
+	// Clear these since they are not necessary anymore
+	m_references.clear();
+	m_referenceTokens.clear();
+}
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/VariableReferenceExpression.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "AbstractExpression.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+class VariableReferenceExpression : public AbstractExpression {
+  public:
+	VariableReferenceExpression(const SCP_vector<SCP_string> references,
+		SCP_vector<antlr4::Token*> referenceTokens);
+	~VariableReferenceExpression() override;
+
+	Value execute(const ProgramVariables& variables) const override;
+	bool validate(antlr4::Parser* parser, const ParseContext& context) override;
+	void validationDone() override;
+
+  protected:
+	ValueType determineReturnType() const override;
+
+  private:
+	ValueType m_variableType = ValueType::Invalid;
+	SCP_string m_fullVariablePath;
+
+	SCP_vector<SCP_string> m_references;
+	SCP_vector<antlr4::Token*> m_referenceTokens;
+};
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/VectorConstructorExpression.cpp

@@ -0,0 +1,87 @@
+
+#include "VectorConstructorExpression.h"
+
+#include "actions/expression/TypeDefinition.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+VectorConstructorExpression::VectorConstructorExpression(antlr4::Token* token,
+	std::shared_ptr<AbstractExpression> xExpression,
+	std::shared_ptr<AbstractExpression> yExpression,
+	std::shared_ptr<AbstractExpression> zExpression)
+	: AbstractExpression(token), m_xExpression(std::move(xExpression)), m_yExpression(std::move(yExpression)),
+	  m_zExpression(std::move(zExpression))
+{
+}
+VectorConstructorExpression::~VectorConstructorExpression() = default;
+
+Value VectorConstructorExpression::execute(const ProgramVariables& variables) const
+{
+	auto xValue = m_xExpression->execute(variables);
+	auto yValue = m_yExpression->execute(variables);
+	auto zValue = m_zExpression->execute(variables);
+
+	vec3d vecVal;
+
+	vecVal.xyz.x = xValue.getFloat();
+	vecVal.xyz.y = yValue.getFloat();
+	vecVal.xyz.z = zValue.getFloat();
+
+	return Value(vecVal);
+}
+bool VectorConstructorExpression::validate(antlr4::Parser* parser, const ParseContext& context)
+{
+	bool valid = true;
+
+	valid &= m_xExpression->validate(parser, context);
+	valid &= m_yExpression->validate(parser, context);
+	valid &= m_zExpression->validate(parser, context);
+
+	if (!valid) {
+		// Exit early if there were errors since the values below are meaningless otherwise
+		return false;
+	}
+
+	if (!checkTypeWithImplicitConversion(m_xExpression->getExpressionType(), ValueType::Float)) {
+		const auto& typeDef = TypeDefinition::forValueType(m_xExpression->getExpressionType());
+		parser->notifyErrorListeners(m_xExpression->getToken(),
+			"Invalid value type for vector constructor. Expected <Float>, got <" + typeDef.getName() + ">",
+			nullptr);
+		valid = false;
+	}
+	if (!checkTypeWithImplicitConversion(m_yExpression->getExpressionType(), ValueType::Float)) {
+		const auto& typeDef = TypeDefinition::forValueType(m_yExpression->getExpressionType());
+		parser->notifyErrorListeners(m_yExpression->getToken(),
+			"Invalid value type for vector constructor. Expected <Float>, got <" + typeDef.getName() + ">",
+			nullptr);
+		valid = false;
+	}
+	if (!checkTypeWithImplicitConversion(m_zExpression->getExpressionType(), ValueType::Float)) {
+		const auto& typeDef = TypeDefinition::forValueType(m_zExpression->getExpressionType());
+		parser->notifyErrorListeners(m_zExpression->getToken(),
+			"Invalid value type for vector constructor. Expected <Float>, got <" + typeDef.getName() + ">",
+			nullptr);
+		valid = false;
+	}
+
+	return valid;
+}
+ValueType VectorConstructorExpression::determineReturnType() const
+{
+	// No need to look at the expressions here since we will always be a vector
+	return ValueType::Vector;
+}
+void VectorConstructorExpression::validationDone()
+{
+	AbstractExpression::validationDone();
+
+	m_xExpression->validationDone();
+	m_yExpression->validationDone();
+	m_zExpression->validationDone();
+}
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/expression/nodes/VectorConstructorExpression.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "AbstractExpression.h"
+
+#include "actions/expression/Value.h"
+
+namespace actions {
+namespace expression {
+namespace nodes {
+
+class VectorConstructorExpression : public AbstractExpression {
+  public:
+	VectorConstructorExpression(antlr4::Token* token,
+		std::shared_ptr<AbstractExpression> xExpression,
+		std::shared_ptr<AbstractExpression> yExpression,
+		std::shared_ptr<AbstractExpression> zExpression);
+	~VectorConstructorExpression() override;
+
+	Value execute(const ProgramVariables& variables) const override;
+	bool validate(antlr4::Parser* parser, const ParseContext& context) override;
+	void validationDone() override;
+
+  protected:
+	ValueType determineReturnType() const override;
+
+  private:
+	std::shared_ptr<AbstractExpression> m_xExpression;
+	std::shared_ptr<AbstractExpression> m_yExpression;
+	std::shared_ptr<AbstractExpression> m_zExpression;
+};
+
+} // namespace nodes
+} // namespace expression
+} // namespace actions

code/actions/types/MoveToSubmodel.cpp

@@ -0,0 +1,79 @@
+
+#include "MoveToSubmodel.h"
+
+#include "math/vecmat.h"
+#include "parse/parselo.h"
+#include "ship/ship.h"
+
+#include <utility>
+
+namespace actions {
+namespace types {
+
+flagset<ProgramContextFlags> MoveToSubmodel::getRequiredExecutionContextFlags()
+{
+	return flagset<ProgramContextFlags>{ProgramContextFlags::HasObject, ProgramContextFlags::HasSubobject};
+}
+
+MoveToSubmodel::MoveToSubmodel(expression::TypedActionExpression<ValueType> subObjectExpression)
+	: m_subObjectExpression(std::move(subObjectExpression))
+{
+}
+MoveToSubmodel::~MoveToSubmodel() = default;
+
+ActionResult MoveToSubmodel::execute(ProgramLocals& locals) const
+{
+	// The calling code should ensure that this never happens
+	Assertion(locals.hostSubobject >= 0, "Did not have a valid host subobject.");
+
+	auto instance = object_get_model_instance(locals.host.objp);
+	Assertion(instance != -1, "Model instances are required if a host subobject is specified.");
+
+	auto pmi = model_get_instance(instance);
+	auto pm = model_get(pmi->model_num);
+
+	const auto destinationSubObject = m_subObjectExpression.execute(locals.variables);
+	bool goToParent = false;
+	if (destinationSubObject == "<parent>") {
+		goToParent = true;
+	}
+
+	if (goToParent) {
+		// Special case when we simply want to go to our parent without explicitly specifying its name
+		auto parentSubobject = pm->submodel[locals.hostSubobject].parent;
+
+		if (parentSubobject < 0) {
+			Warning(LOCATION,
+				"Current program subobject %s on model %s has no parent!",
+				pm->submodel[locals.hostSubobject].name,
+				pm->filename);
+			return ActionResult::Errored;
+		}
+
+		// We have a valid parent so this move will work properly
+		locals.hostSubobject = parentSubobject;
+		return ActionResult::Finished;
+	}
+
+	// We need to do a linear search for the right subobject
+	for (int i = 0; i < pm->n_models; ++i) {
+		const auto submodel = pm->submodel[i];
+
+		if (subsystem_stricmp(destinationSubObject.c_str(), submodel.name) == 0) {
+			// Found something!
+			locals.hostSubobject = i;
+			return ActionResult::Finished;
+		}
+	}
+
+	Warning(LOCATION, "Could not find subobject %s in model %s!", destinationSubObject.c_str(), pm->filename);
+	return ActionResult::Errored;
+}
+
+std::unique_ptr<Action> MoveToSubmodel::clone() const
+{
+	return std::unique_ptr<Action>(new MoveToSubmodel(*this));
+}
+
+} // namespace types
+} // namespace actions

code/actions/types/MoveToSubmodel.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "globalincs/flagset.h"
+
+#include "actions/Action.h"
+#include "actions/expression/ActionExpression.h"
+
+namespace actions {
+namespace types {
+
+class MoveToSubmodel : public Action {
+  public:
+	using ValueType = SCP_string;
+
+	static flagset<ProgramContextFlags> getRequiredExecutionContextFlags();
+
+	explicit MoveToSubmodel(expression::TypedActionExpression<ValueType> subObjectExpression);
+	~MoveToSubmodel() override;
+
+	ActionResult execute(ProgramLocals& locals) const override;
+
+	std::unique_ptr<Action> clone() const override;
+
+  private:
+	expression::TypedActionExpression<ValueType> m_subObjectExpression;
+};
+
+} // namespace types
+} // namespace actions

code/actions/types/ParticleEffectAction.cpp

@@ -0,0 +1,76 @@
+
+#include "ParticleEffectAction.h"
+
+#include "math/vecmat.h"
+#include "parse/parselo.h"
+#include "ship/ship.h"
+
+#include <utility>
+
+namespace actions {
+namespace types {
+
+flagset<ProgramContextFlags> ParticleEffectAction::getRequiredExecutionContextFlags()
+{
+	return flagset<ProgramContextFlags>{ProgramContextFlags::HasObject};
+}
+
+ParticleEffectAction::ParticleEffectAction(expression::TypedActionExpression<ValueType> effectExpression)
+	: m_effectExpression(std::move(effectExpression))
+{
+}
+ParticleEffectAction::~ParticleEffectAction() = default;
+
+ActionResult ParticleEffectAction::execute(ProgramLocals& locals) const
+{
+	auto effectIdx = particle::ParticleManager::get()->getEffectByName(m_effectExpression.execute(locals.variables));
+
+	if (!effectIdx.isValid()) {
+		// In case the parsing code failed
+		return ActionResult::Errored;
+	}
+
+	using namespace particle;
+
+	auto source = ParticleManager::get()->createSource(effectIdx);
+
+	vec3d local_pos;
+	matrix local_orient;
+	if (locals.hostSubobject != -1) {
+		auto instance = object_get_model_instance(locals.host.objp);
+		Assertion(instance != -1, "Model instances are required if a host subobject is specified.");
+
+		auto pmi = model_get_instance(instance);
+		auto pm = model_get(pmi->model_num);
+
+		find_submodel_instance_point_orient(&local_pos,
+			&local_orient,
+			pm,
+			pmi,
+			locals.hostSubobject,
+			&locals.localPosition,
+			&locals.localOrient);
+	} else {
+		local_pos = locals.localPosition;
+		local_orient = locals.localOrient;
+	}
+
+	local_pos += locals.variables.getValue({"locals", "position"}).getVector();
+
+	auto direction = locals.variables.getValue({"locals", "direction"}).getVector();
+
+	source.moveToObject(locals.host.objp, &local_pos);
+	source.setOrientationFromNormalizedVec(&direction, true);
+
+	source.finish();
+
+	return ActionResult::Finished;
+}
+
+std::unique_ptr<Action> ParticleEffectAction::clone() const
+{
+	return std::unique_ptr<Action>(new ParticleEffectAction(*this));
+}
+
+} // namespace types
+} // namespace actions

code/actions/types/ParticleEffectAction.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "actions/Action.h"
+#include "actions/expression/ActionExpression.h"
+#include "particle/ParticleManager.h"
+
+namespace actions {
+namespace types {
+
+class ParticleEffectAction : public Action {
+
+  public:
+	using ValueType = SCP_string;
+
+	static flagset<ProgramContextFlags> getRequiredExecutionContextFlags();
+
+	explicit ParticleEffectAction(expression::TypedActionExpression<ValueType> effectExpression);
+	~ParticleEffectAction() override;
+
+	ActionResult execute(ProgramLocals& locals) const override;
+
+	std::unique_ptr<Action> clone() const override;
+
+  private:
+	expression::TypedActionExpression<ValueType> m_effectExpression;
+};
+
+} // namespace types
+} // namespace actions

code/actions/types/PlaySoundAction.cpp

@@ -0,0 +1,65 @@
+//
+//
+
+#include "PlaySoundAction.h"
+
+#include "ship/ship.h"
+
+#include <utility>
+
+namespace actions {
+namespace types {
+
+flagset<ProgramContextFlags> PlaySoundAction::getRequiredExecutionContextFlags()
+{
+	return flagset<ProgramContextFlags>{ProgramContextFlags::HasObject};
+}
+
+PlaySoundAction::PlaySoundAction(expression::TypedActionExpression<ValueType> soundIdExpression)
+	: m_soundIdExpression(std::move(soundIdExpression))
+{
+}
+PlaySoundAction::~PlaySoundAction() = default;
+
+ActionResult PlaySoundAction::execute(ProgramLocals& locals) const
+{
+	vec3d local_pos;
+	matrix local_orient;
+	if (locals.hostSubobject != -1) {
+		auto instance = object_get_model_instance(locals.host.objp);
+		Assertion(instance != -1, "Model instances are required if a host subobject is specified.");
+
+		auto pmi = model_get_instance(instance);
+		auto pm = model_get(pmi->model_num);
+
+		find_submodel_instance_point_orient(&local_pos,
+			&local_orient,
+			pm,
+			pmi,
+			locals.hostSubobject,
+			&locals.localPosition,
+			&locals.localOrient);
+	} else {
+		local_pos = locals.localPosition;
+		local_orient = locals.localOrient;
+	}
+
+	local_pos += locals.variables.getValue({"locals", "position"}).getVector();
+
+	vec3d global_pos;
+	vm_vec_unrotate(&global_pos, &local_pos, &locals.host.objp->orient);
+	global_pos += locals.host.objp->pos;
+
+	const auto soundId = gamesnd_get_by_name(m_soundIdExpression.execute(locals.variables).c_str());
+
+	// Sound is not attached to the host but the object sound system currently only supports persistent sounds
+	snd_play_3d(gamesnd_get_game_sound(soundId), &global_pos, &Eye_position);
+
+	return ActionResult::Finished;
+}
+std::unique_ptr<Action> PlaySoundAction::clone() const
+{
+	return std::unique_ptr<Action>(new PlaySoundAction(*this));
+}
+} // namespace types
+} // namespace actions

code/actions/types/PlaySoundAction.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "actions/Action.h"
+#include "actions/expression/ActionExpression.h"
+#include "gamesnd/gamesnd.h"
+
+namespace actions {
+namespace types {
+
+class PlaySoundAction : public Action {
+  public:
+	using ValueType = SCP_string;
+
+	static flagset<ProgramContextFlags> getRequiredExecutionContextFlags();
+
+	explicit PlaySoundAction(expression::TypedActionExpression<ValueType> soundIdExpression);
+	~PlaySoundAction() override;
+
+	ActionResult execute(ProgramLocals& locals) const override;
+
+	std::unique_ptr<Action> clone() const override;
+
+  private:
+	expression::TypedActionExpression<ValueType> m_soundIdExpression;
+};
+
+} // namespace types
+} // namespace actions

code/actions/types/SetDirectionAction.cpp

@@ -0,0 +1,39 @@
+
+#include "SetDirectionAction.h"
+
+#include "math/vecmat.h"
+#include "parse/parselo.h"
+
+#include <utility>
+
+namespace actions {
+namespace types {
+
+flagset<ProgramContextFlags> SetDirectionAction::getRequiredExecutionContextFlags()
+{
+	return flagset<ProgramContextFlags>{};
+}
+
+SetDirectionAction::SetDirectionAction(expression::TypedActionExpression<vec3d> newDirExpression)
+	: m_newDirExpression(std::move(newDirExpression))
+{
+}
+SetDirectionAction::~SetDirectionAction() = default;
+
+ActionResult SetDirectionAction::execute(ProgramLocals& locals) const
+{
+	auto dir = m_newDirExpression.execute(locals.variables);
+
+	vm_vec_normalize_safe(&dir);
+
+	locals.variables.setValue({"locals", "direction"}, expression::Value(dir));
+	return ActionResult::Finished;
+}
+
+std::unique_ptr<Action> SetDirectionAction::clone() const
+{
+	return std::unique_ptr<Action>(new SetDirectionAction(*this));
+}
+
+} // namespace types
+} // namespace actions

code/actions/types/SetDirectionAction.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "actions/Action.h"
+#include "actions/expression/ActionExpression.h"
+
+namespace actions {
+namespace types {
+
+class SetDirectionAction : public Action {
+  public:
+	using ValueType = vec3d;
+
+	static flagset<ProgramContextFlags> getRequiredExecutionContextFlags();
+
+	SetDirectionAction(expression::TypedActionExpression<ValueType> newDirExpression);
+	~SetDirectionAction() override;
+
+	ActionResult execute(ProgramLocals& locals) const override;
+
+	std::unique_ptr<Action> clone() const override;
+
+  private:
+	expression::TypedActionExpression<ValueType> m_newDirExpression;
+};
+
+} // namespace types
+} // namespace actions

code/actions/types/SetPositionAction.cpp

@@ -0,0 +1,34 @@
+
+#include "SetPositionAction.h"
+
+#include "parse/parselo.h"
+
+#include <utility>
+
+namespace actions {
+namespace types {
+
+flagset<ProgramContextFlags> SetPositionAction::getRequiredExecutionContextFlags()
+{
+	return flagset<ProgramContextFlags>{};
+}
+
+SetPositionAction::SetPositionAction(expression::TypedActionExpression<ValueType> newPositionExpression)
+	: m_newPosExpression(std::move(newPositionExpression))
+{
+}
+SetPositionAction::~SetPositionAction() = default;
+
+ActionResult SetPositionAction::execute(ProgramLocals& locals) const
+{
+	locals.variables.setValue({"locals", "position"}, expression::Value(m_newPosExpression.execute(locals.variables)));
+	return ActionResult::Finished;
+}
+
+std::unique_ptr<Action> SetPositionAction::clone() const
+{
+	return std::unique_ptr<Action>(new SetPositionAction(*this));
+}
+
+} // namespace types
+} // namespace actions

code/actions/types/SetPositionAction.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "actions/Action.h"
+#include "actions/expression/ActionExpression.h"
+
+namespace actions {
+namespace types {
+
+class SetPositionAction : public Action {
+
+  public:
+	using ValueType = vec3d;
+
+	static flagset<ProgramContextFlags> getRequiredExecutionContextFlags();
+
+	SetPositionAction(expression::TypedActionExpression<ValueType> newPositionExpression);
+	~SetPositionAction() override;
+
+	ActionResult execute(ProgramLocals& locals) const override;
+
+	std::unique_ptr<Action> clone() const override;
+
+  private:
+	expression::TypedActionExpression<vec3d> m_newPosExpression;
+};
+
+} // namespace types
+} // namespace actions

code/actions/types/WaitAction.cpp

@@ -0,0 +1,48 @@
+
+#include "WaitAction.h"
+
+#include "io/timer.h"
+#include "parse/parselo.h"
+
+namespace actions {
+namespace types {
+
+flagset<ProgramContextFlags> WaitAction::getRequiredExecutionContextFlags()
+{
+	return flagset<ProgramContextFlags>{};
+}
+
+WaitAction::WaitAction(expression::TypedActionExpression<float> waitTimeExpression)
+	: _waitTimeExpression(std::move(waitTimeExpression))
+{
+}
+WaitAction::~WaitAction() = default;
+
+ActionResult WaitAction::execute(actions::ProgramLocals& locals) const
+{
+	if (!timestamp_valid(locals.waitTimestamp)) {
+		auto waitTime = _waitTimeExpression.execute(locals.variables);
+
+		// Catch errors in the expression
+		if (waitTime < 0.001f) {
+			waitTime = 0.001f;
+		}
+
+		locals.waitTimestamp = timestamp(fl2i(waitTime * TIMESTAMP_FREQUENCY));
+	}
+	if (!timestamp_elapsed(locals.waitTimestamp)) {
+		// Wait until the timestamp is elapsed
+		return ActionResult::Wait;
+	}
+	// Timestamp is elapsed. The timestamp is elapsed so that timestamp_valid above returns false for the next wait
+	// action
+	locals.waitTimestamp = 0;
+	return ActionResult::Finished;
+}
+std::unique_ptr<Action> WaitAction::clone() const
+{
+	return std::unique_ptr<Action>(new WaitAction(*this));
+}
+
+} // namespace types
+} // namespace actions

code/actions/types/WaitAction.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "actions/Action.h"
+#include "actions/common.h"
+#include "actions/expression/ActionExpression.h"
+#include "utils/RandomRange.h"
+
+namespace actions {
+namespace types {
+
+class WaitAction : public Action {
+  public:
+	using ValueType = float;
+
+	static flagset<ProgramContextFlags> getRequiredExecutionContextFlags();
+
+	explicit WaitAction(expression::TypedActionExpression<ValueType> waitTimeExpression);
+	~WaitAction() override;
+
+	ActionResult execute(ProgramLocals& locals) const override;
+
+	std::unique_ptr<Action> clone() const override;
+
+  private:
+	expression::TypedActionExpression<ValueType> _waitTimeExpression;
+};
+
+} // namespace types
+} // namespace actions

code/ai/aicode.cpp

@@ -3321,7 +3321,9 @@ void ai_start_fly_to_ship(object *objp, int shipnum)
 	aip->mode = AIM_FLY_TO_SHIP;
 	aip->submode_start_time = Missiontime;
 
-	aip->target_objnum = Ships[shipnum].objnum;	
+	aip->target_objnum = Ships[shipnum].objnum;
+	// clear targeted subsystem
+	set_targeted_subsys(aip, nullptr, -1);
 
 	Assert(aip->active_goal != AI_ACTIVE_GOAL_DYNAMIC);
 }

code/asteroid/asteroid.cpp

@@ -1085,7 +1085,7 @@ int asteroid_check_collision(object *pasteroid, object *other_obj, vec3d *hitpos
 
 			}
 
-			// Recover and do usual ship_ship collision, but without rotating submodels
+			// Now complete base model collision checks that do not take into account rotating submodels.
 			mc.flags = copy_flags;
 			*mc.p0 = copy_p0;
 			*mc.p1 = copy_p1;

code/debris/debris.cpp

@@ -940,7 +940,7 @@ int debris_check_collision(object *pdebris, object *other_obj, vec3d *hitpos, co
 				}
 			}
 
-			// Recover and do usual ship_ship collision, but without rotating submodels
+			// Now complete base model collision checks that do not take into account rotating submodels.
 			mc.flags = copy_flags;
 			*mc.p0 = copy_p0;
 			*mc.p1 = copy_p1;

code/gamesnd/gamesnd.cpp

@@ -10,6 +10,7 @@
 #include <sstream>
 #include <climits>
 
+#include "gamesnd.h"
 #include "gamesnd/gamesnd.h"
 #include "localization/localize.h"
 #include "parse/parselo.h"
@@ -421,21 +422,32 @@ bool parse_game_sound(const char* tag, gamesnd_id* idx_dest)
 {
 	if (optional_string(tag))
 	{
-		SCP_string buf;
-		stuff_string(buf, F_NAME);
-
-		*idx_dest = gamesnd_get_by_name(buf.c_str());
-
-		// The special case "-1" is needed to silence warnings where sounds are intentionally removed
-		if (idx_dest->isValid() || buf == "-1")
-			return true;
-		
-		error_display(0, "Could not find game sound with name '%s'!", buf.c_str());
+		*idx_dest = parse_game_sound_inline();
+		return true;
 	}
 
 	return false;
 }
 
+/**
+ * @brief Parses a game sound that should appear at the current parsing location
+ * @return The game sound id or invalid id when parsing fails
+ */
+gamesnd_id parse_game_sound_inline()
+{
+	SCP_string buf;
+	stuff_string(buf, F_NAME);
+
+	auto id = gamesnd_get_by_name(buf.c_str());
+
+	// The special case "-1" is needed to silence warnings where sounds are intentionally removed
+	if (!id.isValid() && buf != "-1") {
+		error_display(0, "Could not find game sound with name '%s'!", buf.c_str());
+	}
+
+	return id;
+}
+
 /**
  * Parse a sound. When using this function for a table entry,
  * required_string and optional_string aren't needed, as this function deals with

code/gamesnd/gamesnd.h

@@ -372,6 +372,8 @@ interface_snd_id gamesnd_get_by_iface_tbl_index(int index);
 // Does all parsing for a sound.  Returns true if a sound was successfully parsed.
 bool parse_game_sound(const char* tag, gamesnd_id* idx_dest);
 
+gamesnd_id parse_game_sound_inline();
+
 void parse_iface_sound(const char* tag, interface_snd_id* idx_dest);
 void parse_iface_sound_list(const char* tag, SCP_vector<interface_snd_id>& destination, const char* object_name, bool scp_list = false);
 

code/libs/antlr/ErrorListener.cpp

@@ -0,0 +1,23 @@
+
+#include "ErrorListener.h"
+
+namespace libs {
+namespace antlr {
+
+void ErrorListener::syntaxError(antlr4::Recognizer*,
+	antlr4::Token* offendingSymbol,
+	size_t line,
+	size_t charPositionInLine,
+	const std::string& msg,
+	std::exception_ptr)
+{
+	// Apparently stop < start is a thing?
+	const auto left = std::min(offendingSymbol->getStartIndex(), offendingSymbol->getStopIndex());
+	const auto right = std::max(offendingSymbol->getStartIndex(), offendingSymbol->getStopIndex());
+	const auto length = right - left + 1;
+
+	diagnostics.push_back(Diagnostic{line, charPositionInLine, length, msg});
+}
+
+} // namespace antlr
+} // namespace libs

code/libs/antlr/ErrorListener.h

@@ -0,0 +1,29 @@
+
+#include "globalincs/pstypes.h"
+
+#include <BaseErrorListener.h>
+#include <Token.h>
+
+namespace libs {
+namespace antlr {
+
+struct Diagnostic {
+	size_t line;
+	size_t columnInLine;
+	size_t tokenLength;
+	SCP_string errorMessage;
+};
+
+struct ErrorListener : public antlr4::BaseErrorListener {
+	SCP_vector<Diagnostic> diagnostics;
+
+	void syntaxError(antlr4::Recognizer* /*recognizer*/,
+		antlr4::Token* offendingSymbol,
+		size_t line,
+		size_t charPositionInLine,
+		const std::string& msg,
+		std::exception_ptr /*e*/) override;
+};
+
+} // namespace antlr
+} // namespace libs

code/math/vecmat.cpp

@@ -157,6 +157,17 @@ void vm_set_identity(matrix *m)
 	m->vec.fvec.xyz.x = 0.0f;	m->vec.fvec.xyz.y = 0.0f;	m->vec.fvec.xyz.z = 1.0f;
 }
 
+vec3d vm_vec_new(float x, float y, float z)
+{
+	vec3d vec;
+
+	vec.xyz.x = x;
+	vec.xyz.y = y;
+	vec.xyz.z = z;
+
+	return vec;
+}
+
 //adds two vectors, fills in dest, returns ptr to dest
 //ok for dest to equal either source, but should use vm_vec_add2() if so
 //dest = src0 + src1
@@ -540,10 +551,12 @@ vec3d *vm_vec_perp(vec3d *dest, const vec3d *p0, const vec3d *p1,const vec3d *p2
 
 //computes the delta angle between two vectors.
 //vectors need not be normalized. if they are, call vm_vec_delta_ang_norm()
-//the forward vector (third parameter) can be NULL, in which case the absolute
-//value of the angle in returned.  Otherwise the angle around that vector is
-//returned.
-float vm_vec_delta_ang(const vec3d *v0, const vec3d *v1, const vec3d *fvec)
+//the up vector (third parameter) can be NULL, in which case the absolute
+//value of the angle in returned.  
+//Otherwise, the delta ang will be positive if the v0 -> v1 direction from the
+//point of view of uvec is clockwise, negative if counterclockwise.
+//This vector should be orthogonal to v0 and v1
+float vm_vec_delta_ang(const vec3d *v0, const vec3d *v1, const vec3d *uvec)
 {
 	float t;
 	vec3d t0,t1,t2;
@@ -551,10 +564,10 @@ float vm_vec_delta_ang(const vec3d *v0, const vec3d *v1, const vec3d *fvec)
 	vm_vec_copy_normalize(&t0,v0);
 	vm_vec_copy_normalize(&t1,v1);
 
-	if (NULL == fvec) {
+	if (uvec == nullptr) {
 		t = vm_vec_delta_ang_norm(&t0, &t1, NULL);
 	} else {
-		vm_vec_copy_normalize(&t2,fvec);
+		vm_vec_copy_normalize(&t2,uvec);
 		t = vm_vec_delta_ang_norm(&t0,&t1,&t2);
 	}
 
@@ -562,16 +575,16 @@ float vm_vec_delta_ang(const vec3d *v0, const vec3d *v1, const vec3d *fvec)
 }
 
 //computes the delta angle between two normalized vectors.
-float vm_vec_delta_ang_norm(const vec3d *v0, const vec3d *v1, const vec3d *fvec)
+float vm_vec_delta_ang_norm(const vec3d *v0, const vec3d *v1, const vec3d *uvec)
 {
 	float a;
 	vec3d t;
 
 	a = acosf(vm_vec_dot(v0,v1));
 
-	if (fvec) {
+	if (uvec) {
 		vm_vec_cross(&t,v0,v1);
-		if ( vm_vec_dot(&t,fvec) < 0.0 )	{
+		if ( vm_vec_dot(&t,uvec) < 0.0 )	{
 			a = -a;
 		}
 	}
@@ -579,7 +592,7 @@ float vm_vec_delta_ang_norm(const vec3d *v0, const vec3d *v1, const vec3d *fvec)
 	return a;
 }
 
-float vm_vec_delta_ang_norm_safe(const vec3d *v0, const vec3d *v1, const vec3d *fvec)
+float vm_vec_delta_ang_norm_safe(const vec3d *v0, const vec3d *v1, const vec3d *uvec)
 {
 	float a, dot;
 	vec3d t;
@@ -591,9 +604,9 @@ float vm_vec_delta_ang_norm_safe(const vec3d *v0, const vec3d *v1, const vec3d *
 
 	a = acosf(dot);
 
-	if (fvec) {
+	if (uvec) {
 		vm_vec_cross(&t,v0,v1);
-		if ( vm_vec_dot(&t,fvec) < 0.0 ) {
+		if ( vm_vec_dot(&t,uvec) < 0.0 ) {
 			a = -a;
 		}
 	}
@@ -2829,3 +2842,9 @@ void vm_interpolate_angles_quick(angles *dest0, angles *src0, angles *src1, floa
 	dest0->h = src0->h + (arc_measures.h * interp_perc);
 	dest0->b = src0->b + (arc_measures.b * interp_perc);
 }
+
+std::ostream& operator<<(std::ostream& os, const vec3d& vec)
+{
+	os << "vec3d<" << vec.xyz.x << ", " << vec.xyz.y << ", " << vec.xyz.z << ")";
+	return os;
+}

code/math/vecmat.h

@@ -52,6 +52,8 @@ extern void vm_set_identity(matrix *m);
 
 #define vm_vec_make(v,_x,_y,_z) ((v)->xyz.x=(_x), (v)->xyz.y=(_y), (v)->xyz.z=(_z))
 
+extern vec3d vm_vec_new(float x, float y, float z);
+
 //Global constants
 
 extern vec3d vmd_zero_vector;
@@ -224,14 +226,16 @@ vec3d *vm_vec_perp(vec3d *dest, const vec3d *p0, const vec3d *p1, const vec3d *p
 
 //computes the delta angle between two vectors.
 //vectors need not be normalized. if they are, call vm_vec_delta_ang_norm()
-//the forward vector (third parameter) can be NULL, in which case the absolute
-//value of the angle in returned.  Otherwise the angle around that vector is
-//returned.
-float vm_vec_delta_ang(const vec3d *v0, const vec3d *v1, const vec3d *fvec);
+//the up vector (third parameter) can be NULL, in which case the absolute
+//value of the angle in returned.  
+//Otherwise, the delta ang will be positive if the v0 -> v1 direction from the
+//point of view of uvec is clockwise, negative if counterclockwise.
+//This vector should be orthogonal to v0 and v1
+float vm_vec_delta_ang(const vec3d *v0, const vec3d *v1, const vec3d *uvec);
 
 //computes the delta angle between two normalized vectors.
-float vm_vec_delta_ang_norm(const vec3d *v0, const vec3d *v1,const vec3d *fvec);
-float vm_vec_delta_ang_norm_safe(const vec3d *v0, const vec3d *v1, const vec3d *fvec);
+float vm_vec_delta_ang_norm(const vec3d *v0, const vec3d *v1,const vec3d *uvec);
+float vm_vec_delta_ang_norm_safe(const vec3d *v0, const vec3d *v1, const vec3d *uvec);
 
 //computes a matrix from a set of three angles.  returns ptr to matrix
 matrix *vm_angles_2_matrix(matrix *m, const angles *a);
@@ -652,6 +656,8 @@ inline matrix operator*(const matrix& left, const matrix& right) {
 	return out;
 }
 
+std::ostream& operator<<(std::ostream& os, const vec3d& vec);
+
 #endif
 
 

code/mission/missionparse.cpp

@@ -3366,6 +3366,8 @@ int parse_object(mission *pm, int  /*flag*/, p_object *p_objp)
 		texture_replace tr;
 		char *p;
 
+		tr.from_table = false;
+
 		while (optional_string("+old:"))
 		{
 			strcpy_s(tr.ship_name, p_objp->name);

code/mission/missionparse.h

@@ -310,6 +310,7 @@ typedef struct texture_replace {
 	char old_texture[MAX_FILENAME_LEN];
 	char new_texture[MAX_FILENAME_LEN];
 	int new_texture_id;
+	bool from_table;
 } texture_replace;
 
 extern SCP_vector<texture_replace> Fred_texture_replacements;

code/model/model.h

@@ -12,14 +12,16 @@
 #ifndef _MODEL_H
 #define _MODEL_H
 
-#include "globalincs/globals.h"	// for NAME_LENGTH
+#include "globalincs/globals.h" // for NAME_LENGTH
 #include "globalincs/pstypes.h"
-#include "graphics/2d.h"
+
+#include "actions/Program.h"
 #include "gamesnd/gamesnd.h"
+#include "graphics/2d.h"
 #include "io/timer.h"
+#include "model/model_flags.h"
 #include "object/object.h"
 #include "ship/ship_flags.h"
-#include "model/model_flags.h"
 
 class object;
 class model_render_params;
@@ -204,13 +206,13 @@ public:
 
 	//Per-turret ownage settings - SUSHI
 	int turret_max_bomb_ownage; 
-	int turret_max_target_ownage; 
+	int turret_max_target_ownage;
+
+	actions::ProgramSet beam_warmdown_program;
 
     void reset();
 
-    model_subsystem() {
-        reset();
-    }
+    model_subsystem();
 };
 
 typedef struct model_special {

code/model/modelread.cpp

@@ -4479,13 +4479,16 @@ void model_update_instance(int model_instance_num, int submodel_num, flagset<Shi
 	model_update_instance(pm, pmi, submodel_num, flags);
 }
 
-void model_update_instance(polymodel *pm, polymodel_instance *pmi, int submodel_num, flagset<Ship::Subsystem_Flags>& flags)
+/*
+ * This function handles copying submodel instance information to other submodel instances as appropriate.  The copy_from parameter is used for
+ * copying data to other LODs, and is only specified from within model_update_instance itself.  The "public" function header omits this parameter.
+ */
+void model_update_instance(polymodel *pm, polymodel_instance *pmi, const submodel_instance *copy_from, int submodel_num, flagset<Ship::Subsystem_Flags>& flags)
 {
-	int i;
 	Assert(pm->id == pmi->model_num);
 	
 	Assertion(submodel_num >= 0 && submodel_num < pm->n_models,
-		"Sub model number (%d) which should be updated is out of range! Must be between 0 and %d. This happend on model %s.",
+		"Submodel number (%d) which should be updated is out of range! Must be between 0 and %d. This happened on model %s.",
 		submodel_num, pm->n_models - 1, pm->filename);
 
 	if ( submodel_num < 0 ) return;
@@ -4494,31 +4497,49 @@ void model_update_instance(polymodel *pm, polymodel_instance *pmi, int submodel_
 	submodel_instance *smi = &pmi->submodel[submodel_num];
 	bsp_info *sm = &pm->submodel[submodel_num];
 	
-	// Set the "blown out" flags
+	// Set the "blown out" flags.
 	if ( flags[Ship::Subsystem_Flags::No_disappear] ) {
 		smi->blown_off = false;
+	} else if ( copy_from ) {
+		smi->blown_off = copy_from->blown_off;
 	}
 
-	if ( smi->blown_off && !(flags[Ship::Subsystem_Flags::No_replace]) )	{
-		if ( sm->my_replacement > -1 )	{
+	if ( smi->blown_off )	{
+		if ( sm->my_replacement >= 0 && !(flags[Ship::Subsystem_Flags::No_replace]) ) {
 			auto r_smi = &pmi->submodel[sm->my_replacement];
 			r_smi->blown_off = false;
-			r_smi->angs = smi->angs;
-			r_smi->prev_angs = smi->prev_angs;
+			if ( copy_from ) {
+				r_smi->angs = copy_from->angs;
+				r_smi->prev_angs = copy_from->prev_angs;
+			} else {
+				r_smi->angs = smi->angs;
+				r_smi->prev_angs = smi->prev_angs;
+			}
 		}
 	} else {
 		// If submodel isn't yet blown off and has a -destroyed replacement model, we prevent
 		// the replacement model from being drawn by marking it as having been blown off
-		if ( sm->my_replacement > -1 && sm->my_replacement != submodel_num)	{
+		if ( sm->my_replacement >= 0 && sm->my_replacement != submodel_num)	{
 			auto r_smi = &pmi->submodel[sm->my_replacement];
 			r_smi->blown_off = true;
 		}
 	}
 
-	// For all the detail levels of this submodel, set them also.
-	for (i=0; i<sm->num_details; i++ )	{
-		model_update_instance(pm, pmi, sm->details[i], flags );
+	// Set the angles.
+	if ( copy_from ) {
+		smi->angs = copy_from->angs;
+		smi->prev_angs = copy_from->prev_angs;
 	}
+
+	// For all the detail levels of this submodel, set them also.
+	for ( int i=0; i<sm->num_details; i++ )	{
+		model_update_instance( pm, pmi, smi, sm->details[i], flags );
+	}
+}
+
+void model_update_instance(polymodel *pm, polymodel_instance *pmi, int submodel_num, flagset<Ship::Subsystem_Flags>& flags)
+{
+	model_update_instance(pm, pmi, nullptr, submodel_num, flags);
 }
 
 void model_do_intrinsic_rotations_sub(intrinsic_rotation *ir)
@@ -5544,4 +5565,10 @@ void model_subsystem::reset()
 
     turret_max_bomb_ownage = 0;
     turret_max_target_ownage = 0;
+
+	beam_warmdown_program = actions::ProgramSet();
+}
+
+model_subsystem::model_subsystem() {
+	reset();
 }

code/model/modelrender.cpp

@@ -2605,6 +2605,14 @@ void model_render_queue(model_render_params* interp, model_draw_list* scene, int
 
 	if (model_instance_num >= 0) {
 		pmi = model_get_instance(model_instance_num);
+
+		// This can happen if we supply a HUD target model for a real ship.
+		// The passed parameter was -1 but it was assigned an instance from
+		// the actual object.  Set it back to -1 if there is a mismatch.
+		if (pmi->model_num != pm->id) {
+			model_instance_num = -1;
+			pmi = nullptr;
+		}
 	}
 	
 	// Set the flags we will pass to the tmapper

code/object/collideshipship.cpp

@@ -326,7 +326,7 @@ int ship_ship_check_collision(collision_info_struct *ship_ship_hit_info)
 
 		}
 
-		// Recover and do usual ship_ship collision, but without rotating submodels
+		// Now complete base model collision checks that do not take into account rotating submodels.
 		mc.flags = copy_flags;
 		*mc.p0 = copy_p0;
 		*mc.p1 = copy_p1;

code/particle/ParticleSource.cpp

@@ -165,22 +165,22 @@ bool SourceOrigin::isValid() const {
 
 SourceOrientation::SourceOrientation() : m_orientation(vmd_identity_matrix) {}
 
-void SourceOrientation::setFromVector(const vec3d& vec) {
+void SourceOrientation::setFromVector(const vec3d& vec, bool relative) {
 	vec3d workVec = vec;
 
 	vm_vec_normalize(&workVec);
 
-	this->setFromNormalizedVector(workVec);
+	this->setFromNormalizedVector(workVec, relative);
 }
 
-void SourceOrientation::setFromNormalizedVector(const vec3d& vec) {
+void SourceOrientation::setFromNormalizedVector(const vec3d& vec, bool relative) {
 	vm_vector_2_matrix_norm(&m_orientation, &vec);
-	m_isRelative = false;
+	m_isRelative = relative;
 }
 
-void SourceOrientation::setFromMatrix(const matrix& mat) {
+void SourceOrientation::setFromMatrix(const matrix& mat, bool relative) {
 	m_orientation = mat;
-	m_isRelative = false;
+	m_isRelative = relative;
 }
 
 void SourceOrientation::setNormal(const vec3d& normal) {

code/particle/ParticleSource.h

@@ -155,18 +155,18 @@ class SourceOrientation {
 	 *
 	 * @param vec The vector to create the matrix from
 	 */
-	void setFromVector(const vec3d& vec);
+	void setFromVector(const vec3d& vec, bool relative = false);
 
 	/**
 	 * @brief Sets the direction from an already normalized vector
 	 *
 	 * @param vec The normalized vector
 	 */
-	void setFromNormalizedVector(const vec3d& vec);
+	void setFromNormalizedVector(const vec3d& vec, bool relative = false);
 
 	void setNormal(const vec3d& normal);
 
-	void setFromMatrix(const matrix& mat);
+	void setFromMatrix(const matrix& mat, bool relative = false);
 
 	vec3d getDirectionVector(const SourceOrigin* origin) const;
 

code/particle/ParticleSourceWrapper.cpp

@@ -84,28 +84,28 @@ namespace particle
 		}
 	}
 
-	void ParticleSourceWrapper::setOrientationFromNormalizedVec(vec3d* normalizedDir)
+	void ParticleSourceWrapper::setOrientationFromNormalizedVec(vec3d* normalizedDir, bool relative)
 	{
 		for (auto& source : m_sources)
 		{
-			source->getOrientation()->setFromNormalizedVector(*normalizedDir);
+			source->getOrientation()->setFromNormalizedVector(*normalizedDir, relative);
 		}
 	}
 
 
-	void ParticleSourceWrapper::setOrientationFromVec(vec3d* dir)
+	void ParticleSourceWrapper::setOrientationFromVec(vec3d* dir, bool relative)
 	{
 		for (auto& source : m_sources)
 		{
-			source->getOrientation()->setFromVector(*dir);
+			source->getOrientation()->setFromVector(*dir, relative);
 		}
 	}
 
-	void ParticleSourceWrapper::setOrientationMatrix(matrix* mtx)
+	void ParticleSourceWrapper::setOrientationMatrix(matrix* mtx, bool relative)
 	{
 		for (auto& source : m_sources)
 		{
-			source->getOrientation()->setFromMatrix(*mtx);
+			source->getOrientation()->setFromMatrix(*mtx, relative);
 		}
 	}
 

code/particle/ParticleSourceWrapper.h

@@ -54,11 +54,11 @@ namespace particle
 
 		void moveTo(vec3d* pos);
 
-		void setOrientationFromNormalizedVec(vec3d* normalizedDir);
+		void setOrientationFromNormalizedVec(vec3d* normalizedDir, bool relative = false);
 
-		void setOrientationFromVec(vec3d* dir);
+		void setOrientationFromVec(vec3d* dir, bool relative = false);
 
-		void setOrientationMatrix(matrix* mtx);
+		void setOrientationMatrix(matrix* mtx, bool relative = false);
 
 		void setOrientationNormal(vec3d* normal);
 

code/scripting/api/objs/ship_bank.cpp

@@ -200,7 +200,7 @@ bool ship_bank_h::IsValid() {
 	return true;
 }
 
-ADE_VIRTVAR(WeaponClass, l_WeaponBank, "weaponclass", "Class of weapon mounted in the bank", "weaponclass", "Weapon class, or an invalid weaponclass handle if bank handle is invalid")
+ADE_VIRTVAR(WeaponClass, l_WeaponBank, "weaponclass", "Class of weapon mounted in the bank. As of FSO 21.0, also changes the maximum ammo to its proper value, which is what the support ship will rearm the ship to.", "weaponclass", "Weapon class, or an invalid weaponclass handle if bank handle is invalid")
 {
 	ship_bank_h *bh = NULL;
 	int weaponclass=-1;
@@ -215,12 +215,16 @@ ADE_VIRTVAR(WeaponClass, l_WeaponBank, "weaponclass", "Class of weapon mounted i
 		case SWH_PRIMARY:
 			if(ADE_SETTING_VAR && weaponclass > -1) {
 				bh->sw->primary_bank_weapons[bh->bank] = weaponclass;
+				if (Weapon_info[weaponclass].wi_flags[Weapon::Info_Flags::Ballistic]) {
+					bh->sw->primary_bank_ammo[bh->bank] = (int)std::lround(bh->sw->primary_bank_capacity[bh->bank] / Weapon_info[weaponclass].cargo_size);
+				}
 			}
 
 			return ade_set_args(L, "o", l_Weaponclass.Set(bh->sw->primary_bank_weapons[bh->bank]));
 		case SWH_SECONDARY:
 			if(ADE_SETTING_VAR && weaponclass > -1) {
 				bh->sw->secondary_bank_weapons[bh->bank] = weaponclass;
+				bh->sw->secondary_bank_ammo[bh->bank] = (int)std::lround(bh->sw->secondary_bank_capacity[bh->bank] / Weapon_info[weaponclass].cargo_size);
 			}
 
 			return ade_set_args(L, "o", l_Weaponclass.Set(bh->sw->secondary_bank_weapons[bh->bank]));

code/scripting/doc_parser.cpp

@@ -1,6 +1,7 @@
 #include "doc_parser.h"
 
 #include "parse/parselo.h"
+#include "libs/antlr/ErrorListener.h"
 
 #undef TRUE
 #undef FALSE
@@ -15,32 +16,6 @@ namespace scripting {
 
 namespace {
 
-struct Diagnostic {
-	size_t line;
-	size_t columnInLine;
-	size_t tokenLength;
-	SCP_string errorMessage;
-};
-
-struct ErrorListener : public antlr4::BaseErrorListener {
-	SCP_vector<Diagnostic> diagnostics;
-
-	void syntaxError(antlr4::Recognizer* /*recognizer*/,
-	                 antlr4::Token* offendingSymbol,
-	                 size_t line,
-	                 size_t charPositionInLine,
-	                 const std::string& msg,
-	                 std::exception_ptr /*e*/) override
-	{
-		// Apparently stop < start is a thing?
-		const auto left   = std::min(offendingSymbol->getStartIndex(), offendingSymbol->getStopIndex());
-		const auto right  = std::max(offendingSymbol->getStartIndex(), offendingSymbol->getStopIndex());
-		const auto length = right - left + 1;
-
-		diagnostics.push_back(Diagnostic{line, charPositionInLine, length, msg});
-	}
-};
-
 ade_type_info merge_alternatives(const ade_type_info& left, const ade_type_info& right)
 {
 	SCP_vector<ade_type_info> elements;
@@ -369,7 +344,7 @@ bool argument_list_parser::parse(const SCP_string& argumentList)
 	ArgumentListParser parser(&tokens);
 	// By default we log to stderr which we do not want
 	parser.removeErrorListeners();
-	ErrorListener errListener;
+	libs::antlr::ErrorListener errListener;
 	parser.addErrorListener(&errListener);
 
 	antlr4::tree::ParseTree* tree = parser.arg_list();

code/ship/ship.cpp

@@ -943,7 +943,7 @@ void ship_info::clone(const ship_info& other)
 
 	if ( other.n_subsystems > 0 ) {
 		if( n_subsystems < 1 ) {
-            subsystems = (model_subsystem *)vm_malloc(sizeof(model_subsystem) * other.n_subsystems);
+			subsystems = new model_subsystem[other.n_subsystems];
 		} else {
 			for ( int i = 0; i < n_subsystems; i++ ) {
 				for ( int j = 0; j < subsystems[i].n_triggers; j++ ) {
@@ -954,10 +954,11 @@ void ship_info::clone(const ship_info& other)
 					}
 				}
 			}
-            subsystems = (model_subsystem *)vm_realloc(subsystems, sizeof(model_subsystem) * other.n_subsystems);
+			delete[] subsystems;
+			subsystems = new model_subsystem[other.n_subsystems];
 		}
 
-        Assert(subsystems != NULL);
+		Assert(subsystems != nullptr);
 		for ( int i = n_subsystems; i < other.n_subsystems; i++ ) {
 			subsystems[i].triggers = (queued_animation*) vm_malloc(sizeof(queued_animation) * (other.subsystems[i].n_triggers));
 		}
@@ -1896,8 +1897,8 @@ ship_info::~ship_info()
 			}
 		}
 
-		vm_free(subsystems);
-        subsystems = NULL;
+		delete[] subsystems;
+		subsystems = nullptr;
 	}
 
 	free_strings();
@@ -2838,6 +2839,8 @@ static void parse_ship_values(ship_info* sip, const bool is_template, const bool
 		texture_replace tr;
 		char *p;
 
+		tr.from_table = true;
+
 		while (optional_string("+old:"))
 		{
 			strcpy_s(tr.ship_name, sip->name);
@@ -4529,9 +4532,9 @@ static void parse_ship_values(ship_info* sip, const bool is_template, const bool
 
 	int n_subsystems = 0;
 	int cont_flag = 1;
-	model_subsystem subsystems[MAX_MODEL_SUBSYSTEMS];		// see model.h for max_model_subsystems
+	model_subsystem subsystems[MAX_MODEL_SUBSYSTEMS] = {}; // see model.h for max_model_subsystems
 	for (auto i=0; i<MAX_MODEL_SUBSYSTEMS; i++) {
-		subsystems[i].stepped_rotation = NULL;
+		subsystems[i].reset();
 	}
 	
 	float	hull_percentage_of_hits = 100.0f;
@@ -5031,6 +5034,8 @@ static void parse_ship_values(ship_info* sip, const bool is_template, const bool
 				}
 			}
 
+			sp->beam_warmdown_program = actions::ProgramSet::parseProgramSet("$On Beam Warmdown:",
+				{actions::ProgramContextFlags::HasObject, actions::ProgramContextFlags::HasSubobject});
 		}
 		break;
 		case 2:
@@ -5053,14 +5058,21 @@ static void parse_ship_values(ship_info* sip, const bool is_template, const bool
 	// when done reading subsystems, malloc and copy the subsystem data to the ship info structure
 	int orig_n_subsystems = sip->n_subsystems;
 	if ( n_subsystems > 0 ) {
-		if(sip->n_subsystems < 1) {
-			sip->n_subsystems = n_subsystems;
-			sip->subsystems = (model_subsystem*)vm_malloc(sizeof(model_subsystem) * sip->n_subsystems);
+		// Let's make sure that n_subsystems is not negative
+		Assertion(sip->n_subsystems >= 0, "Invalid n_subsystems detected!");
+		auto new_n = sip->n_subsystems + n_subsystems;
 
+		std::unique_ptr<model_subsystem[]> subsys_storage(new model_subsystem[new_n]);
+
+		if(sip->n_subsystems <= 0) {
+			sip->n_subsystems = n_subsystems;
 		} else {
+			// This used realloc originally so we need to copy the existing subsystems to the new storage
+			std::copy(sip->subsystems, sip->subsystems + sip->n_subsystems, subsys_storage.get());
+
 			sip->n_subsystems += n_subsystems;
-			sip->subsystems = (model_subsystem *)vm_realloc(sip->subsystems, sizeof(model_subsystem) * sip->n_subsystems);
-		} 
+		}
+		sip->subsystems = subsys_storage.release();
 
 	    Assert(sip->subsystems != NULL);
     }
@@ -13326,7 +13338,7 @@ int ship_type_name_lookup(const char *name)
 // Return true/false for subsystem found/not found.
 // Stuff vector *pos with absolute position.
 // subsysp is a pointer to the subsystem.
-int get_subsystem_pos(vec3d *pos, object *objp, ship_subsys *subsysp)
+int get_subsystem_pos(vec3d* pos, object* objp, ship_subsys* subsysp)
 {
 	if (subsysp == NULL) {
 		*pos = objp->pos;
@@ -13334,7 +13346,7 @@ int get_subsystem_pos(vec3d *pos, object *objp, ship_subsys *subsysp)
 	}
 	Assertion(objp->type == OBJ_SHIP, "Only ships can have subsystems!");
 
-	model_subsystem *mss = subsysp->system_info;
+	model_subsystem* mss = subsysp->system_info;
 
 	if (mss->subobj_num == -1) {
 		// If it's a special point subsys, we can use its offset directly

code/source_groups.cmake

@@ -6,6 +6,67 @@ add_file_folder(""
 	prefix_header.h
 )
 
+add_file_folder("Actions"
+	actions/Action.cpp
+	actions/Action.h
+	actions/ActionDefinition.cpp
+	actions/ActionDefinition.h
+	actions/ActionDefinitionManager.cpp
+	actions/ActionDefinitionManager.h
+	actions/BuiltinActionDefinition.cpp
+	actions/BuiltinActionDefinition.h
+	actions/common.cpp
+	actions/common.h
+	actions/Program.cpp
+	actions/Program.h
+)
+
+add_file_folder("Actions\\\\Expression"
+	actions/expression/ActionExpression.cpp
+	actions/expression/ActionExpression.h
+	actions/expression/ExpressionParser.cpp
+	actions/expression/ExpressionParser.h
+	actions/expression/FunctionManager.cpp
+	actions/expression/FunctionManager.h
+	actions/expression/ParseContext.h
+	actions/expression/ProgramVariables.cpp
+	actions/expression/ProgramVariables.h
+	actions/expression/TypeDefinition.cpp
+	actions/expression/TypeDefinition.h
+	actions/expression/Value.cpp
+	actions/expression/Value.h
+)
+
+add_file_folder("Actions\\\\Expression\\\\Nodes"
+	actions/expression/nodes/AbstractExpression.cpp
+	actions/expression/nodes/AbstractExpression.h
+	actions/expression/nodes/FunctionCallExpression.cpp
+	actions/expression/nodes/FunctionCallExpression.h
+	actions/expression/nodes/LiteralExpression.cpp
+	actions/expression/nodes/LiteralExpression.h
+	actions/expression/nodes/RandomRangeExpression.cpp
+	actions/expression/nodes/RandomRangeExpression.h
+	actions/expression/nodes/VariableReferenceExpression.cpp
+	actions/expression/nodes/VariableReferenceExpression.h
+	actions/expression/nodes/VectorConstructorExpression.cpp
+	actions/expression/nodes/VectorConstructorExpression.h
+)
+
+add_file_folder("Actions\\\\Types"
+	actions/types/MoveToSubmodel.cpp
+	actions/types/MoveToSubmodel.h
+	actions/types/ParticleEffectAction.cpp
+	actions/types/ParticleEffectAction.h
+	actions/types/PlaySoundAction.cpp
+	actions/types/PlaySoundAction.h
+	actions/types/SetDirectionAction.cpp
+	actions/types/SetDirectionAction.h
+	actions/types/SetPositionAction.cpp
+	actions/types/SetPositionAction.h
+	actions/types/WaitAction.cpp
+	actions/types/WaitAction.h
+)
+
 # AI files
 add_file_folder("AI"
 	ai/ai.cpp
@@ -637,6 +698,11 @@ add_file_folder("Libs"
 	libs/jansson.h
 )
 
+add_file_folder("Libs\\\\AntLR"
+	libs/antlr/ErrorListener.cpp
+	libs/antlr/ErrorListener.h
+	)
+
 add_file_folder("Libs\\\\Discord"
 	libs/discord/discord.cpp
 	libs/discord/discord.h
@@ -1458,6 +1524,7 @@ add_file_folder("Utils"
 	utils/HeapAllocator.cpp
 	utils/HeapAllocator.h
 	utils/id.h
+	utils/join_string.h
 	utils/RandomRange.h
 	utils/string_utils.cpp
 	utils/string_utils.h

code/tracing/Monitor.cpp

@@ -5,10 +5,35 @@ using namespace tracing;
 
 namespace tracing {
 
-MonitorBase::MonitorBase(const char* name) : _name(name), _tracing_cat(name, false) {
-}
-void MonitorBase::valueChanged(float newVal) {
+MonitorBase::MonitorBase(const char* name) : _name(name), _tracing_cat(name, false) {}
+void MonitorBase::valueChanged(float newVal)
+{
 	tracing::counter::value(_tracing_cat, newVal);
 }
 
+RunningCounter::RunningCounter(Monitor<int>& monitor) : _monitor(monitor)
+{
+	_monitor += 1;
 }
+RunningCounter::~RunningCounter()
+{
+	_monitor -= 1;
+}
+RunningCounter::RunningCounter(const RunningCounter& other) : _monitor(other._monitor)
+{
+	_monitor += 1;
+}
+RunningCounter& RunningCounter::operator=(const RunningCounter&)
+{
+	return *this;
+}
+RunningCounter::RunningCounter(RunningCounter&& other) noexcept : _monitor(other._monitor)
+{
+	_monitor += 1;
+}
+RunningCounter& RunningCounter::operator=(RunningCounter&&) noexcept
+{
+	return *this;
+}
+
+} // namespace tracing

code/tracing/Monitor.h

@@ -58,7 +58,24 @@ class Monitor: public MonitorBase {
 	}
 };
 
-}
+/**
+ * @brief Class that keeps track of how many operations are currently running
+ */
+class RunningCounter {
+	Monitor<int>& _monitor;
+
+  public:
+	explicit RunningCounter(Monitor<int>& monitor);
+	~RunningCounter();
+
+	RunningCounter(const RunningCounter&);
+	RunningCounter& operator=(const RunningCounter&);
+
+	RunningCounter(RunningCounter&&) noexcept;
+	RunningCounter& operator=(RunningCounter&&) noexcept;
+};
+
+} // namespace tracing
 
 // Creates a monitor variable
 #define MONITOR(function_name)				static ::tracing::Monitor<int> mon_##function_name(#function_name, 0);

code/tracing/categories.cpp

@@ -143,4 +143,6 @@ Category RenderDecals("Render all decals", true);
 Category RenderSingleDecal("Render single decal", true);
 Category GpuHeapAllocate("GPU heap allocate", false);
 Category GpuHeapDeallocate("GPU heap deallocate", false);
+
+Category ProgramStepOne("Step one program", false);
 }

code/tracing/categories.h

@@ -159,6 +159,8 @@ extern Category RenderSingleDecal;
 extern Category GpuHeapAllocate;
 extern Category GpuHeapDeallocate;
 
+extern Category ProgramStepOne;
+
 }
 
 #endif // _TRACING_CATEGORIES_H

code/utils/id.h

@@ -46,7 +46,7 @@ public:
 		return stream;
 	}
 
-	inline bool isValid() { return m_val != default_value; }
+	inline bool isValid() const { return m_val != default_value; }
 
 private:
 	Impl m_val;

code/utils/join_string.h

@@ -0,0 +1,29 @@
+#pragma once
+
+namespace util {
+
+template <typename TIter>
+SCP_string join_range(TIter&& begin, TIter&& end, const SCP_string& joiner)
+{
+	SCP_stringstream stream;
+	bool first = true;
+
+	for (auto iter = begin; iter != end; ++iter) {
+		stream << *iter;
+		if (first) {
+			first = false;
+		} else {
+			stream << joiner;
+		}
+	}
+
+	return stream.str();
+}
+
+template <typename TContainer>
+SCP_string join_container(TContainer& container, const SCP_string& joiner)
+{
+	return join_range(std::begin(container), std::end(container), joiner);
+}
+
+} // namespace util

code/weapon/beam.cpp

@@ -2006,6 +2006,14 @@ void beam_start_warmdown(beam *b)
 		snd_stop(b->beam_sound_loop);
 		b->beam_sound_loop = sound_handle::invalid();
 	}
+
+	if (b->subsys != nullptr) {
+		// Starts the warmdown program if it exists
+		b->subsys->system_info->beam_warmdown_program.start(b->objp,
+			&vmd_zero_vector,
+			&vmd_identity_matrix,
+			b->subsys->system_info->subobj_num);
+	}
 }
 
 // recalculate beam sounds (looping sounds relative to the player)

code/weapon/weapon.h

@@ -14,15 +14,17 @@
 
 #include "globalincs/globals.h"
 #include "globalincs/systemvars.h"
+
+#include "actions/Program.h"
+#include "decals/decals.h"
+#include "gamesnd/gamesnd.h"
 #include "graphics/2d.h"
 #include "graphics/generic.h"
-#include "gamesnd/gamesnd.h"
 #include "model/model.h"
+#include "particle/ParticleManager.h"
 #include "weapon/shockwave.h"
 #include "weapon/trails.h"
-#include "particle/ParticleManager.h"
 #include "weapon/weapon_flags.h"
-#include "decals/decals.h"
 
 class object;
 class ship_subsys;
@@ -512,6 +514,8 @@ struct weapon_info
 
 	decals::creation_info impact_decal;
 
+	actions::ProgramSet on_create_program;
+
 public:
 	weapon_info();
 

code/weapon/weapons.cpp

@@ -3012,6 +3012,19 @@ int parse_weapon(int subtype, bool replace, const char *filename)
 		}
 	}
 
+	// This only works with lasters and missiles for now
+	if (wip->subtype == WP_MISSILE || wip->subtype == WP_LASER) {
+		// We always have an object we are attached to
+		flagset<actions::ProgramContextFlags> contexts{actions::ProgramContextFlags::HasObject};
+
+		if (wip->render_type == WRT_POF) {
+			// We will render with a model so we can have subobejcts
+			contexts.set(actions::ProgramContextFlags::HasSubobject, true);
+		}
+
+		wip->on_create_program = actions::ProgramSet::parseProgramSet("$On Create:", contexts);
+	}
+
 	/* Generate a substitution pattern for this weapon.
 	This pattern is very naive such that it calculates the lowest common denominator as being all of
 	the periods multiplied together.
@@ -5764,10 +5777,8 @@ int weapon_create( vec3d * pos, matrix * porient, int weapon_type, int parent_ob
 
 		objp->radius = model_get_radius(wip->model_num);
 
-		// if we intrinsic-rotate, make sure we have a model instance
-		if (model_get(wip->model_num)->flags & PM_FLAG_HAS_INTRINSIC_ROTATE) {
-			wp->model_instance_num = model_create_instance(false, wip->model_num);
-		}
+		// Always create an instance in case we need them
+		wp->model_instance_num = model_create_instance(false, wip->model_num);
 	} else if ( wip->render_type == WRT_LASER ) {
 		objp->radius = wip->laser_head_radius;
 	}
@@ -5948,6 +5959,17 @@ int weapon_create( vec3d * pos, matrix * porient, int weapon_type, int parent_ob
 
 	weapon_update_state(wp);
 
+	if (wip->render_type == WRT_LASER) {
+		// No model so we also have no submodel
+		wip->on_create_program.start(&Objects[objnum], &vmd_zero_vector, &vmd_identity_matrix, -1);
+	} else if (wip->render_type == WRT_POF) {
+		// We have a model so we can specify a subobject
+		wip->on_create_program.start(&Objects[objnum],
+			&vmd_zero_vector,
+			&vmd_identity_matrix,
+			model_get(wip->model_num)->detail[0]);
+	}
+
 	Script_system.SetHookObject("Weapon", &Objects[objnum]);
 	Script_system.RunCondition(CHA_ONWEAPONCREATED);
 	Script_system.RemHookVar("Weapon");
@@ -8361,6 +8383,8 @@ void weapon_info::reset()
 
 	// Reset using default constructor
 	this->impact_decal = decals::creation_info();
+
+	this->on_create_program = actions::ProgramSet();
 }
 
 const char* weapon_info::get_display_name() const

fred2/missionsave.cpp

@@ -3474,7 +3474,7 @@ int CFred_mission_save::save_objects()
 			fso_comment_push(";;FSO 3.6.8;;");
 
 			for (SCP_vector<texture_replace>::iterator ii = Fred_texture_replacements.begin(); ii != Fred_texture_replacements.end(); ++ii) {
-				if (!stricmp(shipp->ship_name, ii->ship_name)) {
+				if (!stricmp(shipp->ship_name, ii->ship_name) && !(ii->from_table)) {
 					if (needs_header) {
 						if (optional_string_fred("$Texture Replace:")) {
 							parse_comments(1);

fred2/shiptexturesdlg.cpp

@@ -150,6 +150,7 @@ void CShipTexturesDlg::OnOK()
 				strcpy_s(tr.new_texture, new_texture_name[i]);
 				strcpy_s(tr.ship_name, Ships[self_ship].ship_name);
 				tr.new_texture_id = -1;
+				tr.from_table = false;
 
 				// assign to global FRED array
 				Fred_texture_replacements.push_back(tr);
@@ -238,7 +239,7 @@ BOOL CShipTexturesDlg::OnInitDialog()
 	// now look for new textures
 	for (SCP_vector<texture_replace>::iterator ii = Fred_texture_replacements.begin(); ii != Fred_texture_replacements.end(); ++ii)
 	{
-		if (!stricmp(Ships[self_ship].ship_name, ii->ship_name))
+		if (!stricmp(Ships[self_ship].ship_name, ii->ship_name) && !(ii->from_table))
 		{
 			// look for corresponding old texture
 			for (i=0; i<texture_count; i++)
@@ -390,6 +391,7 @@ texture_replace *CShipTexturesDlg::texture_set(texture_replace *dest, const text
 	strcpy_s(dest->ship_name, src->ship_name);
 	strcpy_s(dest->old_texture, src->old_texture);
 	strcpy_s(dest->new_texture, src->new_texture);
+	dest->from_table = src->from_table;
 
 	return dest;
 }

lib/CMakeLists.txt

@@ -48,3 +48,5 @@ include(antlr4.cmake)
 include(vulkan.cmake)
 
 add_subdirectory(mdns)
+
+add_subdirectory(variant)

lib/variant/CMakeLists.txt

@@ -0,0 +1,5 @@
+
+add_library(variant INTERFACE)
+
+target_include_directories(variant SYSTEM INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
+

lib/variant/LICENSE.md

@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

lib/vulkan.cmake

@@ -1,7 +1,12 @@
 
 find_program(GLSLC_PATH glslc)
 
-if (GLSLC_PATH)
+# Add an option for this so that this can be disabled locally when not needed
+option(SHADERS_ENABLE_COMPILATION "Enable compilation of shaders to SPIR-V" OFF)
+
+mark_as_advanced(SHADERS_ENABLE_COMPILATION)
+
+if (SHADERS_ENABLE_COMPILATION AND GLSLC_PATH)
 	if(PLATFORM_WINDOWS)
 		set(SHADERTOOL_FILENAME "shadertool-windows.tar.gz")
 	elseif(PLATFORM_LINUX)

parsers/CMakeLists.txt

@@ -1,4 +1,35 @@
 
+function(add_parser filename)
+    get_filename_component(_name "${filename}" NAME_WE)
+    get_filename_component(_absolutePath "${filename}" ABSOLUTE)
+
+    get_filename_component(_directory "${_absolutePath}" DIRECTORY)
+    get_filename_component(_directoryName "${_directory}" NAME)
+
+    if (ANTLR_FOUND)
+        antlr_target(${_name} "${_absolutePath}"
+            VISITOR
+            OUTPUT_DIRECTORY "${_directory}/generated")
+        target_sources(parsers PRIVATE "${_absolutePath}")
+        source_group("${_directoryName}" FILES "${_absolutePath}")
+    else()
+        # Otherwise we just use the ones that are checked in
+        set(ANTLR_${_name}_OUTPUTS
+            ${_directory}/generated/${_name}BaseVisitor.cpp
+            ${_directory}/generated/${_name}BaseVisitor.h
+            ${_directory}/generated/${_name}Lexer.cpp
+            ${_directory}/generated/${_name}Lexer.h
+            ${_directory}/generated/${_name}Parser.cpp
+            ${_directory}/generated/${_name}Parser.h
+            ${_directory}/generated/${_name}Visitor.cpp
+            ${_directory}/generated/${_name}Visitor.h
+        )
+    endif()
+
+    target_sources(parsers PRIVATE ${ANTLR_${_name}_OUTPUTS})
+    source_group("${_directoryName}\\generated" FILES ${ANTLR_${_name}_OUTPUTS})
+endfunction()
+
 add_library(parsers STATIC)
 
 target_link_libraries(parsers PUBLIC antlr4_static)
@@ -8,28 +39,12 @@ find_package(ANTLR)
 if (ANTLR_FOUND)
     # If we have an ANTLR installation then we can generate new sources
     message(STATUS "Using ANTLR to generate parser")
-    antlr_target(ArgumentList "${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/ArgumentList.g4"
-            VISITOR
-            OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated")
-    target_sources(parsers PRIVATE "arg_parser/ArgumentList.g4")
-    source_group("arg_parser" FILES "arg_parser\\ArgumentList.g4")
 else()
-    # Otherwise we just use the ones that are checked in
     message(STATUS "Using generated ANTLR files")
-    set(ANTLR_ArgumentList_OUTPUTS
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListBaseVisitor.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListBaseVisitor.h
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListLexer.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListLexer.h
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListParser.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListParser.h
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListVisitor.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/arg_parser/generated/ArgumentListVisitor.h
-            )
 endif()
 
-target_sources(parsers PRIVATE ${ANTLR_ArgumentList_OUTPUTS})
-source_group("arg_parser\\generated" FILES ${ANTLR_ArgumentList_OUTPUTS})
+add_parser(arg_parser/ArgumentList.g4)
+add_parser(action_expression/ActionExpression.g4)
 
 target_include_directories(parsers PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
 

parsers/action_expression/ActionExpression.g4

@@ -0,0 +1,61 @@
+grammar ActionExpression;
+
+expression_main: expression EOF;
+
+expression
+ : value_expression
+ | random_range_expression
+ | parenthesis_expression
+ | variable_reference_expression
+ | expression ( PLUS | MINUS ) expression
+ ;
+
+parenthesis_expression: L_PAREN expression R_PAREN;
+
+value_expression
+ : literal_expression
+ | vec3d_constructor
+ ;
+
+literal_expression
+ : FLOAT
+ | INT
+ | STRING
+ ;
+
+// variable references are just a list of identifiers instead of being applied to expressions to avoid introducing types
+// for all the intermediate parts
+variable_reference_expression: IDENTIFIER (DOT IDENTIFIER)*;
+
+random_range_expression: RAND_L_PAREN expression expression R_PAREN;
+
+vec3d_constructor: L_PAREN expression expression expression R_PAREN;
+
+PLUS: '+';
+MINUS: '-';
+
+FLOAT
+ : '-'? ([0-9]+ '.' [0-9]+)
+ ;
+
+INT: '-'? [0-9]+;
+
+// The left parenthesis for the start of a random range
+RAND_L_PAREN: '~(';
+
+L_PAREN: '(';
+R_PAREN: ')';
+
+IDENTIFIER: [a-zA-Z][a-zA-Z0-9]*;
+
+DOT: '.';
+
+STRING: '"' .*? '"';
+
+SPACE
+ : [ \t\r\n] -> skip
+ ;
+
+OTHER
+ : . 
+ ;

parsers/action_expression/generated/ActionExpression.interp

@@ -0,0 +1,43 @@
+token literal names:
+null
+'+'
+'-'
+null
+null
+'~('
+'('
+')'
+null
+'.'
+null
+null
+null
+
+token symbolic names:
+null
+PLUS
+MINUS
+FLOAT
+INT
+RAND_L_PAREN
+L_PAREN
+R_PAREN
+IDENTIFIER
+DOT
+STRING
+SPACE
+OTHER
+
+rule names:
+expression_main
+expression
+parenthesis_expression
+value_expression
+literal_expression
+variable_reference_expression
+random_range_expression
+vec3d_constructor
+
+
+atn:
+[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 14, 66, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 27, 10, 3, 3, 3, 3, 3, 3, 3, 7, 3, 32, 10, 3, 12, 3, 14, 3, 35, 11, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 5, 5, 43, 10, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 7, 7, 50, 10, 7, 12, 7, 14, 7, 53, 11, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 2, 3, 4, 10, 2, 4, 6, 8, 10, 12, 14, 16, 2, 4, 3, 2, 3, 4, 4, 2, 5, 6, 12, 12, 2, 63, 2, 18, 3, 2, 2, 2, 4, 26, 3, 2, 2, 2, 6, 36, 3, 2, 2, 2, 8, 42, 3, 2, 2, 2, 10, 44, 3, 2, 2, 2, 12, 46, 3, 2, 2, 2, 14, 54, 3, 2, 2, 2, 16, 59, 3, 2, 2, 2, 18, 19, 5, 4, 3, 2, 19, 20, 7, 2, 2, 3, 20, 3, 3, 2, 2, 2, 21, 22, 8, 3, 1, 2, 22, 27, 5, 8, 5, 2, 23, 27, 5, 14, 8, 2, 24, 27, 5, 6, 4, 2, 25, 27, 5, 12, 7, 2, 26, 21, 3, 2, 2, 2, 26, 23, 3, 2, 2, 2, 26, 24, 3, 2, 2, 2, 26, 25, 3, 2, 2, 2, 27, 33, 3, 2, 2, 2, 28, 29, 12, 3, 2, 2, 29, 30, 9, 2, 2, 2, 30, 32, 5, 4, 3, 4, 31, 28, 3, 2, 2, 2, 32, 35, 3, 2, 2, 2, 33, 31, 3, 2, 2, 2, 33, 34, 3, 2, 2, 2, 34, 5, 3, 2, 2, 2, 35, 33, 3, 2, 2, 2, 36, 37, 7, 8, 2, 2, 37, 38, 5, 4, 3, 2, 38, 39, 7, 9, 2, 2, 39, 7, 3, 2, 2, 2, 40, 43, 5, 10, 6, 2, 41, 43, 5, 16, 9, 2, 42, 40, 3, 2, 2, 2, 42, 41, 3, 2, 2, 2, 43, 9, 3, 2, 2, 2, 44, 45, 9, 3, 2, 2, 45, 11, 3, 2, 2, 2, 46, 51, 7, 10, 2, 2, 47, 48, 7, 11, 2, 2, 48, 50, 7, 10, 2, 2, 49, 47, 3, 2, 2, 2, 50, 53, 3, 2, 2, 2, 51, 49, 3, 2, 2, 2, 51, 52, 3, 2, 2, 2, 52, 13, 3, 2, 2, 2, 53, 51, 3, 2, 2, 2, 54, 55, 7, 7, 2, 2, 55, 56, 5, 4, 3, 2, 56, 57, 5, 4, 3, 2, 57, 58, 7, 9, 2, 2, 58, 15, 3, 2, 2, 2, 59, 60, 7, 8, 2, 2, 60, 61, 5, 4, 3, 2, 61, 62, 5, 4, 3, 2, 62, 63, 5, 4, 3, 2, 63, 64, 7, 9, 2, 2, 64, 17, 3, 2, 2, 2, 6, 26, 33, 42, 51]

parsers/action_expression/generated/ActionExpression.tokens

@@ -0,0 +1,18 @@
+PLUS=1
+MINUS=2
+FLOAT=3
+INT=4
+RAND_L_PAREN=5
+L_PAREN=6
+R_PAREN=7
+IDENTIFIER=8
+DOT=9
+STRING=10
+SPACE=11
+OTHER=12
+'+'=1
+'-'=2
+'~('=5
+'('=6
+')'=7
+'.'=9