next commit

1 files changed, 75 insertions, 12 deletions

diff --git a/BuilderElement.gd b/BuilderElement.gd
index 6a82c0a..5f1e3ca 100644
--- a/BuilderElement.gd
+++ b/BuilderElement.gd
@@ -6,6 +6,10 @@ extends Node2D
 
 var collision_shape: Shape2D
 
+var previous_position
+
+var collision_areas: Array[Area2D] = []
+
 
 func _ready():
 	var element_sprite: Sprite2D = element.get_node("Sprite2D")
@@ -16,35 +20,94 @@ func _ready():
 	$Sprite2D.position = element_sprite.position
 	
 	var element_collision_shape = element.get_node("CollisionShape2D").duplicate() as CollisionShape2D
-	$Area2D.add_child(element_collision_shape)
+	#$Area2D.add_child(element_collision_shape)
 	collision_shape = element_collision_shape.shape
+	
+	var snapped_size = collision_shape.size.snapped(Game.map.tile_set.tile_size)
+	for x in (snapped_size.x / Game.map.tile_set.tile_size.x):
+		for y in (snapped_size.y / Game.map.tile_set.tile_size.y):
+			var collision_visibility_area_scene = preload("res://CollisionVisibilityArea.tscn")
+			var collision_visibility_area = collision_visibility_area_scene.instantiate()
+			collision_visibility_area.position = Vector2(
+				x * Game.map.tile_set.tile_size.x,
+				y * Game.map.tile_set.tile_size.y
+			)
+			collision_visibility_area.set_collision_layer_value(3, true)
+			collision_visibility_area.set_collision_mask_value(1, true)
+			collision_visibility_area.set_collision_mask_value(2, true)
+			collision_visibility_area.set_collision_mask_value(3, true)
+			collision_visibility_area.colliding_color = Color(1, 0, 0, 0.5)
+			collision_visibility_area.not_colliding_color = Color(0, 1, 0, 0.25)
+			
+			var shape = RectangleShape2D.new()
+			shape.size = Vector2(Game.map.tile_set.tile_size - Vector2i(1, 1))
+			var cshape = CollisionShape2D.new()
+			cshape.shape = shape
+			cshape.position = Game.map.tile_set.tile_size / 2
+			
+			collision_visibility_area.add_child(cshape)
+			add_child(collision_visibility_area)
+			
+			collision_areas.append(collision_visibility_area)
 
 
 func _draw():
 	draw_circle(
-		Vector2.ZERO,
+		Game.map.tile_set.tile_size,
 		8 + element.attack_range,
 		Color(1, 1, 1, 0.75),
 		false,
 		1.0
 	)
 	
-	if not can_build():
-		if collision_shape is RectangleShape2D:
-			draw_rect(Rect2((collision_shape.size / 2) * -1, collision_shape.size), Color(1, 0, 0, 0.75))
+	#if collision_shape is RectangleShape2D:
+		#var nodes = $Area2D.get_overlapping_nodes()
+		#for key in nodes:
+			#var node = nodes[key]
+			#if node.collision_points.size() == 4:
+				#var rect_size = (node.collision_points[0] - node.collision_points[1] +
+								#node.collision_points[2] - node.collision_points[0]).snapped(Game.map.tile_set.tile_size)
+				#var relative_position = global_position - node.body.global_position.snapped(Game.map.tile_set.tile_size)
+				#if relative_position.x > 0:
+					#relative_position.x = 0
+				#if relative_position.y > 0:
+					#relative_position.y = 0
+				#if rect_size.x == 0:
+					#rect_size.x = 16
+				#if rect_size.y == 0:
+					#rect_size.y = 16
+				#draw_rect(
+					#Rect2(
+						#abs(relative_position),
+						#abs(rect_size)
+					#),
+						#Color(0, 0, 1)
+				#)
+		#draw_rect(
+			#Rect2(
+				#Vector2.ZERO,
+				#collision_shape.size
+			#),
+			#Color(1, 0, 0, 0.5) if not can_build() else Color(0, 1, 0, 0.25)
+		#)
 
 
 func _process(_delta):
-	#global_position = get_global_mouse_position().snapped(Game.map.tile_set.tile_size / 2)
-	global_position = get_global_mouse_position().snapped(Game.map.tile_set.tile_size)
+	previous_position = global_position
+	global_position = get_global_mouse_position().snapped(Game.map.tile_set.tile_size) - Vector2(16,16)
+	#global_position = Game.map.map_to_local(Game.map.local_to_map(get_global_mouse_position())) - Vector2(16,16)
+	
+	if global_position != previous_position:
+		queue_redraw()
 
 
 func can_build():
-	if $Area2D.get_overlapping_areas().size() > 0:
-		return false
-	
-	if $Area2D.get_overlapping_bodies().size() > 0:
-		return false
+	for area in collision_areas:
+		if area.get_overlapping_areas().size() > 0:
+			return false
+		
+		if area.get_overlapping_bodies().size() > 0:
+			return false
 	
 	return true