存档

render/shader/level_grid_block.gdshader

@@ -1,7 +1,9 @@
 shader_type spatial;
 uniform bool is_target = false;
+uniform bool is_focus = false;
 uniform vec3 target_position = vec3(0, 1.28, 1);
-uniform bool show_air_wall = true;
+uniform vec3 focus_min = vec3(0,0,0);
+uniform vec3 focus_max = vec3(0,0,0);
 varying vec3 world_position;
 varying vec2 uv1;
 varying vec2 uv2;
@@ -16,16 +18,22 @@ void vertex()
     uv2 = local_uv / 32.0;
 }
 
+bool is_in_focus(vec3 f_min,vec3 f_max){
+    if(world_position.z>f_max.z){return false;}
+    if(world_position.y>f_max.y){return false;}
+    return true;
+}
+
 void fragment() {
+	if (is_focus && !is_in_focus(focus_min,focus_max)){
+        discard;
+	}
+  
     vec3 c = COLOR.rgb;
     if(c.r+c.g+c.b<0.1){
         ALBEDO = vec3(0.0);
     }else if(c.r+c.g+c.b>2.9){
-        if(show_air_wall){
-            ALBEDO = vec3(1.0);
-        }else{
         discard;
-        }
     }else{
         float brightness = 1.0;
         if(is_target){
@@ -41,9 +49,6 @@ void fragment() {
         if(!is_light && world_normal.y<0.1){
             brightness = brightness*0.6;
         }
-		if(show_air_wall){
-			brightness = 1.0;
-		}
 
 		float noise_value1 = texture(tex_noise1,floor(uv1 /0.02) *0.02).r;
 		float discrete_noise_value1 = floor(noise_value1 / 0.5) * 0.5;

script/_global/util.gd

@@ -33,6 +33,11 @@ func get_level_grid_pos(pos: Vector3) -> Vector3i:
 	var ret: Vector3i    = Vector3i(get_div_scale(pos.x, grid_size), get_div_scale(pos.y, grid_size), get_div_scale(pos.z, grid_size))
 	return ret
 
+func get_level_grid_pos2(pos: Vector3) -> Vector3i:
+	var grid_size: float = Setting.pixel_size* Setting.grid_pixel_size * 2
+	var ret: Vector3i    = Vector3i(get_div_scale(pos.x, grid_size), get_div_scale(pos.y, grid_size), get_div_scale(pos.z, grid_size))
+	return ret
+
 
 func get_level_float_pos(pos: Vector3i) -> Vector3:
 	var grid_size: float = Setting.pixel_size* Setting.grid_pixel_size

script/level/level.gd

@@ -11,7 +11,7 @@ var born_pos: Vector3
 func init() -> void:
 	grid_block_material.set_shader_parameter("is_link", false)
 	grid_block_material.set_shader_parameter("is_target", true)
-	grid_block_material.set_shader_parameter("show_air_wall", false)
+	grid_block_material.set_shader_parameter("is_focus", true)
 
 
 func get_level_instance_list() -> Array[LevelInstance]:
@@ -28,15 +28,11 @@ func get_level_instance_list() -> Array[LevelInstance]:
 					rooms_node_child_child.level_area_cfg = rooms_node_child.cfg
 					rooms_node_child_child.set_level_range_visible(false)
 					level_instance_list.append(rooms_node_child_child)
-					rooms_node_child_child.init_character_spots(level_character)
+					rooms_node_child_child.init()
 
 	return level_instance_list
 
 
-func set_level_loading_rate(rate: float) -> void:
-	grid_block_material.set_shader_parameter("focus_rate", rate)
-
-
 func get_born_pos() -> Vector3:
 	if not born_pos:
 		var born_pos_node: Node3D = %BornPos as Node3D

script/level/level_instance.gd

@@ -10,16 +10,20 @@ class_name LevelInstance
 		_on_size_change()
 
 @export var is_force_battle: bool
-
 @export var enemy_nums: Array[LevelEnemy]
 
 @onready var grid_block_material: Material = load("res://render/material/level_grid_block.tres") as Material
 
-var level_area_cfg: LevelAreaCfg #运行时设置
-var character_spots: Array[ChacacterSpot] #运行时设置
-var character_born_spots: Array[ChacacterBornSpot] #运行时设置
-var level_active_spots: Array[LevelActiveSpot] #运行时设置
-var enemy_cfgs: Array[CharacterCfg] #运行时设置
+#character
+var level_area_cfg: LevelAreaCfg
+var character_spots: Array[ChacacterSpot]
+var character_born_spots: Array[ChacacterBornSpot]
+var level_active_spots: Array[LevelActiveSpot]
+var enemy_cfgs: Array[CharacterCfg]
+#main
+var mark_white_list: Array[Vector3i]
+var mark_black_list: Array[Vector3i]
+var grid_main_cache_cells: Array[GridMainCacheCellData]
 
 
 class ChacacterSpot:
@@ -37,6 +41,12 @@ class LevelActiveSpot:
 	var scene: PackedScene
 
 
+class GridMainCacheCellData:
+	var pos: Vector3i
+	var id: int
+	var orientation: int
+
+
 func _on_size_change() -> void:
 	var level_range: CSGBox3D = $LevelRange as CSGBox3D
 	var size_basic: Vector3   = Setting.size_basic
@@ -44,7 +54,6 @@ func _on_size_change() -> void:
 	level_range.position = level_range.size / 2
 
 
-
 func get_level_size() -> Vector2:
 	var level_range: CSGBox3D = $LevelRange as CSGBox3D
 	var level_size: Vector3   = level_range.size
@@ -61,7 +70,22 @@ func set_level_range_visible(value: bool) -> void:
 	level_range.visible = value
 
 
-func init_character_spots(level_character: GridMap) -> void:
+func init() -> void:
+	init_level_character()
+	init_level_main()
+
+
+func set_focus() -> void:
+	var level_range: CSGBox3D = $LevelRange as CSGBox3D
+	var level_size: Vector3   = level_range.size
+	var focus_min: Vector3    = get_global_position() + Vector3(0.640001, 0.640001, 0.640001)
+	var focus_max: Vector3    = get_global_position() + level_size - Vector3(0.640001, 0.639999, 0.639999)
+	grid_block_material.set_shader_parameter("focus_min", focus_min)
+	grid_block_material.set_shader_parameter("focus_max", focus_max)
+
+
+func init_level_character() -> void:
+	var level_character: GridMap    = %LevelGridCharacter as GridMap
 	character_spots = []
 	character_born_spots = []
 	level_active_spots = []
@@ -69,10 +93,14 @@ func init_character_spots(level_character: GridMap) -> void:
 	var id_min: Vector3i            = Util.get_level_grid_pos(pos_min())
 	var id_max: Vector3i            = Util.get_level_grid_pos(pos_max())
 	var mesh_library: MeshLibrary   = level_character.get_mesh_library()
-	for x in range(id_min.x, id_max.x):
-		for y in range(id_min.y, id_max.y):
-			for z in range(id_min.z, id_max.z):
-				var pos: Vector3i      = Vector3i(x, y, z)
+	var used_cells: Array[Vector3i] = level_character.get_used_cells()
+	for pos in used_cells:
+		if pos.x < id_min.x or pos.x > id_max.x:
+			continue
+		if pos.y < id_min.y or pos.y > id_max.y:
+			continue
+		if pos.z < id_min.z or pos.z > id_max.z:
+			continue
 		var float_pos: Vector3 = Util.get_level_float_pos(pos) + Vector3(0.32, 0, 0.32)
 		var item_id: int       = level_character.get_cell_item(pos)
 		if item_id == GridMap.INVALID_CELL_ITEM:
@@ -106,6 +134,74 @@ func init_character_spots(level_character: GridMap) -> void:
 			enemy_cfgs.append(enemy_num.cfg)
 
 
+func init_level_main() -> void:
+	var level_main: GridMap = %LevelGridMain as GridMap
+	var id_min: Vector3i    = Util.get_level_grid_pos2(outter_pos_min())
+	var id_max: Vector3i    = Util.get_level_grid_pos2(outter_pos_max())
+	print(id_min, id_max)
+	# 正前面
+	for x in range(id_min.x, id_max.x):
+		for y in range(id_min.y, id_max.y):
+			var pos: Vector3i = Vector3i(x, id_max.z, y)
+			add_grid_main_cache_cell(level_main, pos)
+	# 底面黑块
+	for x in range(id_min.x, id_max.x):
+		for z in range(id_min.z, id_max.z):
+			var pos: Vector3i = Vector3i(x, id_min.y, z)
+			var id: int       = level_main.get_cell_item(pos)
+			if not(id == GridMap.INVALID_CELL_ITEM or z == id_max.z):
+				continue
+			mark_black_list.append(pos)
+	# 底面黑块延申空气墙
+	for mark_black in mark_black_list:
+		for y in range(id_min.y, id_max.y -1):
+			var pos: Vector3i = Vector3i(mark_black.x, y, mark_black.z)
+			add_grid_main_cache_cell(level_main, pos)
+			mark_white_list.append(pos)
+	# 顶面
+	for x in range(id_min.x, id_max.x):
+		for z in range(id_min.z, id_max.z):
+			var pos: Vector3i = Vector3i(x, id_max.y, z)
+			add_grid_main_cache_cell(level_main, pos)
+			var pos_down: Vector3i = Vector3i(x, id_max.y - 1, z)
+			if level_main.get_cell_item(pos_down) == GridMap.INVALID_CELL_ITEM:
+				mark_white_list.append(pos)
+			else:
+				mark_black_list.append(pos)
+
+
+func add_grid_main_cache_cell(level_main: GridMap, pos: Vector3i) -> void:
+	var id: int = level_main.get_cell_item(pos)
+	if id == GridMap.INVALID_CELL_ITEM:
+		return
+	var cache_data = GridMainCacheCellData.new()
+	cache_data.pos = pos
+	cache_data.id  = id
+	cache_data.orientation= level_main.get_cell_item_orientation(pos)
+	grid_main_cache_cells.append(cache_data)
+
+
+func set_replace(is_active: bool)-> void:
+	print("set_replace")
+	#	print("mark_black_list", mark_black_list)
+	#	print("mark_white_list", mark_white_list)
+	var level_main: GridMap = %LevelGridMain as GridMap
+	if is_active:
+		for cache_data in grid_main_cache_cells:
+			level_main.set_cell_item(cache_data.pos, GridMap.INVALID_CELL_ITEM)
+		#		for pos in mark_white_list:
+		#			level_main.set_cell_item(pos, 0)
+		for pos in mark_black_list:
+			level_main.set_cell_item(pos, 1)
+	else:
+		for pos in mark_white_list:
+			level_main.set_cell_item(pos, GridMap.INVALID_CELL_ITEM)
+		for pos in mark_black_list:
+			level_main.set_cell_item(pos, GridMap.INVALID_CELL_ITEM)
+		for cache_data in grid_main_cache_cells:
+			level_main.set_cell_item(cache_data.pos, cache_data.id, cache_data.orientation)
+
+
 func get_character_spots() -> Array[ChacacterSpot]:
 	return character_spots
 
@@ -132,6 +228,14 @@ func pos_max() -> Vector3:
 	return get_global_position() + level_size
 
 
+func outter_pos_min() -> Vector3:
+	return pos_min() - Vector3(0.72, 0.72, 0.72)
+
+
+func outter_pos_max() -> Vector3:
+	return pos_max() - Vector3(0.72, 0.72, 0.72)
+
+
 func is_in_active_area(pos: Vector3) -> bool:
 	var active_pos_min: Vector3 = pos_min() + Vector3(0.96, 0, 0.96)
 	var active_pos_max: Vector3 = pos_max() - Vector3(0.96, 0, 0.96)

script/manager/level_manager.gd

@@ -13,6 +13,7 @@ var level_doors: Array[LevelDoor]
 var is_level_active: bool
 var enemy_count: int #由关卡生成的怪物数量
 var current_enmey: Array[int] #当前存活怪物id
+var replace_cache: Array[LevelInstance]
 
 
 func _ready():
@@ -43,7 +44,6 @@ func _process(delta) -> void:
 		level_loading_rate += delta *2
 		if level_loading_rate > 1:
 			level_loading_rate = 1
-		level.set_level_loading_rate(level_loading_rate)
 
 
 func get_born_pos() -> Vector3:
@@ -88,6 +88,7 @@ func set_player_position(pos: Vector3) -> void:
 			check_level_active(pos)
 			return
 
+	new_level_instance.set_focus()
 	cur_level_instance = new_level_instance
 	enter_level()
 
@@ -111,9 +112,15 @@ func enter_level() -> void:
 	level_character_born_spots = cur_level_instance.get_character_born_spots()
 	level_enemy_cfgs = cur_level_instance.get_enemy_cfgs()
 	enemy_count = 0
+	#更新cell
+	replace_cache.append(cur_level_instance)
+	if len(replace_cache) >= 3:
+		var replace_level_instance: LevelInstance = replace_cache.pop_at(0)
+		if replace_level_instance != cur_level_instance:
+			replace_level_instance.set_replace(false)
+	cur_level_instance.set_replace(true)
 
 	level_loading_rate = 1-level_loading_rate
-	level.set_level_loading_rate(level_loading_rate)
 	SignalManager.level_size_change.emit(cur_level_instance.get_level_size())
 	SignalManager.level_pos_change.emit(cur_level_instance.get_level_pos())
 
@@ -157,7 +164,7 @@ func enemy_born(count: int) -> bool:
 	count = min(count, count_max - enemy_count)
 	if count == 0:
 		return false
-	var count_start = enemy_count
+	var count_start: int = enemy_count
 	for i in count:
 		var cfg_index: int                                  = count_start + i
 		var cfg: CharacterCfg                               = level_enemy_cfgs[cfg_index]