chore: changed terrain test scene

.dir-locals.el

@@ -0,0 +1,6 @@
+((c++-mode . ((mode . clang-format-on-save)))
+ (c-mode . ((mode . c++)))
+ (nil . ((projectile-project-compilation-cmd . "just build")
+         (projectile-project-run-cmd . "engine/bin/godot.linuxbsd.editor.dev.x86_64.llvm --path project")
+         (projectile-project-configure-cmd . "engine/bin/godot.linuxbsd.editor.dev.x86_64.llvm --path project -e")
+         (projectile-project-test-cmd . "engine/bin/godot.linuxbsd.editor.dev.x86.llvm --path project"))))

.gitignore

@@ -5,16 +5,18 @@
 # When configure fails, SCons outputs these
 config.log
 .sconf_temp
-.config
 
-# build artefacts
-.cache/
+# build artifacts
 *.o
 compile_commands.json
-
 engine/.github
 project/.godot
 build/authority.pck
 build/authority.x86_64
 build/authority.exe
 build.zip
+
+# general-purpose cache folder (used by e.g clangd)
+.cache
+
+__pycache__

design/monarchist_camp.svg

@@ -1,183 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   width="297mm"
-   height="210mm"
-   viewBox="0 0 297 210"
-   version="1.1"
-   id="svg1"
-   inkscape:version="1.4.2 (ebf0e940d0, 2025-05-08)"
-   sodipodi:docname="monarchist_camp.svg"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <sodipodi:namedview
-     id="namedview1"
-     pagecolor="#ffffff"
-     bordercolor="#999999"
-     borderopacity="1"
-     inkscape:showpageshadow="2"
-     inkscape:pageopacity="0"
-     inkscape:pagecheckerboard="0"
-     inkscape:deskcolor="#d1d1d1"
-     inkscape:document-units="mm"
-     inkscape:zoom="1.640567"
-     inkscape:cx="483.67425"
-     inkscape:cy="468.43562"
-     inkscape:window-width="2540"
-     inkscape:window-height="1367"
-     inkscape:window-x="0"
-     inkscape:window-y="0"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="layer1" />
-  <defs
-     id="defs1" />
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     style="display:inline">
-    <circle
-       style="fill:none;stroke:none;stroke-width:2"
-       id="path1"
-       r="26.849329"
-       cy="-22.617027"
-       cx="144.71928"
-       transform="rotate(30.90333)" />
-    <circle
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path3"
-       cx="197.15057"
-       cy="12.570523"
-       r="59.961803"
-       transform="rotate(30.90333)" />
-    <circle
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path4"
-       cx="170.88332"
-       cy="42.191242"
-       r="20.471628"
-       transform="rotate(30.90333)" />
-    <circle
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path5"
-       cx="157.94936"
-       cy="3.7319982"
-       r="19.529419"
-       transform="rotate(30.90333)" />
-    <circle
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path6"
-       cx="223.90398"
-       cy="-0.37947115"
-       r="30.321995"
-       transform="rotate(30.90333)" />
-    <ellipse
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path7"
-       cx="174.47501"
-       cy="77.630127"
-       rx="6.205318"
-       ry="59.151665"
-       transform="rotate(11.27939)" />
-    <circle
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path8"
-       cx="193.49632"
-       cy="-33.014153"
-       r="13.619201"
-       transform="rotate(30.90333)" />
-    <circle
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       id="path9"
-       cx="224.58922"
-       cy="46.388348"
-       r="16.617136"
-       transform="rotate(30.90333)" />
-    <path
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       d="m 144.06991,169.24883 -7.19465,31.03241"
-       id="path10" />
-    <path
-       style="fill:none;stroke:#ff3a00;stroke-width:2;stroke-opacity:1"
-       d="m 166.80343,51.882914 5.05932,-22.12813"
-       id="path11" />
-  </g>
-  <g
-     inkscape:groupmode="layer"
-     id="layer2"
-     inkscape:label="Layer 2">
-    <rect
-       style="fill:#000000;stroke:none;stroke-width:2;stroke-opacity:1"
-       id="rect11"
-       width="17.086163"
-       height="26.649414"
-       x="202.4292"
-       y="92.027176"
-       transform="rotate(4.15663)" />
-    <rect
-       style="fill:#000000;stroke:none;stroke-width:2;stroke-opacity:1"
-       id="rect11-3"
-       width="16.747086"
-       height="23.300817"
-       x="211.42197"
-       y="-116.61307"
-       transform="rotate(67.03562)" />
-    <rect
-       style="fill:#000000;stroke:none;stroke-width:2;stroke-opacity:1"
-       id="rect11-3-1"
-       width="16.747086"
-       height="23.300817"
-       x="153.35806"
-       y="52.250866"
-       transform="rotate(25.13231)" />
-    <rect
-       style="fill:#000000;stroke:none;stroke-width:2;stroke-opacity:1"
-       id="rect11-3-1-3"
-       width="16.747086"
-       height="23.300817"
-       x="139.8774"
-       y="30.531561"
-       transform="rotate(16.66083)" />
-    <rect
-       style="fill:#000000;stroke:none;stroke-width:2;stroke-opacity:1"
-       id="rect11-3-1-3-6"
-       width="13.885768"
-       height="15.52168"
-       x="-177.2769"
-       y="-109.64846"
-       transform="rotate(170.10507)" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1"
-       d="m 168.51515,87.048444 49.7405,-10.74439 -11.59163,-23.78924 -34.05085,-6.36336 z"
-       id="path12"
-       sodipodi:nodetypes="ccccc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1"
-       d="m 167.90348,92.072994 -6.81162,32.060266 3.42606,9.03285 50.86591,9.20609 4.78459,-60.134606 z"
-       id="path13"
-       sodipodi:nodetypes="cccccc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1"
-       d="m 161.76062,139.13159 -9.82191,20.20953 4.20318,13.74019 19.43214,4.89741 29.11417,-13.30994 8.46487,-16.33574 z"
-       id="path14"
-       sodipodi:nodetypes="ccccccc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1"
-       d="m 131.20919,159.8118 8.99249,-4.41574 7.79771,-39.28515 -43.81905,-9.86931 -3.00506,27.21896 17.64521,22.70473 z"
-       id="path15"
-       sodipodi:nodetypes="ccccccc" />
-    <path
-       style="fill:none;stroke:#000000;stroke-width:2;stroke-opacity:1"
-       d="m 107.52909,93.556844 c 0.58795,0.35194 40.17069,12.855976 40.17069,12.855976 l 11.52783,-43.543596 -33.50469,-1.2183 z"
-       id="path16"
-       sodipodi:nodetypes="ccccc" />
-    <path
-       style="fill:#000000;stroke:none;stroke-width:2;stroke-opacity:1"
-       d="M -10.027839,166.80916 -0.34598048,166.54137 7.8424327,122.34249 25.872585,93.782258 34.797274,63.284639 65.815884,30.44139 108.46648,12.423235 l 8.387,-18.0823962 -127.760166,0.1592669 z"
-       id="path17"
-       sodipodi:nodetypes="cccccccccc" />
-  </g>
-</svg>

engine

@@ -1 +1 @@
-Subproject commit e531f3eb7b13a9adaaf5b15ac9b3aebc4c2030cd
+Subproject commit 6b76a5a8dc011723033cc8ad2ba3da345daab039

justfile

@@ -37,9 +37,8 @@ release-windows: build
 initialize-template projectname:
     # Initializing Template {{projectname}}
     sed -i -e "s/PROJECT/{{projectname}}/g" ./modules/PROJECT/register_types.h ./modules/PROJECT/register_types.cpp ./project/project.godot ./project/export_presets.cfg .gitignore
-    sed "s/change_me/{{projectname}}/" ./justfile
+    sed -i -e "s/authority/{{projectname}}/" ./justfile
     mv ./modules/PROJECT ./modules/{{projectname}}
-    # Done Initializing, you will still have to update BUILD_NAME in your justfile
 
 format:
     # Formatting Custom Modules

modules/authority/actor_body.cpp

@@ -1,81 +0,0 @@
-#include "actor_body.h"
-#include "core/config/engine.h"
-#include "core/object/object.h"
-#include "macros.h"
-
-void ActorBody::_bind_methods() {
-	BIND_HPROPERTY(Variant::FLOAT, movement_speed, PROPERTY_HINT_RANGE, "0.0,20.0");
-}
-
-void ActorBody::physics_process(double delta) {
-	if (this->teleport_on_process) {
-		set_global_position(this->teleport_target);
-		this->teleport_on_process = false;
-		force_update_transform();
-	}
-	set_velocity(get_movement_direction() * this->movement_speed);
-	move_and_slide();
-}
-
-void ActorBody::_notification(int what) {
-	if (Engine::get_singleton()->is_editor_hint()) {
-		return;
-	}
-	switch (what) {
-		default:
-			return;
-		case NOTIFICATION_READY:
-			set_physics_process(true);
-			set_as_top_level(true);
-		case NOTIFICATION_PHYSICS_PROCESS:
-			physics_process(get_physics_process_delta_time());
-			return;
-	}
-}
-
-void ActorBody::set_movement_direction(Vector3 direction) {
-	this->mode = Direction;
-	this->movement_vector = Vector3(direction.x, 0.f, direction.z).normalized();
-}
-
-Vector3 ActorBody::get_movement_direction() const {
-	switch (this->mode) {
-		case Position: {
-			Vector3 const direction_3d{ get_global_position().direction_to(get_movement_target()) };
-			return Vector3{ direction_3d.x, 0.f, direction_3d.z };
-		} break;
-		case Direction:
-			return this->movement_vector;
-	}
-}
-
-void ActorBody::set_movement_target(Vector3 location) {
-	this->mode = Position;
-	this->movement_vector = { location.x, 0.f, location.z };
-}
-
-Vector3 ActorBody::get_movement_target() const {
-	switch (this->mode) {
-		case Position:
-			return this->movement_vector;
-		case Direction:
-			return get_global_position() + this->movement_vector;
-	}
-}
-
-void ActorBody::teleport(Vector3 target) {
-	this->teleport_target = target;
-	this->teleport_on_process = true;
-}
-
-void ActorBody::set_movement_speed(float speed) {
-	this->movement_speed = speed;
-}
-
-float ActorBody::get_movement_speed() const {
-	return this->movement_speed;
-}
-
-ActorBody::MovementMode ActorBody::get_movement_mode() const {
-	return this->mode;
-}

modules/authority/actor_body.h

@@ -1,37 +0,0 @@
-#ifndef ACTOR_BODY_H
-#define ACTOR_BODY_H
-
-#include "scene/3d/physics/character_body_3d.h"
-
-class ActorBody : public CharacterBody3D {
-	GDCLASS(ActorBody, CharacterBody3D);
-	static void _bind_methods();
-	void physics_process(double delta);
-
-public:
-	// support both directional and positional movement modes
-	enum MovementMode {
-		Direction,
-		Position
-	};
-	void _notification(int what);
-
-	void set_movement_direction(Vector3 direction);
-	Vector3 get_movement_direction() const;
-	void set_movement_target(Vector3 location);
-	Vector3 get_movement_target() const;
-	void teleport(Vector3 target);
-
-	void set_movement_speed(float speed);
-	float get_movement_speed() const;
-	MovementMode get_movement_mode() const;
-
-private:
-	float movement_speed{ 3.f };
-	Vector3 movement_vector{ 0.f, 0.f, 0.f };
-	MovementMode mode{ Direction };
-	bool teleport_on_process{ false };
-	Vector3 teleport_target{};
-};
-
-#endif //! ACTOR_BODY_H

modules/authority/character.cpp

@@ -0,0 +1,155 @@
+#include "character.h"
+#include "core/config/engine.h"
+#include "macros.h"
+
+void CharacterData::_bind_methods() {
+	BIND_PROPERTY(Variant::FLOAT, speed);
+}
+
+void Character::_bind_methods() {
+	BIND_HPROPERTY(Variant::OBJECT, data, PROPERTY_HINT_RESOURCE_TYPE, "CharacterData");
+}
+
+void Character::physics_process(double delta) {
+	Vector3 const velocity{ get_velocity() };
+	Vector3 new_velocity{ velocity };
+	new_velocity.x = this->world_movement_direction.x;
+	new_velocity.z = this->world_movement_direction.y;
+	set_velocity(new_velocity);
+	if (!velocity.is_zero_approx()) {
+		move_and_slide();
+	}
+}
+
+void Character::_notification(int what) {
+	if (Engine::get_singleton()->is_editor_hint() || !this->data.is_valid()) {
+		return;
+	}
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_READY:
+			set_physics_process(true);
+			return;
+		case NOTIFICATION_PHYSICS_PROCESS:
+			physics_process(get_physics_process_delta_time());
+			return;
+	}
+}
+
+PackedStringArray Character::get_configuration_warnings() const {
+	PackedStringArray warnings{ super_type::get_configuration_warnings() };
+	if (this->data.is_null()) {
+		warnings.push_back("Character requires 'data' to be initialised. To avoid crashes consider adding a placeholder if you intend to programmatically initialise it.");
+	}
+	return warnings;
+}
+
+void Character::set_movement(Vector2 movement) {
+	this->world_movement_direction = movement;
+}
+
+bool Character::is_moving() const {
+	return !this->world_movement_direction.is_zero_approx();
+}
+
+void CharacterState::_bind_methods() {
+	BIND_PROPERTY(Variant::BOOL, start_active);
+}
+
+void CharacterState::_notification(int what) {
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_ENTER_TREE:
+			this->character = cast_to<Character>(get_parent());
+			ERR_FAIL_COND_EDMSG(this->character == nullptr, "CharacterState requires parent to be of type Character");
+			return;
+		case NOTIFICATION_READY:
+			if (start_active) {
+				callable_mp(this, &self_type::set_state_active).call_deferred(true);
+			}
+			return;
+	}
+}
+
+PackedStringArray CharacterState::get_configuration_warnings() const {
+	PackedStringArray warnings{ super_type::get_configuration_warnings() };
+	if (cast_to<Character>(get_parent()) == nullptr) {
+		warnings.push_back("CharacterState requires direct Character parent");
+	}
+	return warnings;
+}
+
+void CharacterState::switch_to_state(String value) {
+	if (!this->state_active) {
+		print_error(vformat("Attempt to switch from inactive state %s to new state %s", get_path(), value));
+		return;
+	}
+	set_state_active(false);
+	stack_state_independent(value);
+}
+
+void CharacterState::stack_state_dependent(String value) {
+	if (!this->state_active) {
+		print_error(vformat("Attempt to stack dependent state %s from inactive state %s", value, get_path()));
+		return;
+	}
+	Node *node{ get_parent()->get_node(value) };
+	if (CharacterState * state{ cast_to<CharacterState>(node) }) {
+		state->depending_state = this;
+		this->dependent_states.insert(state);
+		state->set_state_active(true);
+	}
+}
+
+void CharacterState::notify_dependent_inactive(CharacterState *state) {
+	if (!this->state_active) {
+		print_error(vformat("Received notification that dependent state %s became inactive, while depending state %s was inactive", state->get_path(), get_path()));
+		return;
+	}
+	this->dependent_states.erase(state);
+}
+
+void CharacterState::stack_state_independent(String value) {
+	if (!this->state_active) {
+		print_error(vformat("Attempt to stack state %s from inactive state %s", value, get_path()));
+		return;
+	}
+	Node *node{ get_parent()->get_node(value) };
+	if (CharacterState * state{ cast_to<CharacterState>(node) }) {
+		state->set_state_active(true);
+	} else {
+		print_error(vformat("Attempt to stack nonexistent state %s from %s", value, get_path()));
+	}
+}
+
+void CharacterState::set_state_active(bool active) {
+	if (this->state_active != active) {
+		this->state_active = active;
+		if (active) {
+			state_entered();
+		} else {
+			state_exited();
+			if (this->depending_state && this->depending_state->state_active) {
+				this->depending_state->notify_dependent_inactive(this);
+			}
+			this->depending_state = nullptr;
+			for (CharacterState *state : this->dependent_states) {
+				state->set_state_active(false);
+			}
+			this->dependent_states.clear();
+		}
+	}
+}
+
+bool CharacterState::get_state_active() const {
+	return this->state_active;
+}
+
+Character *CharacterState::get_character() const {
+	return this->character;
+}

modules/authority/character.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "core/io/resource.h"
+#include "core/templates/hash_set.h"
+#include "macros.h"
+#include "scene/3d/physics/character_body_3d.h"
+
+class CharacterData : public Resource {
+	GDCLASS(CharacterData, Resource);
+	static void _bind_methods();
+
+private:
+	float speed{};
+
+public:
+	GET_SET_FNS(float, speed);
+};
+
+class Character : public CharacterBody3D {
+	GDCLASS(Character, CharacterBody3D);
+
+protected:
+	static void _bind_methods();
+	void physics_process(double delta);
+	void _notification(int what);
+	PackedStringArray get_configuration_warnings() const override;
+
+public:
+	void set_movement(Vector2 movement);
+	bool is_moving() const;
+
+private:
+	Ref<CharacterData> data{};
+	Vector2 world_movement_direction{};
+
+public:
+	GET_SET_FNS(Ref<CharacterData>, data);
+};
+
+class CharacterState : public Node {
+	GDCLASS(CharacterState, Node);
+	static void _bind_methods();
+
+protected:
+	void _notification(int what);
+	PackedStringArray get_configuration_warnings() const override;
+	void switch_to_state(String state);
+	void stack_state_dependent(String state);
+	void notify_dependent_inactive(CharacterState *dependent);
+	void stack_state_independent(String state);
+	virtual void state_entered() {}
+	virtual void state_exited() {}
+
+public:
+	void set_state_active(bool active);
+	bool get_state_active() const;
+	Character *get_character() const;
+
+private:
+	bool start_active{ false };
+	bool state_active{ false };
+
+	Character *character{ nullptr };
+	HashSet<CharacterState *> dependent_states{};
+	CharacterState *depending_state{ nullptr };
+
+public:
+	GET_SET_FNS(bool, start_active);
+};

modules/authority/game_state.cpp

@@ -1,18 +0,0 @@
-#include "game_state.h"
-#include "macros.h"
-
-GameState *GameState::singleton_instance{ nullptr };
-
-void GameState::_bind_methods() {}
-
-GameState::GameState() {
-	self_type::singleton_instance = this;
-}
-
-GameState::~GameState() {
-	self_type::singleton_instance = nullptr;
-}
-
-GameState *GameState::get_singleton() {
-	return self_type::singleton_instance;
-}

modules/authority/game_state.h

@@ -1,19 +0,0 @@
-#ifndef GAME_STATE_H
-#define GAME_STATE_H
-
-#include "core/object/class_db.h"
-#include "core/object/object.h"
-#include "core/templates/vector.h"
-
-class GameState : public Object {
-	GDCLASS(GameState, Object);
-	static void _bind_methods();
-	static GameState *singleton_instance;
-
-public:
-	GameState();
-	virtual ~GameState();
-	static GameState *get_singleton();
-};
-
-#endif // !GAME_STATE_H

modules/authority/nav_marker.cpp

@@ -0,0 +1,13 @@
+#include "nav_marker.h"
+
+void NavMarker::_bind_methods() {}
+
+void NavMarker::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_ENTER_TREE:
+			this->set_gizmo_extents(3);
+			return;
+	}
+}

modules/authority/nav_marker.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "macros.h"
+#include "scene/3d/marker_3d.h"
+class Character;
+
+class NavMarker : public Marker3D {
+	GDCLASS(NavMarker, Marker3D);
+	static void _bind_methods();
+
+protected:
+	void _notification(int what);
+
+private:
+	Character *claimed{ nullptr };
+
+public:
+	GET_SET_FNS(Character *, claimed);
+};

modules/authority/party_member_states.cpp

@@ -0,0 +1,84 @@
+#include "party_member_states.h"
+#include "authority/nav_marker.h"
+#include "authority/player_character.h"
+#include "core/config/engine.h"
+#include "core/error/error_macros.h"
+#include "core/templates/vector.h"
+
+void PartyMemberFollow::_bind_methods() {}
+
+void PartyMemberFollow::process_position_target() {
+	Vector3 const marker_position{ this->claimed_marker->get_global_position() };
+	Vector3 const nav_target{ this->nav->get_target_position() };
+	Vector3 const global_position{ get_character()->get_global_position() };
+	if (global_position.distance_squared_to(marker_position) < 0.5) {
+		return;
+	}
+	if (nav_target.distance_squared_to(marker_position) > 0.25) {
+		this->nav->set_target_position(marker_position);
+	}
+	if (this->nav->is_navigation_finished()) {
+		return;
+	}
+	Vector3 velocity{ global_position.direction_to(this->nav->get_next_path_position()) };
+	velocity.y = 0;
+	if (this->nav->get_avoidance_enabled()) {
+		this->nav->set_velocity(velocity * get_character()->get_data()->get_speed());
+	} else {
+		push_movement_direction(velocity * get_character()->get_data()->get_speed());
+	}
+}
+
+void PartyMemberFollow::push_movement_direction(Vector3 velocity) {
+	get_character()->set_movement(Vector2{ velocity.x, velocity.z });
+}
+
+void PartyMemberFollow::_notification(int what) {
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_READY:
+			this->nav = cast_to<NavigationAgent3D>(get_parent()->get_node(NodePath("%NavigationAgent3D")));
+			ERR_FAIL_COND_EDMSG(this->nav == nullptr, "PartyMemberFollow cannot initialise without a navigation agent");
+			return;
+		case NOTIFICATION_PROCESS:
+			process_position_target();
+			return;
+	}
+}
+
+PackedStringArray PartyMemberFollow::get_configuration_warnings() const {
+	PackedStringArray warnings{ super_type::get_configuration_warnings() };
+	if (!get_parent()->has_node(NodePath("%NavigationAgent3D")) || !cast_to<NavigationAgent3D>(get_parent()->get_node(NodePath("%NavigationAgent3D")))) {
+		warnings.push_back("PartyMemberFollow expects a scene sibling of type NavigationAgent3D named with unique name '%NavigationAgent3D'");
+	}
+	return warnings;
+}
+
+void PartyMemberFollow::state_entered() {
+	Vector<NavMarker *> const &markers{ PlayerCharacter::get_singleton()->get_party_follow_markers() };
+	for (NavMarker *marker : markers) {
+		if (marker->get_claimed() == nullptr) {
+			marker->set_claimed(get_character());
+			this->claimed_marker = marker;
+			if (this->nav->get_avoidance_enabled()) {
+				this->nav->connect("velocity_computed", callable_mp(this, &self_type::push_movement_direction));
+			}
+			set_process(true);
+			return;
+		}
+	}
+	ERR_FAIL_EDMSG("PartyMemberFollow could not find an unclaimed player follow marker");
+	set_state_active(false);
+}
+
+void PartyMemberFollow::state_exited() {
+	if (this->claimed_marker) {
+		this->claimed_marker->set_claimed(nullptr);
+		this->nav->disconnect("velocity_computed", callable_mp(this, &self_type::push_movement_direction));
+		set_process(false);
+	}
+}

modules/authority/party_member_states.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "authority/character.h"
+#include "authority/nav_marker.h"
+#include "scene/3d/navigation/navigation_agent_3d.h"
+
+class PartyMemberFollow : public CharacterState {
+	GDCLASS(PartyMemberFollow, CharacterState);
+	static void _bind_methods();
+	void process_position_target();
+	void push_movement_direction(Vector3 velocity);
+
+protected:
+	void _notification(int what);
+	PackedStringArray get_configuration_warnings() const override;
+	void state_entered() override;
+	void state_exited() override;
+
+private:
+	NavigationAgent3D *nav{ nullptr };
+	NavMarker *claimed_marker{ nullptr };
+};

modules/authority/player_actor.cpp

@@ -1,42 +0,0 @@
-#include "player_actor.h"
-#include "authority/game_state.h"
-#include "authority/player_input.h"
-#include "scene/main/viewport.h"
-
-void PlayerActor::_bind_methods() {
-}
-
-void PlayerActor::ready() {
-	PlayerInput *input{ cast_to<PlayerInput>(get_node(NodePath("%PlayerInput"))) };
-	input->connect(PlayerInput::signal_movement, callable_mp(this, &self_type::input_move));
-	set_process(true);
-}
-
-void PlayerActor::process(double delta) {
-	Basis const basis{ this->get_viewport()->get_camera_3d()->get_global_basis() };
-	Vector3 x{ basis.get_column(0) };
-	x = Vector3{ x.x, 0.f, x.z }.normalized();
-	Vector3 z{ basis.get_column(2) };
-	z = Vector3{ z.x, 0.f, z.z }.normalized();
-	set_movement_direction(x * this->move_input.x + z * this->move_input.y);
-}
-
-void PlayerActor::input_move(Vector2 movement) {
-	this->move_input = movement;
-}
-
-void PlayerActor::_notification(int what) {
-	if (Engine::get_singleton()->is_editor_hint()) {
-		return;
-	}
-	switch (what) {
-		default:
-			return;
-		case NOTIFICATION_READY:
-			ready();
-			return;
-		case NOTIFICATION_PROCESS:
-			process(get_process_delta_time());
-			return;
-	}
-}

modules/authority/player_actor.h

@@ -1,20 +0,0 @@
-#ifndef PLAYER_ACTOR_H
-#define PLAYER_ACTOR_H
-
-#include "actor_body.h"
-
-class PlayerActor : public ActorBody {
-	GDCLASS(PlayerActor, ActorBody);
-	static void _bind_methods();
-	void ready();
-	void process(double delta);
-	void input_move(Vector2 movement);
-
-public:
-	void _notification(int what);
-
-private:
-	Vector2 move_input{ 0.f, 0.f };
-};
-
-#endif // !PLAYER_ACTOR_H

modules/authority/player_camera.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "scene/3d/camera_3d.h"
+
+class PlayerCamera : public Camera3D {
+	GDCLASS(PlayerCamera, Camera3D);
+	static void _bind_methods();
+};

modules/authority/player_character.cpp

@@ -0,0 +1,36 @@
+#include "player_character.h"
+#include "authority/nav_marker.h"
+
+void PlayerCharacter::_bind_methods() {}
+
+void PlayerCharacter::_notification(int what) {
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_ENTER_TREE:
+			instance = this;
+			return;
+		case NOTIFICATION_READY:
+			for (Variant var : find_children("*", "NavMarker")) {
+				if (NavMarker * marker{ cast_to<NavMarker>(var) }) {
+					this->party_follow_markers.push_back(marker);
+				}
+			}
+			ERR_FAIL_COND_EDMSG(this->party_follow_markers.size() < 4, "PlayerCharacter should have at least 4 follow NavMarkers for party members");
+			return;
+		case NOTIFICATION_EXIT_TREE:
+			if (instance == this) {
+				instance = nullptr;
+			}
+			return;
+	}
+}
+
+PlayerCharacter *PlayerCharacter::instance{ nullptr };
+
+PlayerCharacter *PlayerCharacter::get_singleton() {
+	return instance;
+}

modules/authority/player_character.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "authority/character.h"
+#include "authority/nav_marker.h"
+#include "macros.h"
+
+class PlayerCharacter : public Character {
+	GDCLASS(PlayerCharacter, Character);
+	static void _bind_methods();
+
+protected:
+	void _notification(int what);
+
+private:
+	Vector<NavMarker *> party_follow_markers{};
+	static PlayerCharacter *instance;
+
+public:
+	static PlayerCharacter *get_singleton();
+	GET_SET_FNS(Vector<NavMarker *> const &, party_follow_markers);
+};

modules/authority/player_input.cpp

@@ -1,146 +0,0 @@
-#include "player_input.h"
-
-#include "core/input/input_event.h"
-#include "macros.h"
-
-String const PlayerInput::signal_movement{ "movement" };
-String const PlayerInput::signal_look{ "look" };
-String const PlayerInput::signal_mouselook{ "mouselook" };
-
-void PlayerInput::_bind_methods() {
-	BIND_PROPERTY(Variant::STRING, action_move_left);
-	BIND_PROPERTY(Variant::STRING, action_move_right);
-	BIND_PROPERTY(Variant::STRING, action_move_forward);
-	BIND_PROPERTY(Variant::STRING, action_move_back);
-	BIND_PROPERTY(Variant::STRING, action_look_left);
-	BIND_PROPERTY(Variant::STRING, action_look_right);
-	BIND_PROPERTY(Variant::STRING, action_look_up);
-	BIND_PROPERTY(Variant::STRING, action_look_down);
-	ADD_SIGNAL(MethodInfo(self_type::signal_movement, PropertyInfo(Variant::VECTOR2, "movement_directions")));
-	ADD_SIGNAL(MethodInfo(self_type::signal_look, PropertyInfo(Variant::VECTOR2, "look_delta")));
-	ADD_SIGNAL(MethodInfo(self_type::signal_mouselook, PropertyInfo(Variant::VECTOR2, "mouse_delta")));
-}
-
-void PlayerInput::_notification(int what) {
-	if (Engine::get_singleton()->is_editor_hint()) {
-		return;
-	}
-	switch (what) {
-		default:
-			return;
-		case NOTIFICATION_READY:
-			set_process_unhandled_input(true);
-			Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_CAPTURED);
-			return;
-	}
-}
-
-void PlayerInput::unhandled_input(Ref<InputEvent> const &event) {
-	Input *input{ Input::get_singleton() };
-
-	bool is_movement_action{ event->is_action(self_type::action_move_left) };
-	is_movement_action |= event->is_action(self_type::action_move_right);
-	is_movement_action |= event->is_action(self_type::action_move_forward);
-	is_movement_action |= event->is_action(self_type::action_move_back);
-	if (is_movement_action) {
-		float const h_axis{ input->get_axis(self_type::action_move_left, self_type::action_move_right) };
-		float const v_axis{ input->get_axis(self_type::action_move_forward, self_type::action_move_back) };
-		emit_signal(self_type::signal_movement, Vector2{ h_axis, v_axis });
-	}
-
-	bool is_look_action{ event->is_action(self_type::action_look_left) };
-	is_look_action |= event->is_action(self_type::action_look_right);
-	is_look_action |= event->is_action(self_type::action_look_up);
-	is_look_action |= event->is_action(self_type::action_look_down);
-	if (is_look_action) {
-		float const h_axis{ input->get_axis(self_type::action_look_right, self_type::action_look_left) };
-		float const v_axis{ input->get_axis(self_type::action_look_down, self_type::action_look_up) };
-		emit_signal(self_type::signal_look, Vector2{ h_axis, v_axis } * this->look_speed);
-	}
-
-	Ref<InputEventMouseMotion> mouse_motion_action{ event };
-	if (mouse_motion_action.is_valid()) {
-		Vector2 const velocity{ mouse_motion_action->get_relative() };
-		emit_signal(self_type::signal_mouselook, velocity * this->mouselook_speed);
-	}
-}
-
-void PlayerInput::set_mouselook_speed(Vector2 speed) {
-	this->mouselook_speed = speed;
-}
-
-Vector2 PlayerInput::get_mouselook_speed() const {
-	return this->mouselook_speed;
-}
-
-void PlayerInput::set_look_speed(Vector2 speed) {
-	this->look_speed = speed;
-}
-
-Vector2 PlayerInput::get_look_speed() const {
-	return this->look_speed;
-}
-
-void PlayerInput::set_action_move_left(String action) {
-	this->action_move_left = action;
-}
-
-String PlayerInput::get_action_move_left() const {
-	return this->action_move_left;
-}
-
-void PlayerInput::set_action_move_right(String action) {
-	this->action_move_right = action;
-}
-
-String PlayerInput::get_action_move_right() const {
-	return this->action_move_right;
-}
-
-void PlayerInput::set_action_move_forward(String action) {
-	this->action_move_forward = action;
-}
-
-String PlayerInput::get_action_move_forward() const {
-	return this->action_move_forward;
-}
-
-void PlayerInput::set_action_move_back(String action) {
-	this->action_move_back = action;
-}
-
-String PlayerInput::get_action_move_back() const {
-	return this->action_move_back;
-}
-
-void PlayerInput::set_action_look_left(String action) {
-	this->action_look_left = action;
-}
-
-String PlayerInput::get_action_look_left() const {
-	return this->action_look_left;
-}
-
-void PlayerInput::set_action_look_right(String action) {
-	this->action_look_right = action;
-}
-
-String PlayerInput::get_action_look_right() const {
-	return this->action_look_right;
-}
-
-void PlayerInput::set_action_look_up(String action) {
-	this->action_look_up = action;
-}
-
-String PlayerInput::get_action_look_up() const {
-	return this->action_look_up;
-}
-
-void PlayerInput::set_action_look_down(String action) {
-	this->action_look_down = action;
-}
-
-String PlayerInput::get_action_look_down() const {
-	return this->action_look_down;
-}

modules/authority/player_input.h

@@ -1,58 +0,0 @@
-#ifndef PLAYER_INPUT_H
-#define PLAYER_INPUT_H
-
-#include "core/input/input_event.h"
-#include "scene/main/node.h"
-
-class PlayerInput : public Node {
-	GDCLASS(PlayerInput, Node);
-	static void _bind_methods();
-
-public:
-	void _notification(int what);
-	virtual void unhandled_input(Ref<InputEvent> const &event) override;
-
-	void set_mouselook_speed(Vector2 speed);
-	Vector2 get_mouselook_speed() const;
-	void set_look_speed(Vector2 speed);
-	Vector2 get_look_speed() const;
-
-	void set_action_move_left(String action);
-	String get_action_move_left() const;
-	void set_action_move_right(String action);
-	String get_action_move_right() const;
-	void set_action_move_forward(String action);
-	String get_action_move_forward() const;
-	void set_action_move_back(String action);
-	String get_action_move_back() const;
-
-	void set_action_look_left(String action);
-	String get_action_look_left() const;
-	void set_action_look_right(String action);
-	String get_action_look_right() const;
-	void set_action_look_up(String action);
-	String get_action_look_up() const;
-	void set_action_look_down(String action);
-	String get_action_look_down() const;
-
-public:
-	static String const signal_movement;
-	static String const signal_look;
-	static String const signal_mouselook;
-
-private:
-	Vector2 mouselook_speed{ 0.001f, 0.001f };
-	Vector2 look_speed{ 1.75f, 1.75f };
-
-	String action_move_left{ "move_left" };
-	String action_move_right{ "move_right" };
-	String action_move_forward{ "move_forward" };
-	String action_move_back{ "move_back" };
-
-	String action_look_left{ "look_left" };
-	String action_look_right{ "look_right" };
-	String action_look_up{ "look_up" };
-	String action_look_down{ "look_down" };
-};
-
-#endif // !PLAYER_INPUT_H

modules/authority/player_states.cpp

@@ -0,0 +1,75 @@
+#include "player_states.h"
+#include "core/input/input.h"
+#include "core/math/basis.h"
+#include "scene/3d/camera_3d.h"
+#include "scene/main/viewport.h"
+
+void PlayerInputState::_bind_methods() {}
+
+void PlayerInputState::unhandled_input(Ref<InputEvent> const &what) {
+	bool const is_move_vertical{ what->is_action("move_forward") || what->is_action("move_backward") };
+	bool const is_move_horizontal{ what->is_action("move_right") || what->is_action("move_left") };
+	if (is_move_vertical || is_move_horizontal) {
+		stack_state_dependent("PlayerMovementState");
+		get_viewport()->set_input_as_handled();
+	}
+}
+
+void PlayerInputState::state_entered() {
+	set_process_unhandled_input(true);
+}
+
+void PlayerInputState::state_exited() {
+	set_process_unhandled_input(false);
+}
+
+void PlayerMovementState::_bind_methods() {}
+
+void PlayerMovementState::process(double delta) {
+	Basis const basis{ get_viewport()->get_camera_3d()->get_global_basis() };
+	Vector2 backward{ basis.get_column(0).x, basis.get_column(0).z };
+	if (backward.is_zero_approx()) {
+		backward = Vector2{ basis.get_column(1).x, basis.get_column(1).z };
+	}
+	Vector2 const right{ basis.get_column(2).x, basis.get_column(2).z };
+	get_character()->set_movement((backward.normalized() * this->movement.x + right.normalized() * this->movement.y) * get_character()->get_data()->get_speed());
+}
+
+void PlayerMovementState::_notification(int what) {
+	if (Engine::get_singleton()->is_editor_hint()) {
+		return;
+	}
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_READY:
+			set_process_input(true);
+			return;
+		case NOTIFICATION_PROCESS:
+			process(get_process_delta_time());
+			return;
+	}
+}
+
+void PlayerMovementState::input(Ref<InputEvent> const &what) {
+	bool const is_move_vertical{ what->is_action("move_forward") || what->is_action("move_backward") };
+	bool const is_move_horizontal{ what->is_action("move_right") || what->is_action("move_left") };
+	if (is_move_vertical || is_move_horizontal) {
+		this->movement = {
+			Input::get_singleton()->get_axis("move_left", "move_right"),
+			Input::get_singleton()->get_axis("move_forward", "move_backward")
+		};
+		this->movement.normalize();
+	}
+	if (this->get_state_active() && this->movement.is_zero_approx()) {
+		set_state_active(false);
+	}
+}
+
+void PlayerMovementState::state_entered() {
+	set_process(true);
+}
+
+void PlayerMovementState::state_exited() {
+	set_process(false);
+}

modules/authority/player_states.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "authority/character.h"
+
+class PlayerInputState : public CharacterState {
+	GDCLASS(PlayerInputState, CharacterState);
+	static void _bind_methods();
+
+protected:
+	void unhandled_input(Ref<InputEvent> const &event) override;
+	void state_entered() override;
+	void state_exited() override;
+};
+
+class PlayerMovementState : public CharacterState {
+	GDCLASS(PlayerMovementState, CharacterState);
+	static void _bind_methods();
+	void ready();
+	void process(double delta);
+
+protected:
+	void _notification(int what);
+	void input(Ref<InputEvent> const &event) override;
+	void state_entered() override;
+	void state_exited() override;
+
+private:
+	Vector2 movement{};
+};

modules/authority/register_types.cpp

@@ -1,34 +1,28 @@
 #include "register_types.h"
 
-#include "authority/actor_body.h"
-#include "authority/game_state.h"
-#include "authority/player_actor.h"
-#include "authority/player_input.h"
-#include "authority/third_person_camera.h"
-#include "core/config/engine.h"
+#include "authority/character.h"
+#include "authority/nav_marker.h"
+#include "authority/party_member_states.h"
+#include "authority/player_character.h"
+#include "authority/player_states.h"
 #include "core/object/class_db.h"
 
-GameState *game_state{ nullptr };
-
 void initialize_authority_module(ModuleInitializationLevel p_level) {
 	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
 		return;
 	}
-	GDREGISTER_CLASS(GameState);
-	GDREGISTER_CLASS(ActorBody);
-	GDREGISTER_CLASS(PlayerActor);
-	GDREGISTER_CLASS(PlayerInput);
-	GDREGISTER_CLASS(ThirdPersonCamera);
-
-	game_state = memnew(GameState);
-	Engine::get_singleton()->add_singleton(Engine::Singleton("GameState", GameState::get_singleton()));
+	ClassDB::register_class<CharacterData>();
+	ClassDB::register_class<Character>();
+	ClassDB::register_class<CharacterState>();
+	ClassDB::register_class<PlayerCharacter>();
+	ClassDB::register_class<PlayerInputState>();
+	ClassDB::register_class<PlayerMovementState>();
+	ClassDB::register_class<NavMarker>();
+	ClassDB::register_class<PartyMemberFollow>();
 }
 
 void uninitialize_authority_module(ModuleInitializationLevel p_level) {
 	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
 		return;
 	}
-	if (game_state) {
-		memdelete(game_state);
-	}
 }

modules/authority/third_person_camera.cpp

@@ -1,54 +0,0 @@
-#include "third_person_camera.h"
-#include "player_input.h"
-
-void ThirdPersonCamera::_bind_methods() {
-}
-
-void ThirdPersonCamera::ready() {
-	set_process(true);
-	if (PlayerInput * player_input{ cast_to<PlayerInput>(get_node(NodePath("%PlayerInput"))) }) {
-		player_input->connect(PlayerInput::signal_look, callable_mp(this, &self_type::on_look_input));
-		player_input->connect(PlayerInput::signal_mouselook, callable_mp(this, &self_type::on_mouselook_input));
-	}
-}
-
-void ThirdPersonCamera::process(double delta) {
-	this->look_rotation += look_rotation_motion * delta;
-	this->look_rotation.y = CLAMP(this->look_rotation.y, -Math_PI / 2.5, Math_PI / 2.5);
-	Vector3 pivot{ get_parent_node_3d()->get_global_position() };
-	pivot.y += this->height;
-	Vector3 offset{ 0.f, 0.f, this->distance };
-	offset.rotate({ 1.f, 0.f, 0.f }, this->look_rotation.y);
-	offset.rotate({ 0.f, 1.f, 0.f }, this->look_rotation.x);
-	look_at_from_position(pivot + offset, pivot);
-}
-
-void ThirdPersonCamera::on_look_input(Vector2 input) {
-	this->look_rotation_motion = input;
-}
-
-void ThirdPersonCamera::on_mouselook_input(Vector2 input) {
-	this->look_rotation -= input;
-}
-
-void ThirdPersonCamera::_notification(int what) {
-	if (Engine::get_singleton()->is_editor_hint()) {
-		return;
-	}
-	switch (what) {
-		case NOTIFICATION_READY:
-			ready();
-			break;
-		case NOTIFICATION_PROCESS:
-			process(get_process_delta_time());
-			break;
-	}
-}
-
-void ThirdPersonCamera::set_base_rotation_speed(Vector2 value) {
-	this->base_rotation_speed = value;
-}
-
-Vector2 ThirdPersonCamera::get_base_rotation_speed() const {
-	return this->base_rotation_speed;
-}

modules/authority/third_person_camera.h

@@ -1,29 +0,0 @@
-#ifndef THIRD_PERSON_CAMERA_H
-#define THIRD_PERSON_CAMERA_H
-
-#include "scene/3d/camera_3d.h"
-
-class ThirdPersonCamera : public Camera3D {
-	GDCLASS(ThirdPersonCamera, Camera3D);
-	static void _bind_methods();
-	void ready();
-	void process(double delta);
-	void on_look_input(Vector2 input);
-	void on_mouselook_input(Vector2 input);
-
-public:
-	void _notification(int what);
-
-	void set_base_rotation_speed(Vector2 value);
-	Vector2 get_base_rotation_speed() const;
-
-private:
-	Vector2 look_rotation_motion{ 0.f, 0.f };
-	Vector2 look_rotation{ 0.f, 0.f };
-
-	Vector2 base_rotation_speed{ 0.1f, 0.1f };
-	float distance{ 3.f };
-	float height{ 2.2f };
-};
-
-#endif // !THIRD_PERSON_CAMERA_H

modules/macros.h

@@ -17,4 +17,29 @@
 	ADD_PROPERTY(PropertyInfo(m_type, #m_property), "set_" #m_property, \
 			"get_" #m_property)
 
+#define GET_SET_FNS(m_type, m_property)   \
+	m_type get_##m_property() const {     \
+		return this->m_property;          \
+	}                                     \
+	void set_##m_property(m_type value) { \
+		this->m_property = value;         \
+	}
+
+#define GET_SET_FNS_EX(m_type, m_property, m_ex) \
+	m_type get_##m_property() const {            \
+		return this->m_property;                 \
+	}                                            \
+	void set_##m_property(m_type value) {        \
+		m_ex;                                    \
+		this->m_property = value;                \
+	}
+
+#define __VA_ARGS__STRING(...) String(#__VA_ARGS__)
+
+#define GDENUM(M_Name, ...)                    \
+	enum M_Name { __VA_ARGS__ };               \
+	static String M_Name##_hint() {            \
+		return __VA_ARGS__STRING(__VA_ARGS__); \
+	}
+
 #endif // !GODOT_EXTRA_MACROS_H

modules/terrain/SCsub

@@ -0,0 +1,3 @@
+Import('env')
+
+env.add_source_files(env.modules_sources, "*.cpp")

modules/terrain/config.py

@@ -0,0 +1,5 @@
+def can_build(env, platform):
+    return True;
+
+def configure(env):
+    pass;

modules/terrain/register_types.cpp

@@ -0,0 +1,24 @@
+#include "register_types.h"
+
+#include "core/object/class_db.h"
+#include "terrain/terrain.h"
+#include "terrain/terrain_chunk.h"
+#include "terrain/terrain_modifier.h"
+
+void initialize_terrain_module(ModuleInitializationLevel p_level) {
+	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
+		return;
+	}
+	ClassDB::register_class<Terrain>();
+	ClassDB::register_abstract_class<TerrainModifier>();
+	ClassDB::register_class<TerrainModifierDistance>();
+	ClassDB::register_class<TerrainModifierPath>();
+	ClassDB::register_class<TerrainModifierPathPoint>();
+	ClassDB::register_class<TerrainChunkMesh>();
+}
+
+void uninitialize_terrain_module(ModuleInitializationLevel p_level) {
+	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
+		return;
+	}
+}

modules/terrain/register_types.h

@@ -0,0 +1,9 @@
+#ifndef TERRAIN_REGISTER_TYPES_H
+#define TERRAIN_REGISTER_TYPES_H
+
+#include "modules/register_module_types.h"
+
+void initialize_terrain_module(ModuleInitializationLevel p_level);
+void uninitialize_terrain_module(ModuleInitializationLevel p_level);
+
+#endif // !TERRAIN_REGISTER_TYPES_H

modules/terrain/terrain.cpp

@@ -0,0 +1,208 @@
+#include "terrain.h"
+#include "terrain/terrain_chunk.h"
+#include "terrain/terrain_modifier.h"
+
+void Terrain::_bind_methods() {
+	BIND_PROPERTY(Variant::INT, side_length);
+	BIND_PROPERTY(Variant::INT, chunk_size);
+	BIND_PROPERTY(Variant::INT, detail);
+	BIND_PROPERTY(Variant::INT, thread_count);
+}
+
+void Terrain::child_order_changed() {
+	this->modifiers.clear();
+	for (Variant var : get_children()) {
+		if (TerrainModifier * mod{ cast_to<TerrainModifier>(var) }) {
+			mod->set_terrain(this);
+			this->modifiers.push_back(mod);
+		}
+	}
+}
+
+void Terrain::update_meshes() {
+	size_t num{ 1 };
+	this->dirty_meshes_lock.lock();
+	num = num > this->dirty_meshes.size() ? this->dirty_meshes.size() : num;
+	this->dirty_meshes_lock.unlock();
+	for (size_t i{ 0 }; i < num; i++) {
+		this->dirty_meshes_lock.lock();
+		TerrainChunkMesh *mesh{ this->dirty_meshes[0] };
+		this->dirty_meshes.remove_at(0);
+		this->dirty_meshes_lock.unlock();
+		mesh->apply_new_mesh();
+	}
+	if (this->dirty_meshes.is_empty()) {
+		set_process(false);
+	}
+}
+
+void Terrain::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_ENTER_TREE:
+			if (!is_ready()) {
+				connect("child_order_changed", callable_mp(this, &self_type::child_order_changed));
+			}
+			return;
+		case NOTIFICATION_READY:
+			construct_chunk_grid();
+			return;
+		case NOTIFICATION_PROCESS:
+			update_meshes();
+			return;
+		case NOTIFICATION_EXIT_TREE:
+			this->workload_lock.lock();
+			this->threads_stop = true;
+			this->workload_lock.unlock();
+			for (Thread &thread : this->threads) {
+				thread.wait_to_finish();
+			}
+			return;
+	}
+}
+
+void Terrain::generate_meshes_thread(void *terrain) {
+	Terrain *self{ static_cast<Terrain *>(terrain) };
+	print_line("thread", Thread::get_caller_id(), "start");
+	for (;;) {
+		self->workload_lock.lock();
+		if (self->threads_stop) {
+			self->workload_lock.unlock();
+			print_line(Thread::get_caller_id(), "exiting");
+			break;
+		}
+		if (self->workload.is_empty()) {
+			self->workload_lock.unlock();
+			Thread::yield();
+			continue;
+		}
+		TerrainChunkMesh *mesh{ self->workload[0] };
+		self->workload.remove_at(0);
+		self->workload_lock.unlock();
+		if (!mesh->is_inside_tree()) {
+			print_line(Thread::get_caller_id(), "mesh is outside tree, exiting");
+			break;
+		}
+		mesh->update_mesh();
+		Thread::yield();
+	}
+	print_line(Thread::get_caller_id(), "done");
+	return;
+}
+
+void Terrain::construct_chunk_grid() {
+	this->workload_lock.lock();
+	this->threads_stop = true;
+	this->workload_lock.unlock();
+	for (Thread &thread : this->threads) {
+		thread.wait_to_finish();
+	}
+	this->workload_lock.lock();
+	for (TerrainChunkMesh *mesh : this->meshes) {
+		remove_child(mesh);
+		mesh->queue_free();
+	}
+	size_t const chunks_per_side{ this->side_length / this->chunk_size };
+	Vector3 const origin{ (float)this->chunk_size / 2.f, 0.f, (float)this->chunk_size / 2.f };
+	this->meshes.clear();
+	this->workload.clear();
+	for (size_t y{ 0 }; y < chunks_per_side; ++y) {
+		for (size_t x{ 0 }; x < chunks_per_side; ++x) {
+			TerrainChunkMesh *chunk{ memnew(TerrainChunkMesh) };
+			chunk->set_size(this->chunk_size);
+			chunk->set_detail(this->detail);
+			chunk->set_terrain(this);
+			chunk->set_position(origin + Vector3{ (float)this->chunk_size * (float)x, 0.f, (float)this->chunk_size * (float)y });
+			add_child(chunk);
+			chunk->set_owner(this);
+			this->meshes.push_back(chunk);
+			this->workload.push_back(chunk);
+		}
+	}
+	this->threads_stop = false;
+	this->dirty_meshes.clear();
+	this->workload_lock.unlock();
+	for (Thread &thread : this->threads) {
+		thread.start(&self_type::generate_meshes_thread, this);
+	}
+}
+
+float Terrain::height_at(Vector2 world_coordinate) {
+	float height{ 0 };
+	for (TerrainModifier *mod : this->modifiers) {
+		if (!mod->is_inside_tree()) {
+			return height;
+		}
+		height = mod->evaluate_at(world_coordinate, height);
+	}
+	return height;
+}
+
+void Terrain::push_changed(Rect2 area) {
+	for (TerrainChunkMesh *mesh : this->meshes) {
+		this->workload_lock.lock();
+		if (area.intersects(mesh->get_bounds()) && !this->workload.has(mesh)) {
+			workload.push_back(mesh);
+		}
+		this->workload_lock.unlock();
+	}
+}
+
+void Terrain::mesh_dirty(TerrainChunkMesh *mesh) {
+	this->dirty_meshes_lock.lock();
+	this->dirty_meshes.push_back(mesh);
+	callable_mp(cast_to<Node>(this), &self_type::set_process).call_deferred(true);
+	this->dirty_meshes_lock.unlock();
+}
+
+void Terrain::set_side_length(size_t length) {
+	this->side_length = length;
+	if (is_inside_tree()) {
+		construct_chunk_grid();
+	}
+}
+
+size_t Terrain::get_side_length() const {
+	return this->side_length;
+}
+
+void Terrain::set_chunk_size(size_t size) {
+	this->chunk_size = size;
+	if (is_inside_tree()) {
+		construct_chunk_grid();
+	}
+}
+
+size_t Terrain::get_chunk_size() const {
+	return this->chunk_size;
+}
+
+void Terrain::set_detail(size_t detail) {
+	this->detail = detail;
+	if (is_inside_tree()) {
+		construct_chunk_grid();
+	}
+}
+
+size_t Terrain::get_detail() const {
+	return this->detail;
+}
+
+void Terrain::set_thread_count(size_t num) {
+	this->workload_lock.lock();
+	this->threads_stop = true;
+	this->workload_lock.unlock();
+	for (Thread &thread : this->threads) {
+		thread.wait_to_finish();
+	}
+	this->threads_stop = false;
+	this->threads.resize_initialized(num);
+	for (Thread &thread : this->threads) {
+		thread.start(&self_type::generate_meshes_thread, this);
+	}
+}
+
+size_t Terrain::get_thread_count() const {
+	return this->threads.size();
+}

modules/terrain/terrain.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "core/math/rect2.h"
+#include "core/os/mutex.h"
+#include "core/os/thread.h"
+#include "core/templates/vector.h"
+#include "scene/main/node.h"
+class TerrainChunkMesh;
+class TerrainModifier;
+
+class Terrain : public Node {
+	GDCLASS(Terrain, Node);
+	static void _bind_methods();
+	void child_order_changed();
+	void update_meshes();
+
+protected:
+	void _notification(int what);
+	static void generate_meshes_thread(void *terrain);
+
+public:
+	void construct_chunk_grid();
+	float height_at(Vector2 world_coordinate);
+	void push_changed(Rect2 area);
+	void mesh_dirty(TerrainChunkMesh *mesh);
+
+private:
+	Vector<TerrainChunkMesh *> workload{};
+	bool threads_stop{ false };
+	Mutex workload_lock;
+
+	Vector<TerrainChunkMesh *> dirty_meshes{};
+	Mutex dirty_meshes_lock{};
+
+	Vector<TerrainChunkMesh *> meshes{};
+	Vector<TerrainModifier *> modifiers{};
+	LocalVector<Thread> threads{};
+
+	size_t side_length{ 200 };
+	size_t chunk_size{ 50 };
+	size_t detail{ 1 };
+
+public:
+	void set_side_length(size_t length);
+	size_t get_side_length() const;
+	void set_chunk_size(size_t size);
+	size_t get_chunk_size() const;
+	void set_detail(size_t detail);
+	size_t get_detail() const;
+	void set_thread_count(size_t num);
+	size_t get_thread_count() const;
+};

modules/terrain/terrain_chunk.cpp

@@ -0,0 +1,89 @@
+#include "terrain_chunk.h"
+#include "core/variant/variant.h"
+#include "scene/resources/surface_tool.h"
+#include "terrain/terrain.h"
+
+void TerrainChunkMesh::_bind_methods() {}
+
+void TerrainChunkMesh::generate_vertices() {
+	ERR_FAIL_COND_EDMSG(this->terrain == nullptr, "TerrainChunkMesh::generate_vertices: no terrain assigned");
+	ERR_FAIL_COND_EDMSG(this->size <= 0.f, "TerrainChunkMesh::generate_vertices: size <= 0");
+	ERR_FAIL_COND_EDMSG(points_per_side() <= 0, "TerrainChunkMesh::generate_vertices: points per side <= 0");
+	float const half_extent{ (float)this->size / 2.f };
+	float const point_distance{ (float)this->size / ((float)points_per_side() - 1) };
+	Vector3 origin{ this->safe_position - Vector3{ half_extent, 0, half_extent } };
+	for (size_t x{ 0 }; x < points_per_side(); ++x) {
+		for (size_t y{ 0 }; y < points_per_side(); ++y) {
+			Vector2 const coordinate{ origin.x + point_distance * x, origin.z + point_distance * y };
+			this->surface->set_uv({ (float)x / (float)points_per_side(), (float)y / (float)points_per_side() });
+			this->surface->add_vertex({ coordinate.x - this->safe_position.x, this->terrain->height_at(coordinate), coordinate.y - this->safe_position.z });
+		}
+	}
+}
+
+void TerrainChunkMesh::generate_faces() {
+	LocalVector<SurfaceTool::Vertex> &verts{ this->surface->get_vertex_array() };
+	ERR_FAIL_COND_EDMSG(verts.size() == 0, "TerrainChunkMesh::generate_faces: no vertices in surface, call generate_vertices first");
+	size_t const faces_per_side{ points_per_side() - 1 };
+	for (size_t x{ 0 }; x < faces_per_side; ++x) {
+		for (size_t y{ 0 }; y < faces_per_side; ++y) {
+			size_t const tl{ x + y * points_per_side() };
+			float tl_br{ verts[tl].vertex.distance_to(verts[tl + points_per_side() + 1].vertex) };
+			float tr_bl{ verts[tl + 1].vertex.distance_to(verts[tl + points_per_side()].vertex) };
+			if (tl_br < tr_bl) {
+				surface->add_index(tl);
+				surface->add_index(tl + points_per_side() + 1);
+				surface->add_index(tl + 1);
+				surface->add_index(tl);
+				surface->add_index(tl + points_per_side());
+				surface->add_index(tl + points_per_side() + 1);
+			} else {
+				surface->add_index(tl + points_per_side());
+				surface->add_index(tl + points_per_side() + 1);
+				surface->add_index(tl + 1);
+				surface->add_index(tl + 1);
+				surface->add_index(tl);
+				surface->add_index(tl + points_per_side());
+			}
+		}
+	}
+}
+
+void TerrainChunkMesh::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_READY:
+			this->safe_position = get_global_position();
+			float const sizef{ (float)get_size() };
+			this->bounds.position = { this->safe_position.x - sizef / 2.f, this->safe_position.z - sizef / 2.f };
+			this->bounds.size = { sizef, sizef };
+			return;
+	}
+}
+
+void TerrainChunkMesh::apply_new_mesh() {
+	this->lock.lock();
+	set_mesh(this->new_mesh);
+	this->lock.unlock();
+}
+
+void TerrainChunkMesh::update_mesh() {
+	ERR_FAIL_COND_EDMSG(this->size <= 0.f, "TerrainChunkMesh::generate: size <= 0");
+	ERR_FAIL_COND_EDMSG(points_per_side() <= 0, "TerrainChunkMesh::generate: points per side <= 0");
+	this->lock.lock();
+	this->surface = memnew(SurfaceTool);
+	this->surface->begin(Mesh::PRIMITIVE_TRIANGLES);
+	generate_vertices();
+	generate_faces();
+	this->surface->generate_normals();
+	this->surface->generate_tangents();
+	this->new_mesh = memnew(ArrayMesh);
+	this->surface->commit(this->new_mesh);
+	this->lock.unlock();
+	this->terrain->mesh_dirty(this);
+}
+
+size_t TerrainChunkMesh::points_per_side() const {
+	return this->size * this->detail;
+}

modules/terrain/terrain_chunk.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "core/math/rect2.h"
+#include "macros.h"
+#include "scene/3d/mesh_instance_3d.h"
+#include "scene/resources/mesh.h"
+#include "scene/resources/surface_tool.h"
+class Terrain;
+
+class TerrainChunkMesh : public MeshInstance3D {
+	GDCLASS(TerrainChunkMesh, MeshInstance3D);
+	static void _bind_methods();
+	void generate_vertices();
+	void generate_faces();
+
+protected:
+	void _notification(int what);
+
+public:
+	void apply_new_mesh();
+	void update_mesh();
+	size_t points_per_side() const;
+
+private:
+	Mutex lock{};
+	Vector3 safe_position{};
+	Ref<SurfaceTool> surface{};
+	Ref<ArrayMesh> new_mesh{};
+	Terrain *terrain{ nullptr };
+	size_t detail{ 1 };
+	size_t size{ 1 };
+	Rect2 bounds{};
+
+public:
+	GET_SET_FNS(Rect2, bounds);
+	GET_SET_FNS(Terrain *, terrain);
+	GET_SET_FNS(size_t, detail);
+	GET_SET_FNS(size_t, size);
+};

modules/terrain/terrain_modifier.cpp

@@ -0,0 +1,392 @@
+#include "terrain_modifier.h"
+#include "core/config/engine.h"
+#include "core/math/math_funcs.h"
+#include "core/variant/variant.h"
+#include "macros.h"
+#include "terrain/terrain.h"
+#include <algorithm>
+
+void TerrainModifier::_bind_methods() {}
+
+void TerrainModifier::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_ENTER_TREE:
+			if (Engine::get_singleton()->is_editor_hint()) {
+				set_notify_transform(true);
+			}
+			this->thread_safe_global_position = get_global_position();
+		case NOTIFICATION_TRANSFORM_CHANGED:
+			this->thread_safe_global_position = get_global_position();
+			return;
+	}
+}
+
+void TerrainModifier::push_changed(Rect2 area) {
+	if (this->terrain) {
+		this->terrain->push_changed(area);
+	}
+}
+
+float TerrainModifier::evaluate_at(Vector2 world_coordinate, float before) {
+	Vector3 const global_position{ get_thread_safe_global_position() };
+	return global_position.y;
+}
+
+void TerrainModifier::set_bounds(Rect2 bounds) {
+	if (this->bounds != bounds) {
+		push_changed(bounds);
+		push_changed(this->bounds);
+		this->bounds = bounds;
+	}
+}
+
+Rect2 TerrainModifier::get_bounds() const {
+	return this->bounds;
+}
+
+Vector3 TerrainModifier::get_thread_safe_global_position() const {
+	return this->thread_safe_global_position;
+}
+
+void SharedMutex::lock_shared() {
+	this->lock.lock();
+	this->shared_count++;
+	this->lock.unlock();
+}
+
+void SharedMutex::unlock_shared() {
+	this->lock.lock();
+	this->shared_count--;
+	this->lock.unlock();
+}
+
+void SharedMutex::lock_exclusive() {
+	while (true) {
+		this->lock.lock();
+		if (this->shared_count == 0) {
+			return;
+		}
+		this->lock.unlock();
+	}
+}
+
+void SharedMutex::unlock_exclusive() {
+	this->lock.unlock();
+}
+
+void TerrainModifierDistance::_bind_methods() {
+	BIND_HPROPERTY(Variant::OBJECT, distance_weight_curve, PROPERTY_HINT_RESOURCE_TYPE, "Curve");
+}
+
+void TerrainModifierDistance::curves_changed() {
+	if (!update_bounds()) {
+		push_changed(get_bounds());
+	}
+}
+
+bool TerrainModifierDistance::update_bounds() {
+	Rect2 const before{ get_bounds() };
+	Rect2 bounds{};
+	Vector3 position{ get_thread_safe_global_position() };
+	bounds.position = { position.x, position.z };
+	bounds.size = { 0, 0 };
+	this->lock.lock_shared();
+	if (this->distance_weight_curve.is_valid()) {
+		float const max_radius{ this->distance_weight_curve->get_max_domain() };
+		float const max_diameter{ 2.f * max_radius };
+		bounds.size = { max_diameter, max_diameter };
+		bounds.position -= { max_radius, max_radius };
+	}
+	this->lock.unlock_shared();
+	this->lock.lock_exclusive();
+	bool const changed{ before != bounds };
+	set_bounds(bounds);
+	this->lock.unlock_exclusive();
+	return changed;
+}
+
+void TerrainModifierDistance::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_READY:
+			update_bounds();
+			set_notify_transform(true);
+			return;
+		case NOTIFICATION_TRANSFORM_CHANGED:
+			if (is_inside_tree()) {
+				if (!update_bounds()) {
+					push_changed(get_bounds());
+				}
+			}
+			return;
+	}
+}
+
+float TerrainModifierDistance::distance_at(Vector2 const &world_coordinate) {
+	Vector3 const global_position{ get_thread_safe_global_position() };
+	return world_coordinate.distance_to({ global_position.x, global_position.z });
+}
+
+float TerrainModifierDistance::evaluate_at(Vector2 world_coordinate, float before) {
+	this->lock.lock_shared();
+	if (this->distance_weight_curve.is_null()) {
+		this->lock.unlock_shared();
+		return before;
+	}
+	float const distance{ distance_at(world_coordinate) };
+	if (distance >= this->distance_weight_curve->get_max_domain()) {
+		this->lock.unlock_shared();
+		return before;
+	}
+	float const weight_offset{
+		std::clamp(distance, this->distance_weight_curve->get_min_domain(), this->distance_weight_curve->get_max_domain())
+	};
+	float const weight{ this->distance_weight_curve->sample(weight_offset) };
+	float out{ weight <= 0.f ? before : Math::lerp(before, get_thread_safe_global_position().y, weight) };
+	this->lock.unlock_shared();
+
+	return out;
+}
+
+PackedStringArray TerrainModifierDistance::get_configuration_warnings() const {
+	PackedStringArray warnings{ super_type::get_configuration_warnings() };
+	if (this->distance_weight_curve.is_null()) {
+		warnings.push_back("distance_weight_curve is invalid, add a valid distance_weight_curve");
+	}
+	return warnings;
+}
+
+void TerrainModifierDistance::set_distance_weight_curve(Ref<Curve> curve) {
+	this->lock.lock_exclusive();
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (this->distance_weight_curve.is_valid()) {
+			this->distance_weight_curve->disconnect_changed(callable_mp(this, &self_type::curves_changed));
+		}
+		if (curve.is_valid()) {
+			curve->connect_changed(callable_mp(this, &self_type::curves_changed));
+		}
+	}
+	this->distance_weight_curve = curve;
+	this->lock.unlock_exclusive();
+	curves_changed();
+	update_configuration_warnings();
+}
+
+Ref<Curve> TerrainModifierDistance::get_distance_weight_curve() const {
+	return this->distance_weight_curve;
+}
+
+void TerrainModifierPathPoint::_bind_methods() {}
+
+void TerrainModifierPathPoint::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_ENTER_TREE:
+			if ((this->path = cast_to<TerrainModifierPath>(get_parent()))) {
+				this->path->path_changed();
+			}
+			return;
+		case NOTIFICATION_READY:
+			set_notify_transform(true);
+			return;
+		case NOTIFICATION_TRANSFORM_CHANGED:
+			if (this->path) {
+				this->path->path_changed();
+			}
+			return;
+		case NOTIFICATION_EXIT_TREE:
+			this->path = nullptr;
+			return;
+	}
+}
+
+void TerrainModifierPath::_bind_methods() {
+	BIND_HPROPERTY(Variant::OBJECT, curve_left, PROPERTY_HINT_RESOURCE_TYPE, "Curve");
+	BIND_HPROPERTY(Variant::OBJECT, curve_right, PROPERTY_HINT_RESOURCE_TYPE, "Curve");
+}
+
+void TerrainModifierPath::curves_changed() {
+	if (!update_bounds()) {
+		push_changed(get_bounds());
+	}
+}
+
+bool TerrainModifierPath::update_bounds() {
+	Vector2 min{}, max{};
+	this->lock.lock_shared();
+	if (this->points.is_empty() || this->curve_left.is_null() || this->curve_right.is_null()) {
+		Vector3 point{ this->get_thread_safe_global_position() };
+		min.x = point.x;
+		min.y = point.z;
+		max = min;
+	} else {
+		max = min = { this->points[0].x, this->points[0].y };
+		for (Vector3 const &point : this->points) {
+			max.x = max.x > point.x ? max.x : point.x;
+			max.y = max.y > point.z ? max.y : point.z;
+			min.x = min.x < point.x ? min.x : point.x;
+			min.y = min.y < point.z ? min.y : point.z;
+		}
+		float max_distance_left{ this->curve_left->get_max_domain() };
+		float max_distance_right{ this->curve_right->get_max_domain() };
+		float max_distance{ max_distance_left > max_distance_right ? max_distance_left : max_distance_right };
+		min -= { max_distance, max_distance };
+		max += { max_distance, max_distance };
+	}
+	Rect2 bounds{ min, max - min };
+	bool const changed{ bounds != get_bounds() };
+	this->lock.unlock_shared();
+	set_bounds(bounds);
+	return changed;
+}
+
+void TerrainModifierPath::_notification(int what) {
+	switch (what) {
+		default:
+			return;
+		case NOTIFICATION_READY:
+			update_bounds();
+			set_notify_transform(true);
+			return;
+		case NOTIFICATION_TRANSFORM_CHANGED:
+			if (is_inside_tree()) {
+				if (!update_bounds()) {
+					push_changed(get_bounds());
+				}
+			}
+			return;
+	}
+}
+
+float TerrainModifierPath::evaluate_line(Vector3 a, bool a_end, Vector3 b, bool b_end, Vector2 world_coordinate, float &out_dot, float &out_distance) {
+	Vector2 a2{ a.x, a.z }, b2{ b.x, b.z };
+	Vector2 const relative_coordinate{ world_coordinate - a2 };
+	Vector2 const difference2{ b2 - a2 };
+	float w{ difference2.normalized().dot(relative_coordinate) / difference2.length() };
+	Vector3 const difference{ b - a };
+	Vector3 const closest_on_line{ a + difference * (w > 0 ? (w < 1 ? w : 1) : 0) };
+	Vector2 const right{ -difference.z, difference.x };
+	out_dot = right.normalized().dot(relative_coordinate);
+	out_distance = world_coordinate.distance_to({ closest_on_line.x, closest_on_line.z });
+	if (a_end) {
+		w = w > 0 ? w : 0;
+	}
+	if (b_end) {
+		w = w < 1 ? w : 1;
+	}
+	return a.y + (b.y - a.y) * w;
+}
+
+float TerrainModifierPath::evaluate_at(Vector2 world_coordinate, float before) {
+	this->lock.lock_shared();
+	if (this->curve_left.is_null() || this->curve_right.is_null() || this->points.size() <= 1) {
+		this->lock.unlock_shared();
+		return before;
+	}
+	float const max_distance{ this->curve_left->get_max_domain() > this->curve_right->get_max_domain() ? this->curve_left->get_max_domain() : this->curve_right->get_max_domain() };
+	float out_score{ -INFINITY };
+	float out_height{ 0 };
+	long const count{ this->closed ? this->points.size() : this->points.size() - 1 };
+	for (int i{ 0 }; i < count; i++) {
+		float dot, distance;
+		float const height{ evaluate_line(this->points[i], !this->closed && i == 0, this->points[Math::wrapi(i + 1, 0, this->points.size())], !this->closed && i == count - 1, world_coordinate, dot, distance) };
+		float const left{ this->curve_left->sample(distance) };
+		float const right{ this->curve_right->sample(distance) };
+		float const ndot{ dot / distance };
+		float separation{ ndot / 2.f + 0.5f };
+		if (closed || (i > 0 && i < count - 1)) {
+			separation = Math::round(separation);
+		}
+		float const weight{ left * (1 - separation) + right * separation };
+		float const blended_height{ Math::lerp(before, height, weight) };
+		float const score{ weight - (1 - Math::abs(ndot)) * 2.f - (distance / max_distance) };
+		if (score > out_score) {
+			out_score = score;
+			out_height = blended_height;
+		}
+	}
+	this->lock.unlock_shared();
+	return out_height;
+}
+
+void TerrainModifierPath::path_changed() {
+	this->lock.lock_exclusive();
+	this->points.clear();
+	this->min_height = INFINITY;
+	this->max_height = -INFINITY;
+	Vector3 last{ INFINITY, INFINITY, INFINITY };
+	for (Variant var : get_children()) {
+		if (TerrainModifierPathPoint * point{ cast_to<TerrainModifierPathPoint>(var) }) {
+			Vector3 position{ point->get_global_position() };
+			if (position != last) {
+				this->points.push_back(position);
+				if (position.y > this->max_height) {
+					this->max_height = position.y;
+				}
+				if (position.y < this->min_height) {
+					this->min_height = position.y;
+				}
+			}
+		}
+		last = var;
+	}
+	this->lock.unlock_exclusive();
+	if (!update_bounds()) {
+		push_changed(get_bounds());
+	}
+}
+
+PackedStringArray TerrainModifierPath::get_configuration_warnings() const {
+	PackedStringArray warnings{ super_type::get_configuration_warnings() };
+	if (this->curve_left.is_null()) {
+		warnings.push_back("distance_weight_curve is invalid, add a valid curve_left");
+	}
+	if (this->curve_right.is_null()) {
+		warnings.push_back("distance_weight_curve is invalid, add a valid curve_right");
+	}
+	return warnings;
+}
+
+void TerrainModifierPath::set_curve_left(Ref<Curve> curve) {
+	this->lock.lock_exclusive();
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (this->curve_left.is_valid()) {
+			this->curve_left->disconnect_changed(callable_mp(this, &self_type::curves_changed));
+		}
+		if (curve.is_valid()) {
+			curve->connect_changed(callable_mp(this, &self_type::curves_changed));
+		}
+	}
+	this->curve_left = curve;
+	this->lock.unlock_exclusive();
+	curves_changed();
+	update_configuration_warnings();
+}
+
+Ref<Curve> TerrainModifierPath::get_curve_left() const {
+	return this->curve_left;
+}
+
+void TerrainModifierPath::set_curve_right(Ref<Curve> curve) {
+	this->lock.lock_exclusive();
+	if (Engine::get_singleton()->is_editor_hint()) {
+		if (this->curve_right.is_valid()) {
+			this->curve_right->disconnect_changed(callable_mp(this, &self_type::curves_changed));
+		}
+		if (curve.is_valid()) {
+			curve->connect_changed(callable_mp(this, &self_type::curves_changed));
+		}
+	}
+	this->curve_right = curve;
+	this->lock.unlock_exclusive();
+	curves_changed();
+	update_configuration_warnings();
+}
+
+Ref<Curve> TerrainModifierPath::get_curve_right() const {
+	return this->curve_right;
+}

modules/terrain/terrain_modifier.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include "core/object/object.h"
+#include "core/variant/variant.h"
+#include "macros.h"
+#include "scene/3d/marker_3d.h"
+#include "scene/resources/curve.h"
+#include <cmath>
+class Terrain;
+
+class TerrainModifier : public Marker3D {
+	GDCLASS(TerrainModifier, Marker3D);
+	static void _bind_methods();
+
+protected:
+	void _notification(int what);
+	void push_changed(Rect2 bounds);
+
+public:
+	virtual float evaluate_at(Vector2 world_coordinate, float before);
+
+private:
+	Vector3 thread_safe_global_position{};
+	Terrain *terrain{ nullptr };
+	Rect2 bounds{ { -INFINITY, -INFINITY }, { INFINITY, INFINITY } };
+
+protected:
+	void set_bounds(Rect2 bounds);
+	Rect2 get_bounds() const;
+
+public:
+	Vector3 get_thread_safe_global_position() const;
+	GET_SET_FNS(Terrain *, terrain);
+};
+
+struct SharedMutex {
+	void lock_shared();
+	void unlock_shared();
+	void lock_exclusive();
+	void unlock_exclusive();
+
+private:
+	Mutex lock{};
+	int shared_count{};
+};
+
+class TerrainModifierDistance : public TerrainModifier {
+	GDCLASS(TerrainModifierDistance, TerrainModifier);
+	static void _bind_methods();
+	void curves_changed();
+	bool update_bounds();
+
+protected:
+	void _notification(int what);
+	float distance_at(Vector2 const &world_coordinate);
+
+public:
+	float evaluate_at(Vector2 world_coordinate, float before) override;
+	PackedStringArray get_configuration_warnings() const override;
+
+private:
+	SharedMutex lock{};
+	Ref<Curve> distance_weight_curve{};
+
+public:
+	void set_distance_weight_curve(Ref<Curve> curve);
+	Ref<Curve> get_distance_weight_curve() const;
+};
+
+class TerrainModifierPathPoint : public Marker3D {
+	GDCLASS(TerrainModifierPathPoint, Marker3D);
+	static void _bind_methods();
+
+protected:
+	void _notification(int what);
+
+public:
+	class TerrainModifierPath *path{ nullptr };
+};
+
+class TerrainModifierPath : public TerrainModifier {
+	GDCLASS(TerrainModifierPath, TerrainModifier);
+	static void _bind_methods();
+	void curves_changed();
+	bool update_bounds();
+
+protected:
+	void _notification(int what);
+	float evaluate_line(Vector3 a, bool a_end, Vector3 b, bool b_end, Vector2 world_coordinate, float &out_dot, float &out_distance);
+
+public:
+	float evaluate_at(Vector2 world_coordinate, float before) override;
+	void path_changed();
+	PackedStringArray get_configuration_warnings() const override;
+
+private:
+	SharedMutex lock{};
+	float min_height{};
+	float max_height{};
+	bool closed{ false };
+	Vector<Vector3> points{};
+	Ref<Curve> curve_left{};
+	Ref<Curve> curve_right{};
+
+public:
+	void set_curve_left(Ref<Curve> curve);
+	Ref<Curve> get_curve_left() const;
+	void set_curve_right(Ref<Curve> curve);
+	Ref<Curve> get_curve_right() const;
+};

project/assets/characters/player_fem/character_fem.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://grb3q5nd2uds"
+path="res://.godot/imported/character_fem.blend-e169cb46816e89cf00aa8e7f988a0574.scn"
+
+[deps]
+
+source_file="res://assets/characters/player_fem/character_fem.blend"
+dest_files=["res://.godot/imported/character_fem.blend-e169cb46816e89cf00aa8e7f988a0574.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/characters/player_fem/textures/Face.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://biqq268lccpng"
+path.s3tc="res://.godot/imported/Face.png-08c0111f3b71fa077c35243a4c740f6e.s3tc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/characters/player_fem/textures/Face.png"
+dest_files=["res://.godot/imported/Face.png-08c0111f3b71fa077c35243a4c740f6e.s3tc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/characters/player_fem/textures/Texture.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://cwqc2g4616eun"
+path.s3tc="res://.godot/imported/Texture.png-98af1a158e1830cbcd0a13178176c442.s3tc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/characters/player_fem/textures/Texture.png"
+dest_files=["res://.godot/imported/Texture.png-98af1a158e1830cbcd0a13178176c442.s3tc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/characters/player_masc/character_masc.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://bsdvnyn6nhiaa"
+path="res://.godot/imported/character_masc.blend-0037c94467e2e85d7ec685a838d7e95d.scn"
+
+[deps]
+
+source_file="res://assets/characters/player_masc/character_masc.blend"
+dest_files=["res://.godot/imported/character_masc.blend-0037c94467e2e85d7ec685a838d7e95d.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path=""
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/characters/player_masc/textures/Face.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://b7n0rgtlub4r7"
+path.s3tc="res://.godot/imported/Face.png-f5f833f7c71137a9e4aac5fe268e4dd4.s3tc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/characters/player_masc/textures/Face.png"
+dest_files=["res://.godot/imported/Face.png-f5f833f7c71137a9e4aac5fe268e4dd4.s3tc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/characters/player_masc/textures/Texture.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://lea3dgv2585y"
+path.s3tc="res://.godot/imported/Texture.png-51f4b86d2d244a13f05f399cc30a0d6b.s3tc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/characters/player_masc/textures/Texture.png"
+dest_files=["res://.godot/imported/Texture.png-51f4b86d2d244a13f05f399cc30a0d6b.s3tc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/environments/blockouts/cliffs_blockout.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://dw4p3s74f1pdg"
+path="res://.godot/imported/cliffs_blockout.blend-f86a374f2c48645fd5614df18445a45a.scn"
+
+[deps]
+
+source_file="res://assets/environments/blockouts/cliffs_blockout.blend"
+dest_files=["res://.godot/imported/cliffs_blockout.blend-f86a374f2c48645fd5614df18445a45a.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/environments/blockouts/terrain.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dwmur2qflotv6"
+path.bptc="res://.godot/imported/terrain.png-52ea7eaf6b989ed8d9fc2c0c5a398fdf.bptc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/environments/blockouts/terrain.png"
+dest_files=["res://.godot/imported/terrain.png-52ea7eaf6b989ed8d9fc2c0c5a398fdf.bptc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=true
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/environments/props/flower.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://dyt1mwbep2012"
+path="res://.godot/imported/flower.blend-a54f993c4db9e1bce792f272b6b1a837.scn"
+
+[deps]
+
+source_file="res://assets/environments/props/flower.blend"
+dest_files=["res://.godot/imported/flower.blend-a54f993c4db9e1bce792f272b6b1a837.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/environments/props/grass_a.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://uujfed6yrp8p"
+path.s3tc="res://.godot/imported/grass_a.png-df3280112d606c2f3fb6a8ca84baa85d.s3tc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/environments/props/grass_a.png"
+dest_files=["res://.godot/imported/grass_a.png-df3280112d606c2f3fb6a8ca84baa85d.s3tc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/environments/props/rock_a.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://db6ddpj53gl5w"
+path="res://.godot/imported/rock_a.blend-b8d8f34d9e140f1b8adb493b605dd07e.scn"
+
+[deps]
+
+source_file="res://assets/environments/props/rock_a.blend"
+dest_files=["res://.godot/imported/rock_a.blend-b8d8f34d9e140f1b8adb493b605dd07e.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/environments/props/rock_a.png.import

@@ -2,8 +2,8 @@
 
 importer="texture"
 type="CompressedTexture2D"
-uid="uid://bh68a5vqm5h7l"
-path.s3tc="res://.godot/imported/tent.png-683c31f751d990e004be3a99db100a94.s3tc.ctex"
+uid="uid://b4rklg0l7aqdm"
+path.s3tc="res://.godot/imported/rock_a.png-3ff1a5814ef260ae524170318024cca4.s3tc.ctex"
 metadata={
 "imported_formats": ["s3tc_bptc"],
 "vram_texture": true
@@ -11,14 +11,16 @@ metadata={
 
 [deps]
 
-source_file="res://textures/grids/tent.png"
-dest_files=["res://.godot/imported/tent.png-683c31f751d990e004be3a99db100a94.s3tc.ctex"]
+source_file="res://assets/environments/props/rock_a.png"
+dest_files=["res://.godot/imported/rock_a.png-3ff1a5814ef260ae524170318024cca4.s3tc.ctex"]
 
 [params]
 
 compress/mode=2
 compress/high_quality=false
 compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
 compress/hdr_compression=1
 compress/normal_map=0
 compress/channel_pack=0
@@ -26,6 +28,10 @@ mipmaps/generate=true
 mipmaps/limit=-1
 roughness/mode=0
 roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
 process/fix_alpha_border=true
 process/premult_alpha=false
 process/normal_map_invert_y=false

project/assets/environments/props/rock_b.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://517yqaw110pf"
+path="res://.godot/imported/rock_b.blend-d76791249d4c14d1c951b842f0208090.scn"
+
+[deps]
+
+source_file="res://assets/environments/props/rock_b.blend"
+dest_files=["res://.godot/imported/rock_b.blend-d76791249d4c14d1c951b842f0208090.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/environments/props/rock_b.png.import

@@ -2,8 +2,8 @@
 
 importer="texture"
 type="CompressedTexture2D"
-uid="uid://f8djywm2jlah"
-path.s3tc="res://.godot/imported/grass.png-94a6319b2d9ea30e834183f2653f3455.s3tc.ctex"
+uid="uid://dpn3sfcjnnool"
+path.s3tc="res://.godot/imported/rock_b.png-063dafa9684f12d7486304024d1aaecf.s3tc.ctex"
 metadata={
 "imported_formats": ["s3tc_bptc"],
 "vram_texture": true
@@ -11,14 +11,16 @@ metadata={
 
 [deps]
 
-source_file="res://textures/grids/grass.png"
-dest_files=["res://.godot/imported/grass.png-94a6319b2d9ea30e834183f2653f3455.s3tc.ctex"]
+source_file="res://assets/environments/props/rock_b.png"
+dest_files=["res://.godot/imported/rock_b.png-063dafa9684f12d7486304024d1aaecf.s3tc.ctex"]
 
 [params]
 
 compress/mode=2
 compress/high_quality=false
 compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
 compress/hdr_compression=1
 compress/normal_map=0
 compress/channel_pack=0
@@ -26,6 +28,10 @@ mipmaps/generate=true
 mipmaps/limit=-1
 roughness/mode=0
 roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
 process/fix_alpha_border=true
 process/premult_alpha=false
 process/normal_map_invert_y=false

project/assets/environments/props/rock_c.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://8n8fduklxduk"
+path="res://.godot/imported/rock_c.blend-26ab78e8b85061bd62ef5331656df04c.scn"
+
+[deps]
+
+source_file="res://assets/environments/props/rock_c.blend"
+dest_files=["res://.godot/imported/rock_c.blend-26ab78e8b85061bd62ef5331656df04c.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/environments/props/rock_c.png.import

@@ -2,8 +2,8 @@
 
 importer="texture"
 type="CompressedTexture2D"
-uid="uid://br64q04tpxmli"
-path.s3tc="res://.godot/imported/mud.png-f0a13a766854ada7e9976a2898dea1c2.s3tc.ctex"
+uid="uid://drf6dro5di2ap"
+path.s3tc="res://.godot/imported/rock_c.png-a276885ef75cf615c39e79d768211422.s3tc.ctex"
 metadata={
 "imported_formats": ["s3tc_bptc"],
 "vram_texture": true
@@ -11,14 +11,16 @@ metadata={
 
 [deps]
 
-source_file="res://textures/grids/mud.png"
-dest_files=["res://.godot/imported/mud.png-f0a13a766854ada7e9976a2898dea1c2.s3tc.ctex"]
+source_file="res://assets/environments/props/rock_c.png"
+dest_files=["res://.godot/imported/rock_c.png-a276885ef75cf615c39e79d768211422.s3tc.ctex"]
 
 [params]
 
 compress/mode=2
 compress/high_quality=false
 compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
 compress/hdr_compression=1
 compress/normal_map=0
 compress/channel_pack=0
@@ -26,6 +28,10 @@ mipmaps/generate=true
 mipmaps/limit=-1
 roughness/mode=0
 roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
 process/fix_alpha_border=true
 process/premult_alpha=false
 process/normal_map_invert_y=false

project/assets/environments/props/tree.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://bnm0go8negvo7"
+path="res://.godot/imported/tree.blend-20cb45b772c5003289278d8ec4060a00.scn"
+
+[deps]
+
+source_file="res://assets/environments/props/tree.blend"
+dest_files=["res://.godot/imported/tree.blend-20cb45b772c5003289278d8ec4060a00.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/environments/props/tree.png.import

@@ -0,0 +1,41 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://cvfsvh8tdpflf"
+path.bptc="res://.godot/imported/tree.png-b3baca9a70a35e7b7075603680fb265f.bptc.ctex"
+metadata={
+"imported_formats": ["s3tc_bptc"],
+"vram_texture": true
+}
+
+[deps]
+
+source_file="res://assets/environments/props/tree.png"
+dest_files=["res://.godot/imported/tree.png-b3baca9a70a35e7b7075603680fb265f.bptc.ctex"]
+
+[params]
+
+compress/mode=2
+compress/high_quality=true
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=true
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=0

project/assets/style/base_outline_material.tres

@@ -0,0 +1,16 @@
+[gd_resource type="StandardMaterial3D" format=3 uid="uid://cd4vnmrmj8cj7"]
+
+[resource]
+transparency = 2
+alpha_scissor_threshold = 0.5
+alpha_antialiasing_mode = 0
+cull_mode = 1
+shading_mode = 0
+diffuse_mode = 3
+specular_mode = 2
+vertex_color_use_as_albedo = true
+albedo_color = Color(0.121152334, 0.121152334, 0.121152334, 1)
+grow = true
+grow_amount = 0.02
+proximity_fade_distance = 0.1
+stencil_outline_thickness = 0.029

project/assets/style/detail_outline_material.tres

@@ -0,0 +1,17 @@
+[gd_resource type="StandardMaterial3D" format=3 uid="uid://02s3lq67141v"]
+
+[resource]
+transparency = 2
+alpha_scissor_threshold = 0.94
+alpha_antialiasing_mode = 0
+cull_mode = 1
+shading_mode = 0
+diffuse_mode = 3
+specular_mode = 2
+vertex_color_use_as_albedo = true
+albedo_color = Color(0.121152334, 0.121152334, 0.121152334, 1)
+grow = true
+grow_amount = 0.02
+proximity_fade_enabled = true
+proximity_fade_distance = 0.3
+stencil_outline_thickness = 0.029

project/assets/style/model_importer.gd

@@ -0,0 +1,36 @@
+@tool
+extends EditorScenePostImport
+
+var regular_outline_material : StandardMaterial3D
+var detail_outline_material : StandardMaterial3D
+var thin_outline_material : StandardMaterial3D
+
+func _post_import(root : Node):
+	regular_outline_material = ResourceLoader.load("res://assets/style/base_outline_material.tres") as StandardMaterial3D
+	detail_outline_material = ResourceLoader.load("res://assets/style/detail_outline_material.tres") as StandardMaterial3D
+	thin_outline_material = ResourceLoader.load("res://assets/style/thin_outline_material.tres") as StandardMaterial3D
+	apply_outline_recursive(root)
+	return root
+
+func get_flag(node : Node, flag : String) -> bool:
+	if node.name.contains(flag):
+		node.name = node.name.erase(node.name.find(flag), flag.length())
+		return true
+	else:
+		return false
+
+func apply_outline_recursive(node : Node):
+	if node != null:
+		var outline : bool = not get_flag(node, "-nooutline")
+		if outline and node is MeshInstance3D:
+			var detail : bool = get_flag(node, "-detailoutline")
+			var thin : bool = get_flag(node, "-thinoutline")
+			var mesh : MeshInstance3D = (node as MeshInstance3D)
+			if detail and detail_outline_material:
+				mesh.material_overlay = detail_outline_material
+			elif thin and thin_outline_material:
+				mesh.material_overlay = thin_outline_material
+			elif regular_outline_material:
+				mesh.material_overlay = regular_outline_material
+		for child in node.get_children():
+			apply_outline_recursive(child)

project/assets/style/model_importer.gd.uid

@@ -0,0 +1 @@
+uid://ba7qlhj5ylm3d

project/assets/style/thin_outline_material.tres

@@ -0,0 +1,22 @@
+[gd_resource type="StandardMaterial3D" format=3 uid="uid://vo4kk73alewq"]
+
+[ext_resource type="Material" uid="uid://02s3lq67141v" path="res://assets/style/detail_outline_material.tres" id="1_jjhui"]
+
+[resource]
+next_pass = ExtResource("1_jjhui")
+transparency = 2
+alpha_scissor_threshold = 0.9
+alpha_antialiasing_mode = 0
+cull_mode = 1
+shading_mode = 0
+diffuse_mode = 3
+specular_mode = 2
+vertex_color_use_as_albedo = true
+albedo_color = Color(0.121152334, 0.121152334, 0.121152334, 1)
+grow = true
+grow_amount = 0.007
+proximity_fade_distance = 0.1
+distance_fade_mode = 1
+distance_fade_min_distance = 10.0
+distance_fade_max_distance = 9.0
+stencil_outline_thickness = 0.029

project/assets/vehicles/bike.blend.import

@@ -0,0 +1,60 @@
+[remap]
+
+importer="scene"
+importer_version=1
+type="PackedScene"
+uid="uid://dkq8b07op54lx"
+path="res://.godot/imported/bike.blend-8d249f74417ff10660977200f19cdfc5.scn"
+
+[deps]
+
+source_file="res://assets/vehicles/bike.blend"
+dest_files=["res://.godot/imported/bike.blend-8d249f74417ff10660977200f19cdfc5.scn"]
+
+[params]
+
+nodes/root_type=""
+nodes/root_name=""
+nodes/root_script=null
+nodes/apply_root_scale=true
+nodes/root_scale=1.0
+nodes/import_as_skeleton_bones=false
+nodes/use_name_suffixes=true
+nodes/use_node_type_suffixes=true
+meshes/ensure_tangents=true
+meshes/generate_lods=true
+meshes/create_shadow_meshes=true
+meshes/light_baking=1
+meshes/lightmap_texel_size=0.2
+meshes/force_disable_compression=false
+skins/use_named_skins=true
+animation/import=true
+animation/fps=30
+animation/trimming=false
+animation/remove_immutable_tracks=true
+animation/import_rest_as_RESET=false
+import_script/path="uid://ba7qlhj5ylm3d"
+materials/extract=0
+materials/extract_format=0
+materials/extract_path=""
+_subresources={}
+blender/nodes/visible=0
+blender/nodes/active_collection_only=false
+blender/nodes/punctual_lights=true
+blender/nodes/cameras=true
+blender/nodes/custom_properties=true
+blender/nodes/modifiers=1
+blender/meshes/colors=false
+blender/meshes/uvs=true
+blender/meshes/normals=true
+blender/meshes/export_geometry_nodes_instances=false
+blender/meshes/gpu_instances=false
+blender/meshes/tangents=true
+blender/meshes/skins=2
+blender/meshes/export_bones_deforming_mesh_only=false
+blender/materials/unpack_enabled=true
+blender/materials/export_materials=1
+blender/animation/limit_playback=true
+blender/animation/always_sample=true
+blender/animation/group_tracks=true
+gltf/naming_version=2

project/assets/vehicles/sidecar.png.import

@@ -2,8 +2,8 @@
 
 importer="texture"
 type="CompressedTexture2D"
-uid="uid://cd4cchmulwnc5"
-path.s3tc="res://.godot/imported/bricks.png-217e783fed9aafaab4854f1be96e4aed.s3tc.ctex"
+uid="uid://csscfssydx1n4"
+path.s3tc="res://.godot/imported/sidecar.png-10b8daaf663ef9108162d2fab75bc493.s3tc.ctex"
 metadata={
 "imported_formats": ["s3tc_bptc"],
 "vram_texture": true
@@ -11,14 +11,16 @@ metadata={
 
 [deps]
 
-source_file="res://textures/grids/bricks.png"
-dest_files=["res://.godot/imported/bricks.png-217e783fed9aafaab4854f1be96e4aed.s3tc.ctex"]
+source_file="res://assets/vehicles/sidecar.png"
+dest_files=["res://.godot/imported/sidecar.png-10b8daaf663ef9108162d2fab75bc493.s3tc.ctex"]
 
 [params]
 
 compress/mode=2
 compress/high_quality=false
 compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
 compress/hdr_compression=1
 compress/normal_map=0
 compress/channel_pack=0
@@ -26,6 +28,10 @@ mipmaps/generate=true
 mipmaps/limit=-1
 roughness/mode=0
 roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
 process/fix_alpha_border=true
 process/premult_alpha=false
 process/normal_map_invert_y=false

project/data/character_data/fallback_character_data.tres

@@ -0,0 +1,4 @@
+[gd_resource type="CharacterData" format=3 uid="uid://d28pn4xekwh6p"]
+
+[resource]
+speed = 2.0

project/data/default_player_character.tres

@@ -0,0 +1,4 @@
+[gd_resource type="CharacterData" format=3 uid="uid://bmudhddb0vedg"]
+
+[resource]
+speed = 2.0

project/icon.svg.import

@@ -18,6 +18,8 @@ dest_files=["res://.godot/imported/icon.svg-218a8f2b3041327d8a5756f3a245f83b.cte
 compress/mode=0
 compress/high_quality=false
 compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
 compress/hdr_compression=1
 compress/normal_map=0
 compress/channel_pack=0
@@ -25,6 +27,10 @@ mipmaps/generate=false
 mipmaps/limit=-1
 roughness/mode=0
 roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
 process/fix_alpha_border=true
 process/premult_alpha=false
 process/normal_map_invert_y=false

project/level_props/tent.tscn

@@ -1,13 +0,0 @@
-[gd_scene load_steps=3 format=3 uid="uid://dkgep77ogr1tv"]
-
-[ext_resource type="Material" uid="uid://cupy5mpdsngcl" path="res://materials/grids/tent.tres" id="1_yfc7x"]
-
-[sub_resource type="BoxMesh" id="BoxMesh_dudpm"]
-size = Vector3(3, 1.3, 2)
-
-[node name="Tent" type="Node3D"]
-
-[node name="MeshInstance3D" type="MeshInstance3D" parent="."]
-transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.658981, 0)
-material_override = ExtResource("1_yfc7x")
-mesh = SubResource("BoxMesh_dudpm")