0

Description

"## Introduction\r\n\r\nEvery game needs a fishing mini-game.\r\n\r\nJokes aside, here is a snippet to add a simple \"linear precision game\" sub-scene.\r\nThe sub-scene itself consists in a `Node2D` on which the script will be attached and two `Sprite2D` children. For better result, let the sprites centered. \r\n\r\n\r\nThe behavior is simple : A cursor will slide over an horizontal area at a certain speed. The area is itself composed of sub-areas of a certain value ranging from 0 to 1. When the user\/player use the _ui_select_ action, the script emits a signal with the value under the cursor current position.\r\n\r\nAt first, the scene is \"stopped\", meaning that there's no processing nor input processing.\r\n\r\n## Script\r\n\r\n### Signal\r\n\r\nThere's only one signal : `on_select(value : float)`.\r\nThis signal is triggered when the player use the _ui_select_ action and provide the value below the current cursor position.\r\n\r\n### Parameters\r\n\r\n* **cursor_texture** : Texture to be applied to the cursor\r\n* **area_size** : Size of the roaming area\r\n* **area_material** : Shader material used for area rendering (gradient of colors, mixing texture, you name it). The only restriction is to declare a uniform called `values` that will be the sampler2D mapping the value of the area (encoded on the red channel, from 0 to 1. UV of X axis matter).\r\n* **area_values** : A curve that determine the values over the roaming area. Domain and value should be comprised between 0 and 1 (default value of `Curve`)\r\n* **progression_type** : A kind of cursor progression, being one of the following value:\r\n\t* LOOP_POSITIVE : left to right, restarting on left\r\n\t* LOOP_NEGATIVE : right to left, restarting on right\r\n\t* PING_PONG : back and forth between the two extremities\r\n* **progression_speed** : How fast the cursor moves, in \"area traversal\" per seconds\r\n* **offset** : translation offset in local transform\r\n* **stop_at_select** : if set to _true_, then when the selection action occurs, the processing and input processing are stopped\r\n\r\n### Functions\r\n\r\nThe scene can be activated using the function **activate**. When invoked, it activates the `_process` and `_input` functions, and wrap up textures and shader material.\r\n\r\nOn the opposite, **deactivate** shuts down the scene by passivating the `_process` and `_input` functions.\r\n\r\nThe scene visibility is left to the discretion of the caller.\r\n\r\n## Sides\r\n\r\n\r\n### Examples of Canvas Shader\r\n\r\nTo decorate the bar\/area, you can use the kind of shader below. Note the `values` uniform that conveys the values along the bar.\r\n\r\n```glsl\r\nshader_type canvas_item;\r\n\r\nuniform sampler2D values;\r\n\r\nuniform sampler2D colors;\r\n\r\nvoid fragment() {\r\n\tCOLOR = texture(colors, vec2(texture(values, UV).r, 0.));\r\n}\r\n```\r\n\r\n`colors` is typically a `GradientTexture1D` with constant interpolation mode as shown below:\r\n\r\n\r\n### Debug Code\r\n\r\nTo quick test the scene, append the following code to the `_ready` function and launch the scene itself.\r\n\r\n```\r\n\tactivate()\r\n\ton_select.connect(func simple_debug(value : float) -> void :\r\n\t\tprint(\"Value is %s\" % (value))\r\n\t)\r\n```\r\n"

Screenshots

Main code

extends Node2D

## Triggered when the "select" action occurs. Provide the value at the cursor position
signal on_select(value : float)

## Progression type. Either looping or going back and forth.
enum ProgressionType {
	LOOP_POSITIVE,
	LOOP_NEGATIVE,
	PING_PONG
}

## Texture for the cursor
@export var cursor_texture : Texture

## Size of the area
@export var area_size : Vector2 :
	set(value) :
		area_size = value
		area_texture = ImageTexture.create_from_image(Image.create_empty(area_size.x, area_size.y, false, Image.FORMAT_RGBA8))

## Shader material used for area rendering.
## Should have a sampler2D uniform called "values" that will accept a 1D-ish texture
## mapping the values.
@export var area_material : ShaderMaterial

## Success values
@export var area_values : Curve :
	set(value) :
		area_values = value
		if value != null:
			curve_texture = CurveTexture.new()
			var texture_size : int = int(ceil((area_values.bake_resolution * 4) / 512.) * 512)
			curve_texture.width = texture_size
			curve_texture.curve = area_values
			curve_texture.texture_mode = CurveTexture.TEXTURE_MODE_RED
			if area_material != null:
				area_material.set_shader_parameter("values", curve_texture)

## Type of progression
@export var progression_type : ProgressionType = ProgressionType.PING_PONG :
	set(value) :
		progression_type = value
		_compute_phase()

## Progression speed in "area per second" (1 means "one area sprite length per seconds")
@export var progression_speed : float

## Sprite offsetting (for debug purpose ...)
@export var offset : Vector2

## Shall we stop after a select ?
@export var stop_at_select : bool = false

# Cursor sprite
@onready var cursor_sprite : Sprite2D = $Cursor as Sprite2D

# Area sprite
@onready var area_sprite : Sprite2D = $Area as Sprite2D

# Progression phase (1. left to right, -1. right to left)
@onready var phase : float = 1.

var progression : float

var curve_texture : CurveTexture

var area_texture : Texture

func _ready() -> void:
	deactivate()

func activate() -> void:
	assert(cursor_texture != null and area_material != null and area_values != null )
	progression = 0.
	cursor_sprite.texture = cursor_texture
	area_sprite.texture = area_texture
	area_sprite.position = offset
	area_sprite.material = area_material
	area_material.set_shader_parameter("values", curve_texture)
	area_sprite.material = area_material
	phase = -1. if progression_type == ProgressionType.LOOP_NEGATIVE else 1.
	set_process(true)
	set_process_input(true)

func deactivate() -> void:
	set_process(false)
	set_process_input(false)

func _process(delta : float) -> void:
	progression += delta * progression_speed
	if progression > 1.:
		progression -= 1.
		_compute_phase()
	cursor_sprite.position.x = area_sprite.position.x + phase * ((progression - 0.5) * area_size.x * area_sprite.scale.x)
	cursor_sprite.position.y = area_sprite.position.y # in case of area movement ...

func _input(event : InputEvent) -> void:
	if event.is_action("ui_accept") and event.is_pressed() and (not event.is_echo()):
		var p : float = progression if phase > 0. else 1. - progression
		on_select.emit(area_values.sample_baked(p))
		if stop_at_select:
			set_process(false)
			set_process_input(false)

func _compute_phase() -> void:
	match progression_type:
		ProgressionType.PING_PONG:
			phase *= -1.
		ProgressionType.LOOP_POSITIVE:
			phase = 1.
		ProgressionType.LOOP_NEGATIVE:
			phase = -1.

Comments