Better save management

Atproto/AtProtoSaveFactory.cs

···
             .Named("AtProtoSave")
             .Patching("res://Scenes/Singletons/UserSave/usersave.gdc")
             .AddRule(new TransformationRuleBuilder()
+                .Named("ready_slot_condition")
+                .Matching(TransformationPatternFactory.CreateGdSnippetPattern("_load_save(last_loaded_slot)", 2))
+                .Do(Operation.ReplaceAll)
+                .With("""
+                      var Atproto = $"/root/Atproto"
+                      if last_loaded_slot != Atproto.ATPROTO_SLOT or Atproto.config.Autoload:
+                      	_load_save(last_loaded_slot)
+                      else:
+                      	last_loaded_slot = -1
+                      """, 2)
+            )
+            .AddRule(new TransformationRuleBuilder()
                 .Named("save_file")
                 .Matching(TransformationPatternFactory.CreateGdSnippetPattern(
                     "\"locked_refs\": PlayerData.locked_refs, \n\t}\n", 2))
                 .Do(Operation.Append)
-                .With("var atproto = $\"/root/Atproto\"\nif atproto.AtProtoClient.connected() && atproto.save_loaded != null:\n\tatproto.AtProtoClient.save_file()\n", 1)).Build();
+                .With("var atproto = $\"/root/Atproto\"\nif atproto.can_save_to_atproto():\n\tatproto.AtProtoClient.save_file()\n", 1)
+            )
+            
+            .Build();
     }
 }

gdscript/mods/Atproto/atproto_client.gd

···
 
 # Signals
 signal connection(suceeded)
+signal savefile_loaded(uri)
+
+# State
+var can_save = true
 
 # AtProto
 var did
···
 func get_saves(callback: FuncRef):
 	list_records(callback, "dev.regnault.webfishing.savefile")
 	
-func save_file(callback: FuncRef = null):
-	if !connected(): return
+	
+func get_save_data():
 	var save_data = {
 		"inventory": PlayerData.inventory, 
 		"hotbar": PlayerData.hotbar, 
···
 	for letter in save_data.inbound_mail:
 		for item in letter.items:
 			item.size = str(item.size)
+			
+	return save_data
+	
+func save_file(callback: FuncRef = null, creation = false):
+	if UserSave.current_loaded_slot != Atproto.ATPROTO_SLOT:
+		return
+	if !connected(): return
+	
+	var save_data = get_save_data()
 	save_data.at_type = "dev.regnault.webfishing.save"
 	
-	if Atproto.save_loaded:
+	if Atproto.save_loaded != "":
 		put_record(Atproto.save_loaded, save_data)
-	else:
-		create_record(save_data, callback)
-	
+
+func create_save(callback: FuncRef = null):
+	if !connected(): return
+	var save_data = get_save_data()
+	save_data.at_type = "dev.regnault.webfishing.save"
+	create_record(save_data, callback)
+
 func load_save(uri: String):
 	var splitted_uri = uri.split("/")
 	var did = splitted_uri[2]
···
 
 func _after_get_save(save_record):
 	var save = save_record.value
+	
+	UserSave._load_save(Atproto.ATPROTO_SLOT)
 	
 	var modified_journal: Dictionary = {}
 	for area in save.journal:
···
 	PlayerData._missing_quest_check()
 	PlayerData._unlock_defaults()
 	
-	Atproto.config.Save = save_record.uri
-	Atproto.save_loaded = save_record.uri
-	PopupMessage._show_popup("AtProto save file loaded")
+	can_save = false
+	UserSave._save_slot(Atproto.ATPROTO_SLOT)
+	can_save = true
+	
+	emit_signal("savefile_loaded", save_record.uri)
+	
 	

gdscript/mods/Atproto/main.gd

···
 extends Node
 
 var config: Dictionary
+
+const ATPROTO_SLOT = 99
 var save_loaded: String
 var default_config: Dictionary = {}
 
···
 func _enter_tree():
 	AtProtoClient = AtProtoClient_t.new()
 	add_child(AtProtoClient)
+	AtProtoClient.connect("savefile_loaded", self, "set_save_file")
 	get_tree().connect("node_added", self, "_add_atproto_menu")
 	
 	
 func _ready() -> void:
-	print("QUOTA:", Steam.getQuota())
-	TackleBox.connect("mod_config_updated", self, "_on_config_update")
-
 	_init_config()
 
 func _init_config():
···
 	if config.Autoconnect == true:
 		AtProtoClient.login(config.Handle, config.Password)
 
-
 func _save_config():
 	TackleBox.set_mod_config(name, config)
 
-func _on_config_update(mod_id: String, new_config: Dictionary) -> void:
-	if mod_id != name:
-		return
-	if config.hash() == new_config.hash():
-		return
-	config = new_config
-	if config.Handle != "" and config.Password != "":
-		AtProtoClient.login(config.Handle, config.Password)
-
 func _add_atproto_menu(node: Node):
 	if node.name == "main_menu":
 		var atproto_menu: Node = AtProtoMenu.instance()
···
 	
 	if config.Save != "" and config.Autoload and AtProtoClient.connected():
 		AtProtoClient.load_save(config.Save)
+
+func can_save_to_atproto():
+	return AtProtoClient.can_save && UserSave.current_loaded_slot == ATPROTO_SLOT && AtProtoClient.connected()
+
+func set_save_file(save_uri):
+	save_loaded = save_uri

gdscript/mods/Atproto/ui/buttons/atproto.gd

···
 
 func _on_mods_pressed() -> void:
 	var atproto_menu = $"../../atproto_config"
+	atproto_menu._refresh()
 	atproto_menu.visible = true

gdscript/mods/Atproto/ui/menus/atproto_config.gd

···
 extends Node
 
 onready var Atproto := $"/root/Atproto"
+
 const AtProtoNewSaveMenu := preload("res://mods/Atproto/ui/menus/new_save.tscn")
 
 signal setup_done()
···
 var Saves : VBoxContainer
 
 func _ready():
+	Atproto.AtProtoClient.connect("savefile_loaded", self, "set_save_file")
 	Settings = $"%atproto_settings"
 	Credentials = Settings.get_node("credentials")
 	Saves = Settings.get_node("saves")
···
 		load_save_button.disabled = true
 		new_save_button.disabled = true
 	
+	_refresh()
 	emit_signal("setup_done")
 
 func _on_apply_pressed() -> void:
···
 func after_login(_a = null):
 	Atproto.AtProtoClient.get_saves(funcref(self, "init_saves"))
 	
+func _refresh():
+	$"%atproto_settings/save_info".text = get_loaded_save_info()
 
+func get_loaded_save_info():
+	if UserSave.current_loaded_slot != Atproto.ATPROTO_SLOT:
+		return "No AtProto save loaded"
+	else:
+		var save_option: OptionButton = Saves.get_node("save").get_node("OptionButton")
+		var i = 0
+		while i < save_option.get_item_count():
+			var metadata = save_option.get_item_metadata(i)
+			if metadata == Atproto.save_loaded:
+				return save_option.get_item_text(i) + " is currently loaded"
+			i+=1
+		return "Invalid save file loaded"
 # SAVES
 
+func set_save_file(save_uri):
+	Atproto.config.Save = save_uri
+	PopupMessage._show_popup("AtProto save loaded : " + get_current_save_name())
+	_refresh()
+	pass
+
 func _on_load_save_button_down():
 	var save: OptionButton = Saves.get_node("save").get_node("OptionButton")
 	Atproto.AtProtoClient.load_save(save.get_selected_metadata())
 	pass
 
 
+func get_current_save_name() -> String:
+	if UserSave.current_loaded_slot != 99:
+		return "Slot " + str(UserSave.current_loaded_slot + 1)
+		
+	var save_option: OptionButton = Saves.get_node("save").get_node("OptionButton")
+	var i = 0
+	while i < save_option.get_item_count():
+			var metadata = save_option.get_item_metadata(i)
+			if metadata == Atproto.save_loaded:
+				return save_option.get_item_text(i)
+			i+=1
+	return ""
+
 func _on_new_save_button_down():
+	var current = get_current_save_name()
+	if current != "":
+		SaveMenu.get_node("save_menu/duplicate").text = "Duplicate " + current
+		SaveMenu.get_node("save_menu/duplicate").disabled = false
+	else:
+		SaveMenu.get_node("save_menu/duplicate").text = "Invalid Save"
+		SaveMenu.get_node("save_menu/duplicate").disabled = true
+	 
 	SaveMenu.visible = true
-	pass # Replace with function body.
+
 
 # Create Save Menu
 func init_save_menu():
···
 	var backup = backup_save()
 	if !duplicate:
 		PlayerData._reset_save()
-	Atproto.AtProtoClient.save_file(funcref(self, "create_save_file"))
+	Atproto.AtProtoClient.create_save(funcref(self, "create_save_file"))
 	close_save_menu()
 	restore_save(backup)
 	pass
 	
+func save_file_created(record):
+	var file_name = SaveMenu.get_node("save_menu/Panel/save_name/LineEdit").text
+	PopupMessage._show_popup("AtProto save created : " + file_name)
+	SaveMenu.get_node("save_menu/Panel/save_name/LineEdit").text = ""
+	after_login()
+	pass
+	
 func create_save_file(save_record):
 	var file_name = SaveMenu.get_node("save_menu/Panel/save_name/LineEdit").text
 	var uri = save_record.uri
-	Atproto.AtProtoClient.create_save_file(uri, file_name, funcref(self, "after_login"))
+	Atproto.AtProtoClient.create_save_file(uri, file_name, funcref(self, "save_file_created"))
 	pass
 	
 func backup_save():

gdscript/mods/Atproto/ui/menus/atproto_config.tscn

···
 [node name="atproto_settings" type="VBoxContainer" parent="Panel/Panel/ScrollContainer"]
 unique_name_in_owner = true
 margin_right = 704.0
-margin_bottom = 356.0
+margin_bottom = 428.0
 size_flags_horizontal = 3
 custom_constants/separation = 40
 
···
 margin_bottom = 32.0
 size_flags_horizontal = 3
 text = "Load Save"
+
+[node name="save_info" type="Label" parent="Panel/Panel/ScrollContainer/atproto_settings"]
+margin_top = 396.0
+margin_right = 704.0
+margin_bottom = 428.0
+text = "[No Save File Loaded]"
+align = 1
 
 [node name="Loader" type="Panel" parent="Panel"]
 visible = false

gdscript/mods/Atproto/ui/menus/new_save.tscn

···
 corner_radius_bottom_left = 16
 
 [node name="Node2D" type="Control"]
-margin_right = 1920.0
-margin_bottom = 1080.0
+anchor_right = 1.0
+anchor_bottom = 1.0
 theme = ExtResource( 1 )
 
 [node name="background" type="ColorRect" parent="."]
 anchor_right = 1.0
 anchor_bottom = 1.0
-margin_left = -67.0
-margin_top = 17.0
-margin_right = 1853.0
-margin_bottom = 1097.0
+margin_left = -83.0
+margin_top = -47.0
+margin_right = 33.0
+margin_bottom = 29.0
 size_flags_horizontal = 3
 size_flags_vertical = 3
 color = Color( 0.0627451, 0.109804, 0.192157, 0.431373 )
···
 size_flags_horizontal = 3
 
 [node name="Label" type="Label" parent="save_menu/Panel/save_name"]
-margin_right = 521.0
+margin_right = 520.0
 margin_bottom = 32.0
 text = "Save Name"
 align = 1
 
 [node name="LineEdit" type="LineEdit" parent="save_menu/Panel/save_name"]
 margin_top = 36.0
-margin_right = 521.0
+margin_right = 520.0
 margin_bottom = 68.0
 size_flags_horizontal = 3
 
···
 margin_top = -56.0
 margin_right = 0.287964
 margin_bottom = 24.0
+grow_horizontal = 0
 rect_pivot_offset = Vector2( 89, 24 )
 text = "Duplicate Save"
 script = ExtResource( 2 )