Wrap2D and Wrap3D nodes

[Shadowblitz16]

@Bioblaze
I was wondering if a Wrap2D and Wrap3D node could be added.

Basically they would wrap a target node around the bounds of the camera or a custom rectangle.

The problem with doing this in gdscript is it needs to simulate the entire node at 8 different locations.

• one for the top
• one for the bottom
• one for the left
• one for the right
• one for the top left
• one for the top right
• one for the bottom left
• one for the bottom right

that's x and y, the 3d version needs to account for z too

This is to ensure things like sprite wrapping.
It also ensures if you have a ship spawning a bullet it spawns bullets at the clones too.

It needs to also handle physics.
This is because if a physics body wraps around the border then it should check against the copies and and sync up the physics accordingly

My best attempt at doing a wrap2d node but it currently runs into a bug

@tool class_name Wrapper2D extends Node

class Target2D:
	var target:Node2D
	var parent:Node
	var clones:Array[Clone2D]=[]
	var wrapper:Wrapper2D

	static func create(wrapper:Wrapper2D, item:Node2D)->Target2D:
		var instance := Target2D.new()
		instance.wrapper = wrapper
		instance.target  = item
		instance.parent  = item.get_parent()
		instance.target.tree_exited.connect(instance._clean_up_target)
		instance.parent.tree_exited.connect(instance._clear_up_parent)
		item.ready.connect(instance._ready_clones.bind(instance, item))
		return instance

	func process_physics()->void:

		if target == null || not target.is_node_ready() || not target.is_inside_tree() || Engine.is_editor_hint(): return

		target.position.x = wrapf(target.position.x, wrapper.rect.position.x, wrapper.rect.position.x+wrapper.rect.size.x)
		target.position.y = wrapf(target.position.y, wrapper.rect.position.y, wrapper.rect.position.y+wrapper.rect.size.y)

		for clone in clones:
			if clone.clone == null || not clone.clone.is_node_ready() || not clone.clone.is_inside_tree(): return
			clone.sync_with(target)

	func _ready_clones(instance:Target2D, item:Node2D)->void:
		for clone_y in range(-1, 1, 2):
			for clone_x in range(-1, 1, 2):
				var clone := Clone2D.create(instance, clone_x, clone_y)
				instance.clones.append(clone)

	func _clean_up_target()->void:
		for clone in clones:
			parent.remove_child(clone.node)
		_clear_up_parent()
		target.tree_exited.disconnect(target._clean_up_target)
	func _clear_up_parent()->void:
		clones.clear()
		parent.tree_exited.disconnect(target._clear_up_parent)
class Clone2D:
	var clone           :Node2D
	var offset          :Vector2
	var position        :Vector2
	var rotation        :float
	var linear_velocity :Vector2
	var angular_velocity:float

	static func create(target:Target2D, x:int, y:int)->Clone2D:
		var rect     := target.target.get_viewport().get_visible_rect()
		var instance := Clone2D.new()
		instance.clone            = target.target.duplicate() as Node2D
		instance.offset           = Vector2(x*rect.size.x, y*rect.size.y)
		instance.position         = instance.clone.position + instance.offset
		instance.rotation         = instance.clone.rotation
		instance.linear_velocity  = instance.get_linear_velocity (instance.clone)
		instance.angular_velocity = instance.get_angular_velocity(instance.clone)

		print(target.target.is_node_ready())
		print(target.target.is_inside_tree())
		var wrappers := instance.find_wrapper_2d(instance.clone)
		for wrapper in wrappers:
			wrapper.queue_free()

		target.parent.call_deferred("add_child", instance.clone)
		return instance
	func find_wrapper_2d(node:Node)->Array[Wrapper2D]:
		var wrappers : Array[Wrapper2D] = []
		for child in node.get_children():
			if child is Wrapper2D:
				wrappers.append(child)
			wrappers.append_array(find_wrapper_2d(child))
		return wrappers

	func sync_with(target:Node2D)->void:
		sync_position_with(target)
		sync_rotation_with(target)
		sync_linear_velocity_with(target)
		sync_angular_velocity_with(target)

	func sync_position_with(target:Node2D)->void:
		var target_delta := target.position - position
		var clone_delta  := clone  .position - position

		if  target_delta != Vector2.ZERO:
			target.position += target_delta
		if  clone_delta  != Vector2.ZERO:
			clone .position += clone_delta

		position = target_delta - clone_delta

	func sync_rotation_with(target:Node2D)->void:
		var target_delta := target.rotation - rotation
		var clone_delta  := clone .rotation - rotation

		if  target_delta !=  0.0:
			target.rotation += target_delta
		if  clone_delta  != 0.0:
			clone .rotation += clone_delta

		rotation = target_delta - clone_delta


	func sync_linear_velocity_with(target:Node2D)->void:
		var target_delta := get_linear_velocity(target) - linear_velocity
		var clone_delta  := get_linear_velocity(clone ) - linear_velocity

		if  target_delta != Vector2.ZERO:
			try_set_linear_velocity(target, get_linear_velocity(target) + target_delta)
		if  clone_delta  != Vector2.ZERO:
			try_set_linear_velocity(clone, get_linear_velocity(clone) + clone_delta)

		linear_velocity = target_delta - clone_delta

	func sync_angular_velocity_with(target:Node2D)->void:
		var target_delta := get_angular_velocity(target) - angular_velocity
		var clone_delta  := get_angular_velocity(clone  ) - angular_velocity

		if  target_delta != 0.0:
			try_set_angular_velocity(target, get_angular_velocity(target) + target_delta)
		if  clone_delta  != 0.0:
			try_set_angular_velocity(clone, get_angular_velocity(clone) + clone_delta)

		angular_velocity = target_delta - clone_delta

	func try_set_linear_velocity(node:Node2D, linear_velocity:Vector2)->void:
		if node is RigidBody2D    : node.linear_velocity          = linear_velocity
		if node is CharacterBody2D: node.velocity                 = linear_velocity
		if node is StaticBody2D   : node.constant_linear_velocity = linear_velocity
	func try_set_angular_velocity(node:Node2D, angular_velocity:float)->void:
		if node is RigidBody2D    : node.angular_velocity          = angular_velocity
		if node is StaticBody2D   : node.constant_angular_velocity = angular_velocity
	func get_linear_velocity(node:Node2D)->Vector2:
		if node is RigidBody2D    : return node.linear_velocity
		if node is CharacterBody2D: return node.velocity
		if node is StaticBody2D   : return node.constant_linear_velocity
		return Vector2.ZERO
	func get_angular_velocity(node:Node2D)->float:
		if node is RigidBody2D    : return node.angular_velocity
		if node is CharacterBody2D: return 0.0
		if node is StaticBody2D   : return node.constant_angular_velocity
		return 0.0

enum RectMode {
	Manual,
	Viewport,
	Camera
}

var _target     : Target2D
var _rectangle  : ColorRect

@export var target    : Node2D
@export var rect      : Rect2:
	get = get_rect,
	set = set_rect
@export var rect_mode := RectMode.Camera


func _ready() -> void:
	_target             = Target2D.create(self, target)
	_rectangle          = ColorRect.new()
	_rectangle.color    = Color.YELLOW
	_rectangle.color.a8 = 64
	add_child(_rectangle)

func _physics_process(delta: float) -> void:
	_rectangle.global_position = rect.position
	_rectangle.size            = rect.size
	_target.process_physics()

func get_rect()->Rect2:
	match rect_mode:
		RectMode.Camera:
			if get_viewport() == null:
				return Rect2(0,0,0,0)
			return get_viewport().get_visible_rect()
		RectMode.Viewport:
			if get_viewport() == null:
				return Rect2(0,0,0,0)
			return Rect2(Vector2.ZERO, get_viewport().get_visible_rect().size)
	return rect
func set_rect(value:Rect2)->void:
	if  rect != value and rect_mode == RectMode.Manual:
		rect  = value

[Shadowblitz16]

#498
#495