load, save, list terrain

utils/terrain/Terrain.gd

@@ -256,7 +256,6 @@ class Edge:
 		return line
 
 # Terrain instance variables
-const terrain_file = "user://terrain_%s.save"
 
 var _width: int
 var _height: int
@@ -270,44 +269,79 @@ var _data = {}
 var _points_data = []
 var _edges_data = []
 var _triangles_data = []
-var _file = File.new()
+
+var _created = false
+var _loaded = false
+var _list = []
 
 # Terrain constructor
-func _init(width:int=1600, height:int=800, spacing:int=30, create=false, name:String="delaunay"):
+func _init(width:int=1600, height:int=800, spacing:int=30, create=false, name:String=""):
-	if _file.file_exists(terrain_file) and not create:
+	var terrain_dir = Directory.new()
+	terrain_dir.open("user://")
+	if not terrain_dir.dir_exists("terrain"):
+		terrain_dir.make_dir("terrain")
+	terrain_dir.change_dir("terrain")
+	terrain_dir.list_dir_begin()
+	var filename = terrain_dir.get_next()
+	while filename != "":
+		if terrain_dir.file_exists(filename):
+			# Ok terrain file found
+			var terrain = {}
+			var terrain_filename = "user://terrain/%s" % (filename)
+			var file = File.new()
+			file.open(terrain_filename, File.READ)
+			terrain["width"] = file.get_var()
+			terrain["height"] = file.get_var()
+			terrain["spacing"] = file.get_var()
+			terrain["name"] = file.get_var()
+			file.close()
+			_list.append(terrain)
+		filename = terrain_dir.get_next()
+	terrain_dir.list_dir_end()
+	
+	var file = File.new()
+	var terrain_filename = "user://terrain/terrain_%s.save" % (name)
+	if file.file_exists(terrain_filename) and not create:
 		Global.print_debug("loading : %s ..." % (name))
-		_load(name)
+		load(name)
 	else:
-		Global.print_debug("Creating : %s ..." % (name))
+		if name:
-		var delaunay: Delaunator
+			create(width, height, spacing, name)
-		_width = width
+
-		_height = height
-		_spacing = spacing
-		_create_points()
-		delaunay = Delaunator.new(_points)
 		
-		_halfedges = PoolIntArray(delaunay.halfedges)
+func create(width:int, height:int, spacing:int, name:String):
-		_triangles = PoolIntArray(delaunay.triangles)
+	Global.print_debug("Creating : %s ..." % (name))
+	var delaunay: Delaunator
+	_width = width
+	_height = height
+	_spacing = spacing
+	_name = name
+	_create_points()
+	delaunay = Delaunator.new(_points)
 	
-		# Initialize _points_to_halfedges
+	_halfedges = PoolIntArray(delaunay.halfedges)
-		for edge in get_edges():
+	_triangles = PoolIntArray(delaunay.triangles)
-			var endpoint = _triangles[edge.next_half().get_index()]
-			if (! _points_to_halfedges.has(endpoint) or _halfedges[edge.get_index()] == -1):
-				_points_to_halfedges[endpoint] = edge.get_index()
 	
-		# Initialise _points_data
+	# Initialize _points_to_halfedges
-		for point_idx in self.get_points().size():
+	for edge in get_edges():
-			_points_data.append({})
+		var endpoint = _triangles[edge.next_half().get_index()]
+		if (! _points_to_halfedges.has(endpoint) or _halfedges[edge.get_index()] == -1):
+			_points_to_halfedges[endpoint] = edge.get_index()
 		
-		# Initialise _edges_data
+	# Initialise _points_data
-		for edge_idx in self.get_edges().size():
+	for point_idx in self.get_points().size():
-			_edges_data.append({})
+		_points_data.append({})
 	
-		# Initialise _triangle_data
+	# Initialise _edges_data
-		for triangle_idx in self.get_triangles().size():
+	for edge_idx in self.get_edges().size():
-			_triangles_data.append({})
+		_edges_data.append({})
 	
-		_save()
+	# Initialise _triangle_data
+	for triangle_idx in self.get_triangles().size():
+		_triangles_data.append({})
+	
+	_created = true
+	save()
 
 # Create points on the terrain	
 func _create_points():
@@ -341,37 +375,71 @@ func get_edge(idx):
 func get_triangle(idx):
 	return Triangle.new(idx, self)
 	
-func _save():
+func save():
-	_file.open(terrain_file % (_name), File.WRITE)
+	var terrain_dir = Directory.new()
-	_file.store_var(_width)
+	var file = File.new()
-	_file.store_var(_height)
+	var terrain_filename = "user://terrain/terrain_%s.save" % (_name)
-	_file.store_var(_spacing)
+	terrain_dir.open("user://")
-	_file.store_var(_name)
+	if not terrain_dir.dir_exists("terrain"):
-	_file.store_var(_points)
+		terrain_dir.make_dir("terrain")
-	_file.store_var(_halfedges)
+	terrain_dir.change_dir("terrain")
-	_file.store_var(_triangles)
+	Global.print_debug("Save file : %s" % (terrain_filename))
-	_file.store_var(_points_to_halfedges)
+	file.open(terrain_filename, File.WRITE)
-	_file.store_var(_data)
+	file.store_var(_width)
-	_file.store_var(_points_data)
+	file.store_var(_height)
-	_file.store_var(_edges_data)
+	file.store_var(_spacing)
-	_file.store_var(_triangles_data)
+	file.store_var(_name)
-	_file.close()
+	file.store_var(_points)
-	
+	file.store_var(_halfedges)
-func _load(name):
+	file.store_var(_triangles)
-	_file.open(terrain_file % (name), File.READ)
+	file.store_var(_points_to_halfedges)
-	_width = _file.get_var()
+	file.store_var(_data)
-	_height = _file.get_var()
+	file.store_var(_points_data)
-	_spacing = _file.get_var()
+	file.store_var(_edges_data)
-	_name = _file.get_var()
+	file.store_var(_triangles_data)
-	_points = _file.get_var()
+	file.close()
-	_halfedges = _file.get_var()
+	
-	_triangles = _file.get_var()
+func load(name):
-	_points_to_halfedges = _file.get_var()
+	var terrain_dir = Directory.new()
-	_data = _file.get_var()
+	var file = File.new()
-	_points_data = _file.get_var()
+	var terrain_filename = "user://terrain/terrain_%s.save" % (name)
-	_edges_data = _file.get_var()
+	terrain_dir.open("user://")
-	_triangles_data = _file.get_var()
+	if not terrain_dir.dir_exists("terrain"):
-	_file.close()
+		terrain_dir.make_dir("terrain")
+	if terrain_dir.file_exists(terrain_filename):
+		Global.print_debug("Load file : %s" % (terrain_filename))
+		file.open(terrain_filename, File.READ)
+		_width = file.get_var()
+		_height = file.get_var()
+		_spacing = file.get_var()
+		_name = file.get_var()
+		_points = file.get_var()
+		_halfedges = file.get_var()
+		_triangles = file.get_var()
+		_points_to_halfedges = file.get_var()
+		_data = file.get_var()
+		_points_data = file.get_var()
+		_edges_data = file.get_var()
+		_triangles_data = file.get_var()
+		file.close()
+		_loaded = true
+	else:
+		Global.print_debug("The file : %s does not exist" % (terrain_filename))
+	
+func list():
+	return _list
+
+func is_created():
+	return _created
+	
+func is_loaded():
+	return _loaded
+	
+func exists(name):
+	for terrain in _list:
+		if name == terrain["name"]:
+			return true
+	return false
 	
 func get_triangles_as_polygon():
 	var list_polygon = []

world/game.gd

@@ -22,10 +22,25 @@ func _ready():
 	rng.randomize()
 	noise.seed = rng.randi()
 	noise.octaves = octaves
-	terrain = Terrain.new(width,height,spacing,true)
+	# terrain = Terrain.new(width,height,spacing,false)
 	
-	init_data()
+	var terrain_name="bonjour"
-	emit_signal("world_loaded", terrain)
+	terrain = Terrain.new()
+
+	print(terrain.list())
+	
+	if terrain.exists(terrain_name):
+		terrain.load(terrain_name)
+	else:
+		terrain.create(width,height,spacing,"bonjour")
+
+	if terrain.is_created() or terrain.is_loaded():
+		init_data()
+		emit_signal("world_loaded", terrain)
+	else:
+		Global.print_debug("Pas de terrain, pas de construction ...")
+		Global.print_debug("Pas de construction ..., pas de palais ...")
+		Global.print_debug("Pas de palais ..., pas de palais.")
 
 func init_data():
 	for point in terrain.get_points():