Basic input handling and judgement text

Bezel.gd

@@ -4,12 +4,12 @@ extends "res://main.gd"
 var center := Vector2(0.0, 0.0)
 
 func _draw():
-	var bezel_colors := PoolColorArray([theme.bezel_color])
+	var bezel_colors := PoolColorArray([GameTheme.bezel_color])
 	var bezel_points: PoolVector2Array
 	var screen_height2 := screen_height/2.0
 
-	draw_rect(Rect2(-screen_height2, -screen_height2, -x_margin, screen_height), theme.bezel_color)
+	draw_rect(Rect2(-screen_height2, -screen_height2, -x_margin, screen_height), GameTheme.bezel_color)
-	draw_rect(Rect2(screen_height2, -screen_height2, x_margin, screen_height), theme.bezel_color)
+	draw_rect(Rect2(screen_height2, -screen_height2, x_margin, screen_height), GameTheme.bezel_color)
 
 	bezel_points = arc_point_list(center, screen_height2, 0, -90)
 	bezel_points.push_back(Vector2(screen_height2, -screen_height2))

GameTheme.gd

@@ -1,6 +1,6 @@
 extends Node
 
-var receptor_ring_radius := 460
+var receptor_ring_radius := 460.0
 var note_forecast_beats := 2.0  # Notes start to appear this many beats before you need to tap them
 const INNER_NOTE_CIRCLE_RATIO := 0.3  # Notes under this far from the center will zoom into existence
 const SLIDE_DELAY := 0.5  # Time in beats between the tap of the star and the start of the visual slide
@@ -8,6 +8,14 @@ const SLIDE_DELAY := 0.5  # Time in beats between the tap of the star and the st
 var sprite_size := 128
 var sprite_size2 := sprite_size/2
 
+var judge_text_size := 256
+# Text is rendered from center.
+const JUDGE_TEXT_ANG2 := atan(1.0/4.0)
+const JUDGE_TEXT_ANG1 := PI - JUDGE_TEXT_ANG2
+const JUDGE_TEXT_ANG3 := PI + JUDGE_TEXT_ANG2
+const JUDGE_TEXT_ANG4 := -JUDGE_TEXT_ANG2
+var judge_text_size2 := 0.5*judge_text_size/cos(JUDGE_TEXT_ANG2)
+
 # Color definitions
 const COLOR_TAP := Color(1, 0.15, 0.15, 1)
 const COLOR_TAP2 := Color(0.75, 0.5, 0, 1)  # High-score taps ("breaks" in maimai)
@@ -15,6 +23,7 @@ const COLOR_HOLD := Color(1, 0.15, 0.15, 1)
 const COLOR_HOLD_HELD := Color(1, 1, 1, 1)
 const COLOR_STAR := Color(0, 0, 1, 1)
 const COLOR_DOUBLE := Color(1, 1, 0, 1)  # When two (or more in master) hit events coincide
+const COLOR_TEXT := Color(1, 1, 1, 1)
 
 var COLOR_ARRAY_TAP := PoolColorArray([COLOR_TAP, COLOR_TAP, COLOR_TAP, COLOR_TAP])
 var COLOR_ARRAY_TAP2 := PoolColorArray([COLOR_TAP2, COLOR_TAP2, COLOR_TAP2, COLOR_TAP2])
@@ -45,3 +54,8 @@ func init_radial_values():
 		var angle = deg2rad(fmod(Rules.FIRST_COLUMN_ANGLE_DEG + (i * Rules.COLS_ANGLE_DEG), 360.0))
 		RADIAL_COL_ANGLES.push_back(angle)
 		RADIAL_UNIT_VECTORS.push_back(Vector2(cos(angle), sin(angle)))
+
+
+func color_array_text(alpha: float) -> PoolColorArray:
+	var color := Color(COLOR_TEXT.r, COLOR_TEXT.g, COLOR_TEXT.b, alpha)
+	return PoolColorArray([color, color, color, color])

InputHandler.gd

@@ -6,14 +6,32 @@ var fingers = 0 setget set_fingers					# setter for show fingers number on scree
 var txt_ball = preload("res://assets/ball.png")		# preload our ball texture
 var default_font = preload("res://assets/NotoSans.tres")	# point to godot standard font
 
-
+var buttons_pressed := PoolByteArray()
+var touchbuttons_pressed := PoolByteArray()
+signal button_pressed(index)  # Add int type to these once Godot supports typed signals
+signal button_released(index)
+signal touchbutton_pressed(index)
+signal touchbutton_released(index)
+const TOUCHBUTTON_MIN_DIST := 0.8
+const TOUCHBUTTON_MAX_DIST := 1.05
+const BUTTON_MIN_DIST := TOUCHBUTTON_MAX_DIST
+const BUTTON_MAX_DIST := 1.25
 
 func _init():
-	pass
+	buttons_pressed.resize(Rules.COLS)
+	touchbuttons_pressed.resize(Rules.COLS)
+	for i in Rules.COLS:
+		buttons_pressed[i] = 0
+		touchbuttons_pressed[i] = 0
 
 func _ready():
 	set_process_unhandled_input(true)				# process user input
 	set_fingers(0)
+	connect("button_pressed", self, "print_pressed")
+
+
+func print_pressed(col: int):
+	print("Pressed %d"%col)
 
 
 ##########################################################################
@@ -26,6 +44,7 @@ func _draw():
 		# DRAW POINTS ################################################
 		draw_texture(txt_ball, point.position - Vector2(24, 24))
 		draw_string(default_font, point.position - Vector2(24, 24), str(i))
+		draw_string(default_font, point.position + Vector2(-24, 48), str(point.position))
 #	if len(touch_positions) > 1:
 #		for i in range(len(touch_positions)-1):
 #			# Draw line
@@ -35,6 +54,35 @@ func update_data():
 	touch_positions.clear()
 	for i in touch_points:
 		touch_positions.push_back(touch_points[i].position)
+
+
+	var buttons_pressed_temp := []
+	var touchbuttons_pressed_temp := []
+	for i in Rules.COLS:
+		buttons_pressed_temp.append(false)
+		touchbuttons_pressed_temp.append(false)
+
+	for pos in touch_positions:
+		pos -= Vector2(960, 540)  # Change this if we move the node
+		var pol = cartesian2polar(pos.x, pos.y)
+		var dist = pol.x/GameTheme.receptor_ring_radius
+		var angle = rad2deg(pol.y)
+		if dist < TOUCHBUTTON_MIN_DIST:
+			continue
+		# bin the angle
+		angle -= Rules.FIRST_COLUMN_ANGLE_DEG - Rules.COLS_TOUCH_ARC_DEG/2.0
+		if fmod(angle, Rules.COLS_ANGLE_DEG) > Rules.COLS_TOUCH_ARC_DEG:
+			continue
+		var col := int(floor(angle/Rules.COLS_ANGLE_DEG))
+		if dist < TOUCHBUTTON_MAX_DIST:
+			touchbuttons_pressed_temp[col] = true
+		elif dist < BUTTON_MAX_DIST:
+			buttons_pressed_temp[col] = true
+
+	for i in Rules.COLS:
+		set_button_state(i, buttons_pressed_temp[i])
+		set_touchbutton_state(i, touchbuttons_pressed_temp[i])
+
 	set_fingers(len(touch_positions))
 	update()
 
@@ -58,8 +106,23 @@ func _input(event):
 ##########################################################################
 # write how many fingers are tapping the screen
 func set_fingers(value):
-	fingers = value
+	fingers = max(value, 0)
-	if fingers > 0:
+	set_text("Fingers: %d" % fingers)
-		set_text("Fingers: " + str(fingers))
+
-	else:
+func set_button_state(index: int, state: bool):
-		set_text("Fingers: 0")
+	var new_state = int(state)
+	match new_state - buttons_pressed[index]:
+		1:
+			emit_signal("button_pressed", index)
+		-1:
+			emit_signal("button_released", index)
+	buttons_pressed[index] = new_state
+
+func set_touchbutton_state(index: int, state: bool):
+	var new_state = int(state)
+	match new_state - touchbuttons_pressed[index]:
+		1:
+			emit_signal("touchbutton_pressed", index)
+		-1:
+			emit_signal("touchbutton_released", index)
+	touchbuttons_pressed[index] = new_state

Note.gd

@@ -36,17 +36,17 @@ class NoteSlide extends NoteBase:
 	func update_slide_variables():
 		match slide_type:
 			Note.SlideType.CHORD:
-				values.start = theme.RADIAL_UNIT_VECTORS[column] * theme.receptor_ring_radius
+				values.start = GameTheme.RADIAL_UNIT_VECTORS[column] * GameTheme.receptor_ring_radius
-				values.end = theme.RADIAL_UNIT_VECTORS[column_release] * theme.receptor_ring_radius
+				values.end = GameTheme.RADIAL_UNIT_VECTORS[column_release] * GameTheme.receptor_ring_radius
 				values.angle = (values.end - values.start).angle()
 			Note.SlideType.ARC_CW:
-				values.start_a = theme.RADIAL_COL_ANGLES[column]
+				values.start_a = GameTheme.RADIAL_COL_ANGLES[column]
-				values.end_a = theme.RADIAL_COL_ANGLES[column_release]
+				values.end_a = GameTheme.RADIAL_COL_ANGLES[column_release]
 				if values.end_a < values.start_a:
 					values.end_a += TAU
 			Note.SlideType.ARC_ACW:
-				values.start_a = theme.RADIAL_COL_ANGLES[column]
+				values.start_a = GameTheme.RADIAL_COL_ANGLES[column]
-				values.end_a = theme.RADIAL_COL_ANGLES[column_release]
+				values.end_a = GameTheme.RADIAL_COL_ANGLES[column_release]
 				if values.end_a > values.start_a:
 					values.end_a -= TAU
 
@@ -56,10 +56,10 @@ class NoteSlide extends NoteBase:
 				return lerp(values.start, values.end, progress)
 			Note.SlideType.ARC_CW:
 				var circle_angle : float = lerp(values.start_a, values.end_a, progress)
-				return polar2cartesian(theme.receptor_ring_radius, circle_angle)
+				return polar2cartesian(GameTheme.receptor_ring_radius, circle_angle)
 			Note.SlideType.ARC_ACW:
 				var circle_angle : float = lerp(values.start_a, values.end_a, progress)
-				return polar2cartesian(theme.receptor_ring_radius, circle_angle)
+				return polar2cartesian(GameTheme.receptor_ring_radius, circle_angle)
 
 	func get_angle(progress: float) -> float:
 		match slide_type:
@@ -76,11 +76,11 @@ class NoteSlide extends NoteBase:
 		# Return unit-circle (r=1) length of slide trail
 		match slide_type:
 			Note.SlideType.CHORD:
-				return 2*abs(sin((theme.RADIAL_COL_ANGLES[column_release] - theme.RADIAL_COL_ANGLES[column])/2))
+				return 2*abs(sin((GameTheme.RADIAL_COL_ANGLES[column_release] - GameTheme.RADIAL_COL_ANGLES[column])/2))
 			Note.SlideType.ARC_CW:
-				return fposmod(theme.RADIAL_COL_ANGLES[column_release] - theme.RADIAL_COL_ANGLES[column], TAU)
+				return fposmod(GameTheme.RADIAL_COL_ANGLES[column_release] - GameTheme.RADIAL_COL_ANGLES[column], TAU)
 			Note.SlideType.ARC_ACW:
-				return fposmod(theme.RADIAL_COL_ANGLES[column] - theme.RADIAL_COL_ANGLES[column_release], TAU)
+				return fposmod(GameTheme.RADIAL_COL_ANGLES[column] - GameTheme.RADIAL_COL_ANGLES[column_release], TAU)
 
 
 

NoteHandler.gd

@@ -2,19 +2,20 @@ extends "res://main.gd"
 
 # This script will draw all note events.
 
-var tex := preload("res://assets/spritesheet-1024.png")
+var tex := preload("res://assets/spritesheet-4k.png")
-var tex_slide_arrow := preload("res://assets/slide-arrow-512.png")
+var tex_judgement_text := preload("res://assets/text-4k.png")
+var tex_slide_arrow := preload("res://assets/slide-arrow-4k.png")
 var slide_trail_shadermaterial := preload("res://shaders/slidetrail.tres")
 
 ## Constants for the overall notefield
-#var theme.RADIAL_COL_ANGLES := PoolRealArray()  # ideally const
+#var GameTheme.RADIAL_COL_ANGLES := PoolRealArray()  # ideally const
-#var theme.RADIAL_UNIT_VECTORS := PoolVector2Array()  # ideally const
+#var GameTheme.RADIAL_UNIT_VECTORS := PoolVector2Array()  # ideally const
 #
 #func init_radial_values():
 #	for i in range(Rules.COLS):
 #		var angle = deg2rad(fmod(Rules.FIRST_COLUMN_ANGLE_DEG + (i * Rules.COLS_ANGLE_DEG), 360.0))
-#		theme.RADIAL_COL_ANGLES.push_back(angle)
+#		GameTheme.RADIAL_COL_ANGLES.push_back(angle)
-#		theme.RADIAL_UNIT_VECTORS.push_back(Vector2(cos(angle), sin(angle)))
+#		GameTheme.RADIAL_UNIT_VECTORS.push_back(Vector2(cos(angle), sin(angle)))
 
 const SQRT2 := sqrt(2)
 const DEG45 := deg2rad(45.0)
@@ -54,10 +55,42 @@ var NORMAL_ARRAY_8 := PoolVector3Array([
 	DEFAULT_NORMAL, DEFAULT_NORMAL, DEFAULT_NORMAL, DEFAULT_NORMAL
 	])
 
+# Text UVs
+var text_UV_arrays := []
+func make_text_UV(row: int, column: int) -> PoolVector2Array:
+	return PoolVector2Array([Vector2(column/4.0, row/8.0), Vector2((column+1)/4.0, row/8.0), Vector2(column/4.0, (row+1)/8.0), Vector2((column+1)/4.0, (row+1)/8.0)])
+func make_text_UVs():
+	for row in 8:
+		for column in 4:
+			text_UV_arrays.append(make_text_UV(row, column))
+enum TextStyle {STRAIGHT=0, ARC=1, ARC_EARLY=2, ARC_LATE=3}
+enum TextWord {NICE=0, OK=4, NG=8, PERFECT=12, GREAT=16, GOOD=20, ALMOST=24, MISS=28}
+
+func make_text_mesh(mesh: ArrayMesh, text_id: int, pos: Vector2, angle: float, alpha:=1.0, scale:=1.0):
+	var r := GameTheme.judge_text_size2 * scale
+	var vertex_array := PoolVector2Array([
+		pos+polar2cartesian(r, angle+GameTheme.JUDGE_TEXT_ANG2), # TODO: fix this UV/vertex order mess
+		pos+polar2cartesian(r, angle+GameTheme.JUDGE_TEXT_ANG1),
+		pos+polar2cartesian(r, angle+GameTheme.JUDGE_TEXT_ANG4),
+		pos+polar2cartesian(r, angle+GameTheme.JUDGE_TEXT_ANG3)
+	])
+	var arrays = []
+	arrays.resize(Mesh.ARRAY_MAX)
+	arrays[Mesh.ARRAY_VERTEX] = vertex_array
+	arrays[Mesh.ARRAY_TEX_UV] = text_UV_arrays[text_id]
+	arrays[Mesh.ARRAY_COLOR] = GameTheme.color_array_text(alpha)
+	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLE_STRIP, arrays)
+
+func make_judgement_text(mesh: ArrayMesh, text_id: int, col: int, progress:=0.0):
+	make_text_mesh(mesh, text_id,
+		GameTheme.RADIAL_UNIT_VECTORS[col] * GameTheme.receptor_ring_radius * lerp(0.85, 0.8, progress),
+		GameTheme.RADIAL_COL_ANGLES[col]-PI/2.0, lerp(1.0, 0.0, progress), lerp(1.0, 0.5, progress)
+	)
+
 # ----------------------------------------------------------------------------------------------------------------------------------------------------
 # Helper functions to generate meshes from vertex arrays
-func make_tap_mesh(mesh: ArrayMesh, note_center: Vector2, scale:=1.0, color_array:=theme.COLOR_ARRAY_TAP):
+func make_tap_mesh(mesh: ArrayMesh, note_center: Vector2, scale:=1.0, color_array:=GameTheme.COLOR_ARRAY_TAP):
-	var dim = theme.sprite_size2 * scale
+	var dim = GameTheme.sprite_size2 * scale
 	var vertex_array = PoolVector2Array([note_center + Vector2(-dim, -dim), note_center + Vector2(dim, -dim), note_center + Vector2(-dim, dim), note_center + Vector2(dim, dim)])
 	var arrays = []
 	arrays.resize(Mesh.ARRAY_MAX)
@@ -67,8 +100,8 @@ func make_tap_mesh(mesh: ArrayMesh, note_center: Vector2, scale:=1.0, color_arra
 	arrays[Mesh.ARRAY_COLOR] = color_array
 	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLE_STRIP, arrays)
 
-func make_hold_mesh(mesh: ArrayMesh, note_center: Vector2, note_center_rel: Vector2, scale:=1.0, angle:=0.0, color_array = theme.COLOR_ARRAY_HOLD):
+func make_hold_mesh(mesh: ArrayMesh, note_center: Vector2, note_center_rel: Vector2, scale:=1.0, angle:=0.0, color_array = GameTheme.COLOR_ARRAY_HOLD):
-	var dim = theme.sprite_size2 * scale
+	var dim = GameTheme.sprite_size2 * scale
 	var dim2 = dim * SQRT2
 	var a1 = angle - DEG45
 	var a2 = angle + DEG45
@@ -90,8 +123,8 @@ func make_hold_mesh(mesh: ArrayMesh, note_center: Vector2, note_center_rel: Vect
 	arrays[Mesh.ARRAY_COLOR] = color_array
 	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLE_STRIP, arrays)
 
-func make_star_mesh(mesh: ArrayMesh, note_center: Vector2, scale:=1.0, angle:=0.0, color_array:=theme.COLOR_ARRAY_STAR):
+func make_star_mesh(mesh: ArrayMesh, note_center: Vector2, scale:=1.0, angle:=0.0, color_array:=GameTheme.COLOR_ARRAY_STAR):
-	var dim = theme.sprite_size2 * scale * SQRT2
+	var dim = GameTheme.sprite_size2 * scale * SQRT2
 	var a1 = angle - DEG45
 	var a2 = angle + DEG45
 	var a3 = angle - DEG135
@@ -108,7 +141,7 @@ func make_star_mesh(mesh: ArrayMesh, note_center: Vector2, scale:=1.0, angle:=0.
 	arrays[Mesh.ARRAY_COLOR] = color_array
 	mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLE_STRIP, arrays)
 
-#func make_arrow_mesh(mesh: ArrayMesh, vertex_array, color_array = theme.COLOR_ARRAY_TAP):
+#func make_arrow_mesh(mesh: ArrayMesh, vertex_array, color_array = GameTheme.COLOR_ARRAY_TAP):
 #	var arrays = []
 #	arrays.resize(Mesh.ARRAY_MAX)
 #	arrays[Mesh.ARRAY_VERTEX] = vertex_array
@@ -127,7 +160,7 @@ func make_slide_trail_mesh(note) -> ArrayMesh:
 	var vertices := PoolVector2Array()
 	var uvs := PoolVector2Array()
 	var colors := PoolColorArray()
-	var size := theme.sprite_size2
+	var size := GameTheme.sprite_size2
 	var color := Color(0.67, 0.67, 1.0)
 	if note.double_hit:
 		color = Color(1.0, 1.0, 0.35)
@@ -180,7 +213,8 @@ func make_slide_trail_mesh(note) -> ArrayMesh:
 
 func _init():
 	Input.set_mouse_mode(Input.MOUSE_MODE_HIDDEN)
-	theme.init_radial_values()
+	GameTheme.init_radial_values()
+	make_text_UVs()
 
 func _draw():
 	var mesh := ArrayMesh.new()
@@ -190,40 +224,40 @@ func _draw():
 	var j := 0
 
 	for note in active_notes:
-		var position : float = (t+theme.note_forecast_beats-note.time_hit)/theme.note_forecast_beats
+		var position : float = (t+GameTheme.note_forecast_beats-note.time_hit)/GameTheme.note_forecast_beats
 		var scale := 1.0
-		noteline_data.set_pixel(i%16, i/16, Color(position, note.column, theme.RADIAL_COL_ANGLES[note.column]))
+		noteline_data.set_pixel(i%16, i/16, Color(position, note.column, GameTheme.RADIAL_COL_ANGLES[note.column]))
 		i += 1
-		if position < theme.INNER_NOTE_CIRCLE_RATIO:
+		if position < GameTheme.INNER_NOTE_CIRCLE_RATIO:
-			scale *= position/theme.INNER_NOTE_CIRCLE_RATIO
+			scale *= position/GameTheme.INNER_NOTE_CIRCLE_RATIO
-			position = theme.INNER_NOTE_CIRCLE_RATIO
+			position = GameTheme.INNER_NOTE_CIRCLE_RATIO
-		var note_center = (theme.RADIAL_UNIT_VECTORS[note.column] * position * theme.receptor_ring_radius)
+		var note_center = (GameTheme.RADIAL_UNIT_VECTORS[note.column] * position * GameTheme.receptor_ring_radius)
 		match note.type:
 			Note.NOTE_TAP:
-				var color = theme.COLOR_ARRAY_DOUBLE_4 if note.double_hit else theme.COLOR_ARRAY_TAP
+				var color = GameTheme.COLOR_ARRAY_DOUBLE_4 if note.double_hit else GameTheme.COLOR_ARRAY_TAP
 				make_tap_mesh(mesh, note_center, scale, color)
 			Note.NOTE_HOLD:
-				var color = theme.COLOR_ARRAY_DOUBLE_8 if note.double_hit else theme.COLOR_ARRAY_HOLD
+				var color = GameTheme.COLOR_ARRAY_DOUBLE_8 if note.double_hit else GameTheme.COLOR_ARRAY_HOLD
-				var position_rel : float = (t+theme.note_forecast_beats-note.time_release)/theme.note_forecast_beats
+				var position_rel : float = (t+GameTheme.note_forecast_beats-note.time_release)/GameTheme.note_forecast_beats
 				if position_rel > 0:
-					var note_rel_center := (theme.RADIAL_UNIT_VECTORS[note.column] * position_rel * theme.receptor_ring_radius)
+					var note_rel_center := (GameTheme.RADIAL_UNIT_VECTORS[note.column] * position_rel * GameTheme.receptor_ring_radius)
-					noteline_data.set_pixel(j%16, 15, Color(position_rel, note.column, theme.RADIAL_COL_ANGLES[note.column]))
+					noteline_data.set_pixel(j%16, 15, Color(position_rel, note.column, GameTheme.RADIAL_COL_ANGLES[note.column]))
 					j += 1
-				if position_rel < theme.INNER_NOTE_CIRCLE_RATIO:
+				if position_rel < GameTheme.INNER_NOTE_CIRCLE_RATIO:
-					position_rel = theme.INNER_NOTE_CIRCLE_RATIO
+					position_rel = GameTheme.INNER_NOTE_CIRCLE_RATIO
-				var note_center_rel = (theme.RADIAL_UNIT_VECTORS[note.column] * position_rel * theme.receptor_ring_radius)
+				var note_center_rel = (GameTheme.RADIAL_UNIT_VECTORS[note.column] * position_rel * GameTheme.receptor_ring_radius)
-				make_hold_mesh(mesh, note_center, note_center_rel, scale, theme.RADIAL_COL_ANGLES[note.column], color)
+				make_hold_mesh(mesh, note_center, note_center_rel, scale, GameTheme.RADIAL_COL_ANGLES[note.column], color)
 			Note.NOTE_SLIDE:
-				var color = theme.COLOR_ARRAY_DOUBLE_4 if note.double_hit else theme.COLOR_ARRAY_STAR
+				var color = GameTheme.COLOR_ARRAY_DOUBLE_4 if note.double_hit else GameTheme.COLOR_ARRAY_STAR
 				var angle = fmod(t/note.duration, 1.0)*TAU
 				make_star_mesh(mesh, note_center, scale, angle, color)
 				var trail_alpha := 1.0
-				if position < theme.INNER_NOTE_CIRCLE_RATIO:
+				if position < GameTheme.INNER_NOTE_CIRCLE_RATIO:
 					trail_alpha = 0.0
 				elif position < 1.0:
-					trail_alpha = min(1.0, (position-theme.INNER_NOTE_CIRCLE_RATIO)/(1-theme.INNER_NOTE_CIRCLE_RATIO*2))
+					trail_alpha = min(1.0, (position-GameTheme.INNER_NOTE_CIRCLE_RATIO)/(1-GameTheme.INNER_NOTE_CIRCLE_RATIO*2))
 				else:
-					var trail_progress : float = clamp((t - note.time_hit - theme.SLIDE_DELAY)/(note.duration - theme.SLIDE_DELAY), 0.0, 1.0)
+					var trail_progress : float = clamp((t - note.time_hit - GameTheme.SLIDE_DELAY)/(note.duration - GameTheme.SLIDE_DELAY), 0.0, 1.0)
 					var star_pos : Vector2 = note.get_position(trail_progress)
 					var star_angle : float = note.get_angle(trail_progress)
 					make_star_mesh(mesh, star_pos, 1.33, star_angle, color)
@@ -238,6 +272,18 @@ func _draw():
 	$notelines.set_texture(noteline_data_tex)
 
 	$meshinstance.set_mesh(mesh)
+
+	var textmesh := ArrayMesh.new()
+	make_judgement_text(textmesh, TextWord.PERFECT+TextStyle.ARC, 0, 0.0)
+	make_judgement_text(textmesh, TextWord.GREAT+TextStyle.ARC_LATE, 1, 0.0)
+	make_judgement_text(textmesh, TextWord.GOOD+TextStyle.ARC_EARLY, 2, 0.1)
+	make_judgement_text(textmesh, TextWord.ALMOST+TextStyle.ARC_LATE, 3, 0.2)
+	make_judgement_text(textmesh, TextWord.MISS+TextStyle.ARC, 4, 0.4)
+	make_judgement_text(textmesh, TextWord.NICE+TextStyle.ARC, 5, 0.6)
+	make_judgement_text(textmesh, TextWord.OK+TextStyle.ARC, 6, 0.8)
+	make_judgement_text(textmesh, TextWord.NG+TextStyle.ARC, 7, 0.9)
+	$JudgeText.set_mesh(textmesh)
+
 #	draw_mesh(mesh, tex)
 
 var noteline_array_image := Image.new()
@@ -251,13 +297,13 @@ func _ready():
 	all_notes = []
 	next_note_to_load = 0
 
-	$meshinstance.material.set_shader_param("star_color", theme.COLOR_STAR)
+	$meshinstance.material.set_shader_param("star_color", GameTheme.COLOR_STAR)
-	$meshinstance.material.set_shader_param("held_color", theme.COLOR_HOLD_HELD)
+	$meshinstance.material.set_shader_param("held_color", GameTheme.COLOR_HOLD_HELD)
 	$meshinstance.material.set_shader_param("bps", bpm/60.0)
 	$meshinstance.material.set_shader_param("screen_size", get_viewport().get_size())
 	$meshinstance.set_texture(tex)
 
-	var rec_scale1 = (float(screen_height)/float(theme.receptor_ring_radius))*0.5
+	var rec_scale1 = (float(screen_height)/float(GameTheme.receptor_ring_radius))*0.5
 	var uv_array_playfield := PoolVector2Array([Vector2(-1.0, -1.0)*rec_scale1, Vector2(-1.0, 1.0)*rec_scale1, Vector2(1.0, -1.0)*rec_scale1, Vector2(1.0, 1.0)*rec_scale1])
 #	var vertex_array_playfield := PoolVector2Array([
 #		Vector2(x_margin, screen_height), Vector2(x_margin, 0.0),
@@ -332,7 +378,7 @@ func _process(delta):
 		if next_note_to_load >= len(all_notes):
 			# All notes have been loaded, maybe do something
 			break
-		if all_notes[next_note_to_load].time_hit > (t + theme.note_forecast_beats):
+		if all_notes[next_note_to_load].time_hit > (t + GameTheme.note_forecast_beats):
 			# Next chronological note isn't ready to load yet
 			break
 		# Next chronological note is ready to load, load it

Receptors.gd

@@ -8,11 +8,11 @@ var center := Vector2(0.0, 0.0)
 
 func _draw():
 	# Screen filter
-	draw_rect(Rect2(-screen_height/2, -screen_height/2, screen_height, screen_height), theme.screen_filter)
+	draw_rect(Rect2(-screen_height/2, -screen_height/2, screen_height, screen_height), GameTheme.screen_filter)
 
 	# Receptor ring
-	var receptor_circle := arc_point_list(center, theme.receptor_ring_radius, 0.0, 360.0, 360)
+	var receptor_circle := arc_point_list(center, GameTheme.receptor_ring_radius, 0.0, 360.0, 360)
-	var receptor_centers := arc_point_list(center, theme.receptor_ring_radius, Rules.FIRST_COLUMN_ANGLE_DEG, Rules.FIRST_COLUMN_ANGLE_DEG+360.0-Rules.COLS_ANGLE_DEG, Rules.COLS)
+	var receptor_centers := arc_point_list(center, GameTheme.receptor_ring_radius, Rules.FIRST_COLUMN_ANGLE_DEG, Rules.FIRST_COLUMN_ANGLE_DEG+360.0-Rules.COLS_ANGLE_DEG, Rules.COLS)
 
 	# Shadows
 	for i in range(len(receptor_circle)-1):
@@ -22,7 +22,7 @@ func _draw():
 
 	# Foregrounds
 	for i in range(len(receptor_circle)-1):
-		draw_line(receptor_circle[i], receptor_circle[i+1], theme.receptor_color, ring_px, true)
+		draw_line(receptor_circle[i], receptor_circle[i+1], GameTheme.receptor_color, ring_px, true)
 	for i in range(len(receptor_centers)):
-		draw_circle(receptor_centers[i], receptor_px/2, theme.receptor_color)
+		draw_circle(receptor_centers[i], receptor_px/2, GameTheme.receptor_color)
 

main.tscn

@@ -1,18 +1,19 @@
-[gd_scene load_steps=13 format=2]
+[gd_scene load_steps=14 format=2]
 
 [ext_resource path="res://main.gd" type="Script" id=1]
 [ext_resource path="res://songs/cirno_1080p_rt_cpu1_3M.webm" type="VideoStream" id=2]
 [ext_resource path="res://video.gd" type="Script" id=3]
 [ext_resource path="res://Receptors.gd" type="Script" id=4]
 [ext_resource path="res://NoteHandler.gd" type="Script" id=5]
-[ext_resource path="res://shaders/notelines.shader" type="Shader" id=6]
+[ext_resource path="res://assets/text-4k.png" type="Texture" id=6]
-[ext_resource path="res://shaders/notemesh.shader" type="Shader" id=7]
+[ext_resource path="res://shaders/notelines.shader" type="Shader" id=7]
-[ext_resource path="res://Bezel.gd" type="Script" id=8]
+[ext_resource path="res://shaders/notemesh.shader" type="Shader" id=8]
-[ext_resource path="res://assets/NotoSans.tres" type="DynamicFont" id=9]
+[ext_resource path="res://Bezel.gd" type="Script" id=9]
-[ext_resource path="res://InputHandler.gd" type="Script" id=10]
+[ext_resource path="res://assets/NotoSans.tres" type="DynamicFont" id=10]
+[ext_resource path="res://InputHandler.gd" type="Script" id=11]
 
 [sub_resource type="ShaderMaterial" id=1]
-shader = ExtResource( 6 )
+shader = ExtResource( 7 )
 shader_param/line_color = Plane( 0.8, 0.8, 1, 0.8 )
 shader_param/line_color_double = Plane( 1, 1, 0.6, 0.9 )
 shader_param/dot_color = Plane( 1, 1, 1, 0.8 )
@@ -24,7 +25,7 @@ shader_param/dot_fullbright_thickness = 0.013
 shader_param/max_angle = 1.0708
 
 [sub_resource type="ShaderMaterial" id=2]
-shader = ExtResource( 7 )
+shader = ExtResource( 8 )
 shader_param/bps = null
 shader_param/star_color = null
 shader_param/held_color = null
@@ -34,7 +35,8 @@ shader_param/screen_size = null
 position = Vector2( 960, 540 )
 script = ExtResource( 1 )
 __meta__ = {
-"_edit_vertical_guides_": [ 1450.0 ]
+"_edit_horizontal_guides_": [  ],
+"_edit_vertical_guides_": [ 420.85, 1500.91 ]
 }
 
 [node name="video" type="VideoPlayer" parent="."]
@@ -61,6 +63,9 @@ script = ExtResource( 5 )
 
 [node name="SlideTrailHandler" type="Node2D" parent="NoteHandler"]
 
+[node name="JudgeText" type="MeshInstance2D" parent="NoteHandler"]
+texture = ExtResource( 6 )
+
 [node name="notelines" type="MeshInstance2D" parent="NoteHandler"]
 material = SubResource( 1 )
 
@@ -68,13 +73,13 @@ material = SubResource( 1 )
 material = SubResource( 2 )
 
 [node name="Bezel" type="Node2D" parent="."]
-script = ExtResource( 8 )
+script = ExtResource( 9 )
 
 [node name="InputHandler" type="Label" parent="."]
 margin_left = -960.0
 margin_top = -540.0
 margin_right = 960.0
 margin_bottom = 540.0
-custom_fonts/font = ExtResource( 9 )
+custom_fonts/font = ExtResource( 10 )
 text = "Fingers on the screen:"
-script = ExtResource( 10 )
+script = ExtResource( 11 )

project.godot

@@ -30,7 +30,7 @@ channel_disable_time=5.0
 Note="*res://Note.gd"
 FileLoader="*res://FileLoader.gd"
 Rules="*res://Rules.gd"
-theme="*res://theme.gd"
+GameTheme="*res://GameTheme.gd"
 
 [debug]