Merge branch 'main' of github.com:db0/godot-card-game-framework into main

Author: db0

CHANGELOG.md

@@ -1,11 +1,19 @@
 # Changelog
 
-## 1.15 (Ongoing)
+## 1.15
+
+### Important for Upgrades
+
+* New property `CFConst.FONT_SIZE_CACHE` has to exist. Best practice is to set it to "user://CGFFontCache.json"
 
 ### New Features
 
+* Now each card type has exported variables for the canonical card size as well as the various scaling. **This finally allows the game to utilize different card sizes at the same time**. CardContainers and BoardGrid for different card sizes now also need to have a defined card_size of the card they're going to host.
 * Added exported vars for controlling card tween duration (@stevosaurus)
 * Mouse will not teleport to a card's top-right when dragging starts. (@stevosaurus)
+* Adjustments to prevent Rich Text Labels from sizing at 4 font size
+* Recursive rescaling will also now take into account MarginContainer margins
+* Added font_size_caching which should now reduce time lost while calculating font sizes.
 
 #### ScriptingEngine
 

src/core/BoardPlacementGrid.gd

@@ -6,7 +6,7 @@
 #
 # Adjust its highlight colour and the amount of columns it should have as well
 #
-# The BoardPlacementSlots will adjust to CFConst.CARD_SIZE on runtime, but
+# The BoardPlacementSlots will adjust to card_size on runtime, but
 # If you want to visually see on the editor your result
 class_name BoardPlacementGrid
 extends Control
@@ -22,11 +22,16 @@ export(Color) var highlight = CFConst.TARGET_HOVER_COLOUR
 # when find_available_slot() is used and there's no more available slots
 # (only useful when using the ScriptingEngine)
 export var auto_extend := false
+# Used to adjust the grid according to the card size that will be put into it.
+# This size should match the
+export var card_size := CFConst.CARD_SIZE
+export var card_play_scale := CFConst.PLAY_AREA_SCALE
 
 # Sets a custom label for this grid
 onready var name_label = $Control/Label
 
 func _ready() -> void:
+	rect_size = (card_size * card_play_scale) + Vector2(4,4)
 	# We ensure the separation of the grid slots is always 1 pixel larger
 	# Than the radius of the mouse pointer collision area.
 	# This ensures that we don't highlight 2 slots at the same time.

src/core/BoardPlacementSlot.gd

@@ -14,7 +14,7 @@ onready var owner_grid = get_parent().get_parent()
 func _ready() -> void:
 	# We set the initial size of our highlight and area, to 
 	# fit the size of the cards on the board.
-	rect_min_size = CFConst.CARD_SIZE * CFConst.PLAY_AREA_SCALE
+	rect_min_size = owner_grid.card_size * owner_grid.card_play_scale
 	$Highlight.rect_min_size = rect_min_size
 	$Area2D/CollisionShape2D.shape.extents = rect_min_size / 2
 	$Area2D/CollisionShape2D.position = rect_min_size / 2

src/core/CFControl.gd

@@ -24,6 +24,11 @@ var _ut_show_token_buttons := CFConst.SHOW_TOKEN_BUTTONS
 # It is initiated by looking for [CFConst#SETTINGS_FILENAME], but if it
 # doesn't exist, defaults to the values specified in CFConst, if applicable.
 var game_settings := {}
+# This variable stores the font and icon size for each string of text.
+# based on the current card size. This allows us to avoid calculating fonts
+# on the fly all the time and adding delay to card instancing.
+var font_size_cache := {}
+var cache_commit_timer: SceneTreeTimer
 # If set to true, the player will be prevented from interacting with the game
 var game_paused := false setget set_game_paused
 # If this is false, all CardContainers will pause in their ready() scene
@@ -85,6 +90,7 @@ var ov_utils  = load(CFConst.PATH_OVERRIDABLE_UTILS).new()
 
 func _ready() -> void:
 	init_settings_from_file()
+	init_font_cache()
 	if not game_settings.has('fancy_movement'):
 		game_settings['fancy_movement'] = CFConst.FANCY_MOVEMENT
 	if not game_settings.has('focus_style'):
@@ -108,7 +114,6 @@ func _ready() -> void:
 	set_seed(game_rng_seed)
 	card_definitions = load_card_definitions()
 
-
 # Run when all necessary nodes (Board, CardContainers etc) for the game
 # have been initialized. Allows them to proceed with their ready() functions.
 func _on_all_nodes_mapped() -> void:
@@ -239,6 +244,38 @@ func init_settings_from_file() -> void:
 			game_settings = data.duplicate()
 
 
+func set_font_cache() -> void:
+#	var timer = Timer.new()
+#	timer.connect("timeout", self, "_commit_font_cache", [timer])
+#	timer.wait_time = 1
+#	timer.start()
+	if not cache_commit_timer:
+		cache_commit_timer = get_tree().create_timer(1.0)
+		cache_commit_timer.connect("timeout", self, "_commit_font_cache")
+		
+	
+# Whenever a setting is changed via this function, it also stores it
+# permanently on-disk.
+func _commit_font_cache() -> void:
+#	timer.disconnect("timeout", self, "_commit_font_cache")
+#	timer.queue_free()
+	var file = File.new()
+	file.open(CFConst.FONT_SIZE_CACHE, File.WRITE)
+	file.store_string(JSON.print(font_size_cache, '\t'))
+	file.close()
+	cache_commit_timer = null
+
+
+# Initiates game_settings from the contents of CFConst.SETTINGS_FILENAME
+func init_font_cache() -> void:
+	var file = File.new()
+	if file.file_exists(CFConst.FONT_SIZE_CACHE):
+		file.open(CFConst.FONT_SIZE_CACHE, File.READ)
+		var data = parse_json(file.get_as_text())
+		file.close()
+		if typeof(data) == TYPE_DICTIONARY:
+			font_size_cache = data.duplicate()
+
 # This function resets the game to the same state as when
 # the board loads for the first time. Only works when you're running
 # off of the Main scene.

src/core/Card/CardFront.gd

@@ -47,7 +47,7 @@ onready var card_owner = get_parent().get_parent().get_parent()
 
 # Set a label node's text.
 # As the string becomes longer, the font size becomes smaller
-func set_label_text(node: Label, value):
+func set_label_text(node: Label, value, scale: float = 1):
 #	while font_thread and font_thread.is_active():
 #		yield(get_tree(), "idle_frame")
 #	font_thread = Thread.new()
@@ -57,29 +57,36 @@ func set_label_text(node: Label, value):
 		return
 	resizing_labels.append(node)
 	value = _check_for_replacements(node, value)
-	# We add a yield here to allow the calling function to continue
-	# and thus avoid the game waiting for the label to resize
-	yield(get_tree(), "idle_frame")
-	var working_value: String
-	# If the label node has been set to uppercase the text
-	# Then we need to work off-of uppercased text value
-	# otherwise our calculation will be off and we'll
-	# end up extending the rect_size.y anyway
-	if node.uppercase:
-		working_value = value.to_upper()
-	else:
-		working_value = value
-	_capture_original_font_size(node)
-	var line_spacing = node.get("custom_constants/line_spacing")
-	if not line_spacing:
-		line_spacing = 3
-	var starting_font_size: int = font_sizes[node.name]
 	var label_font :Font = get_card_label_font(node)
-	label_font.size = starting_font_size
-	var font_adjustment := _adjust_font_size(label_font, working_value, node.rect_min_size, line_spacing)
-#	if  node.name == "Abilities": font_adjustment = -17
-	# We always start shrinking the size, starting from the original size.
-	label_font.size = starting_font_size + font_adjustment
+#	print_debug(scaled_fonts.get(node.name, 1))
+	var cached_font_size = get_cached_font_size(node,value,scale)
+	if cached_font_size:
+		label_font.size = cached_font_size
+	else:
+		# We add a yield here to allow the calling function to continue
+		# and thus avoid the game waiting for the label to resize
+		yield(get_tree(), "idle_frame")
+		var working_value: String
+		# If the label node has been set to uppercase the text
+		# Then we need to work off-of uppercased text value
+		# otherwise our calculation will be off and we'll
+		# end up extending the rect_size.y anyway
+		if node.uppercase:
+			working_value = value.to_upper()
+		else:
+			working_value = value
+		_capture_original_font_size(node)
+		var line_spacing = node.get("custom_constants/line_spacing")
+		if not line_spacing:
+			line_spacing = 3
+		var starting_font_size: int = font_sizes[node.name]
+		label_font.size = starting_font_size
+		var font_adjustment := _adjust_font_size(label_font, working_value, node.rect_min_size, line_spacing)
+	#	if  node.name == "Abilities": font_adjustment = -17
+		# We always start shrinking the size, starting from the original size.
+#		print_debug(scaled_fonts.get(node.name, 1))
+		_cache_font_size(node,value,starting_font_size + font_adjustment,scale)
+		label_font.size = starting_font_size + font_adjustment
 	set_card_label_font(node, label_font)
 	node.text = value
 	resizing_labels.erase(node)
@@ -127,16 +134,16 @@ func scale_to(scale_multiplier: float) -> void:
 				yield(get_tree(), "idle_frame")
 			if card_labels[l] as RichTextLabel:
 				var label : RichTextLabel = card_labels[l]
-				call_deferred("set_rich_label_text",label, label.bbcode_text, true)
+				call_deferred("set_rich_label_text",label, label.bbcode_text, true, scale_multiplier)
 			else:
 				var label : Label = card_labels[l]
-				call_deferred("set_label_text",label, label.text)
+				call_deferred("set_label_text",label, label.text, scale_multiplier)
 
 
 
 # Set a label node's bbcode text.
 # As the string becomes longer, the font size becomes smaller
-func set_rich_label_text(node: RichTextLabel, value: String, is_resize := false):
+func set_rich_label_text(node: RichTextLabel, value: String, is_resize := false, scale : float = 1):
 	# We need to avoid other functions to trying to resize this label
 	# while it's already resizing, as due to all the yields
 	# it causes a mess
@@ -163,59 +170,102 @@ func set_rich_label_text(node: RichTextLabel, value: String, is_resize := false)
 	# We always start shrinking the size, starting from the original size.
 	_capture_original_font_size(node)
 	_capture_rt_font_size_variations(node)
-	var starting_font_size: int = font_sizes[node.name]
-	var font_adjustment:= 0
-#	label_font.size = font_sizes[node.name]
-	var label_size = node.rect_min_size
-	_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
-	_assign_bbcode_text(node, value, starting_font_size + font_adjustment)
-	# Rich Text has no way to grab its total size without setting the bbcode first
-	# After we set the bbcode, we need to wait for the next frame for the label to adjust
-	# and then we can grab its height
-	yield(get_tree(), "idle_frame")
-	var bbcode_height = node.get_content_height()
-	# To save some time, we use the same trick we do in normal labels
-	# where we reduce the font size to fits its rect
-	# However unlike normal labels, we might have icons and different font sizes
-	# which will not be taken into account.
-	# Therefore this gives us the starting point, but further reduction might be
-	# needed.
-	if bbcode_height > label_size.y:
-		font_adjustment = _adjust_font_size(label_fonts["normal_font"], node.text, label_size)
-		_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
-		yield(get_tree(), "idle_frame")
-		bbcode_height = node.get_content_height()
-#		print_debug(bbcode_height, ':', font_adjustment, ':', label_size.y)
-	# If the reduction of font sizes when checking against the normal font
-	# was not enough to bring the total rich label height into the rect.y we want
-	# we use a while loop where we do the following in order
-	# * reduce all rich-text font sizes by 1
-	# * reset the bbcode text
-	# * Wait for the next frame
-	# * grab the new rich text height
-	# Unitl the rich text height is smaller than the labels' rect size.
-	while bbcode_height > label_size.y:
-		font_adjustment -= 1
+	var cached_font_size = get_cached_font_size(node,value,scale)
+	if cached_font_size:
+		_set_card_rtl_fonts(node, label_fonts, cached_font_size)
+		_assign_bbcode_text(node, value, cached_font_size)
+	else:
+		var starting_font_size: int = font_sizes[node.name]
+		var font_adjustment:= 0
+	#	label_font.size = font_sizes[node.name]
+		var label_size = node.rect_min_size
 		_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
 		_assign_bbcode_text(node, value, starting_font_size + font_adjustment)
+		# Rich Text has no way to grab its total size without setting the bbcode first
+		# After we set the bbcode, we need to wait for the next frame for the label to adjust
+		# and then we can grab its height
 		yield(get_tree(), "idle_frame")
-		bbcode_height = node.get_content_height()
-		# If we don't keep the card front face-up while setting the RTL,
-		# The bbcode_height will be returned as either 0 or 1000 after setting the
-		# bbcode_text. Regardless of how long we wait.
-		# The below snipper was debugging code to keep the code waiting to resize
-		# until the card was turned face-up
-#		while bbcode_height == 0 or bbcode_height > 1000:
-#			_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
-#			_assign_bbcode_text(node, value, starting_font_size + font_adjustment)
-#			yield(get_tree(), "idle_frame")
-#			bbcode_height = node.get_content_height()
-		if starting_font_size + font_adjustment == 4:
-			break
+		var _retries := 0
+		var bbcode_height = node.get_content_height()
+		while bbcode_height == 0 or bbcode_height > 1000:
+			_retries += 1
+			print_debug("BBcode height:" + bbcode_height + " retrying: " + _retries)
+			yield(get_tree(), "idle_frame")
+			bbcode_height = node.get_content_height()
+			if _retries >= 10:
+				break
+		# To save some time, we use the same trick we do in normal labels
+		# where we reduce the font size to fits its rect
+		# However unlike normal labels, we might have icons and different font sizes
+		# which will not be taken into account.
+		# Therefore this gives us the starting point, but further reduction might be
+		# needed.
+		if bbcode_height > label_size.y:
+			font_adjustment = _adjust_font_size(label_fonts["normal_font"], node.text, label_size)
+			_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
+			yield(get_tree(), "idle_frame")
+			bbcode_height = node.get_content_height()
+	#		print_debug(bbcode_height, ':', font_adjustment, ':', label_size.y)
+		# If the reduction of font sizes when checking against the normal font
+		# was not enough to bring the total rich label height into the rect.y we want
+		# we use a while loop where we do the following in order
+		# * reduce all rich-text font sizes by 1
+		# * reset the bbcode text
+		# * Wait for the next frame
+		# * grab the new rich text height
+		# Unitl the rich text height is smaller than the labels' rect size.
+		while bbcode_height > label_size.y:
+			font_adjustment -= 1
+			_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
+			_assign_bbcode_text(node, value, starting_font_size + font_adjustment)
+			yield(get_tree(), "idle_frame")
+			bbcode_height = node.get_content_height()
+			_retries = 0
+			while bbcode_height == 0 or bbcode_height > 1000:
+				_retries += 1
+				print_debug("BBcode height:" + bbcode_height + " retrying: " + _retries)
+				yield(get_tree(), "idle_frame")
+				bbcode_height = node.get_content_height()
+				if _retries >= 10:
+					break
+			# If we don't keep the card front face-up while setting the RTL,
+			# The bbcode_height will be returned as either 0 or 1000 after setting the
+			# bbcode_text. Regardless of how long we wait.
+			# The below snipper was debugging code to keep the code waiting to resize
+			# until the card was turned face-up
+	#		while bbcode_height == 0 or bbcode_height > 1000:
+	#			_set_card_rtl_fonts(node, label_fonts, starting_font_size + font_adjustment)
+	#			_assign_bbcode_text(node, value, starting_font_size + font_adjustment)
+	#			yield(get_tree(), "idle_frame")
+	#			bbcode_height = node.get_content_height()
+			if starting_font_size + font_adjustment == 4:
+				break
+		_cache_font_size(node,value,starting_font_size + font_adjustment, scale)
 	modulate.a = 1
 	resizing_labels.erase(node)
 
 
+func _cache_font_size(label: Control, text: String, font_size: int, scale : float) -> void:
+	var text_md5 =  text.md5_text()
+	# We will store each label's font size in a key based on the card scale
+	# The default scale being 1
+	# It has to be a string because the Godot Json print converts ints to
+	# Strings when saving to file
+	var card_size = str(scale)
+	if not cfc.font_size_cache.has(card_size):
+		cfc.font_size_cache[card_size] = {}
+	if not cfc.font_size_cache[card_size].has(label.name):
+		cfc.font_size_cache[card_size][label.name] = {}
+	cfc.font_size_cache[card_size][label.name][text_md5] = font_size
+	cfc.set_font_cache()
+
+
+func get_cached_font_size(label: Control, text: String, scale : float):
+	var text_md5 =  text.md5_text()
+	var card_size = str(scale)
+	var cached_font_size = cfc.font_size_cache.get(card_size, {}).get(label.name, {}).get(text_md5)
+	return(cached_font_size)
+
 # Stores the original font size this label had.
 # We use this to start shrinking the label from this size, which allows us to
 # also increase it's size when its text changes to be smaller.

src/core/CardContainer.gd

@@ -35,6 +35,7 @@ export(CFInt.OverlapShiftDirection) var overlap_shift_direction
 # In case of multiple CardContainers using the same anchor placement
 # specifies which container should be displaced more.
 export(CFInt.IndexShiftPriority) var index_shift_priority
+export var card_size := CFConst.CARD_SIZE
 
 # Used for debugging
 var _debugger_hook := false
@@ -301,12 +302,12 @@ func re_place():
 			# Right position always start from the right-side of the viewport
 			# minus the width of the container
 			Anchors.TOP_RIGHT, Anchors.RIGHT_MIDDLE, Anchors.BOTTOM_RIGHT:
-				place.x = get_viewport().size.x - (CFConst.CARD_SIZE.x * scale.x)
+				place.x = get_viewport().size.x - (card_size.x * scale.x)
 				add_to_group("right")
 			# Middle placement is the middle of the viewport width,
 			# minues half the height of the container
 			Anchors.TOP_MIDDLE, Anchors.BOTTOM_MIDDLE:
-				place.x = get_viewport().size.x / 2 - (CFConst.CARD_SIZE.x / 2 * scale.x)
+				place.x = get_viewport().size.x / 2 - (card_size.x / 2 * scale.x)
 		# Now we adjust the y position. Same logic for
 		match placement:
 			# Top position always start from y == 0,
@@ -317,12 +318,12 @@ func re_place():
 			# Bottom position always start from the bottom of the viewport
 			# minus the height of the container
 			Anchors.BOTTOM_LEFT, Anchors.BOTTOM_MIDDLE, Anchors.BOTTOM_RIGHT:
-				place.y = get_viewport().size.y - (CFConst.CARD_SIZE.y * scale.y)
+				place.y = get_viewport().size.y - (card_size.y * scale.y)
 				add_to_group("bottom")
 			# Middle placement is the middle of the viewport height
 			# minus half the height of the container
 			Anchors.RIGHT_MIDDLE, Anchors.LEFT_MIDDLE:
-				place.y = get_viewport().size.y / 2 - (CFConst.CARD_SIZE.y / 2 * scale.y)
+				place.y = get_viewport().size.y / 2 - (card_size.y / 2 * scale.y)
 		# Now we try to discover if more than one CardContainer share
 		# the same anchor and the figure out which to displace.
 		var duplicate_anchors := {}