finally an almost working camera model!

Main.tscn

@@ -29,8 +29,8 @@ extents = Vector2( 160, 90 )
 
 [node name="ViewportContainer" type="ViewportContainer" parent="."]
 material = SubResource( 3 )
-margin_right = 320.0
+margin_right = 322.0
-margin_bottom = 180.0
+margin_bottom = 182.0
 rect_scale = Vector2( 2, 2 )
 
 [node name="Viewport" type="Viewport" parent="ViewportContainer"]
@@ -54,10 +54,10 @@ position = Vector2( 112, 56 )
 position = Vector2( 160, 90 )
 collision_layer = 0
 collision_mask = 256
+collision/safe_margin = 0.25
 script = ExtResource( 5 )
 
 [node name="CollisionShape2D" type="CollisionShape2D" parent="ViewportContainer/Viewport/KinematicBody2D"]
-visible = false
 shape = SubResource( 1 )
 
 [node name="Camera2D" type="Camera2D" parent="ViewportContainer/Viewport"]

project.godot

@@ -293,4 +293,6 @@ common/physics_interpolation=true
 [rendering]
 
 quality/driver/driver_name="GLES2"
+2d/snapping/use_gpu_pixel_snap=true
 vram_compression/import_etc=true
+batching/precision/uv_contract=true

src/camera_control.gd

@@ -13,18 +13,40 @@ func _ready():
 	pass # Replace with function body.
 
 var flip_tracker = 0.0
+var stuck_check: bool
 func _physics_process(delta):
 	var pos = global_position
 	#pos = pos.move_toward(PlayerInfo.player_position, delta)
-	pos = lerp(pos, PlayerInfo.player_position, delta )
+	#pos = lerp(pos, PlayerInfo.player_position, delta )
-	var dir_to = pos.direction_to(PlayerInfo.player_position)
+	var dir_to = Vector2(0,0)
 
-#	UiManager.debug_text = ("PP: " + str(PlayerInfo.player_position.snapped(Vector2(0.01,0.01))) + 
+	# Calculate how far the player is from object
-#		"\nKB: " + str(global_position.snapped(Vector2(0.01,0.01))) + 
+	var diff_to = (PlayerInfo.player_position - pos)
-#		"\nCP: " + str (dir_to)
+	var dist_to = (PlayerInfo.player_position - pos).length()
+	
+	# Determine the chase direction of player is past the threshold
+	# Try to prevent bounce
+	if (is_on_wall() or is_on_floor() or is_on_ceiling()) and abs(diff_to.x) > 10:
+		dir_to = pos.direction_to(PlayerInfo.player_position)
+	elif !(is_on_wall() or is_on_floor() or is_on_ceiling()) and abs(diff_to.y) > 10:
+		dir_to = pos.direction_to(PlayerInfo.player_position)
+
+	
+#	UiManager.debug_text = ( UiManager.debug_text + 
+#		# str(PlayerInfo.player_position.snapped(Vector2(0.01,0.01))) + 
+#		"\n" + str(is_on_ceiling()) + str(is_on_floor()) + str(is_on_wall()) +
+#		"\nPP: {0}, {1}".format({"0":"%7.2f" % PlayerInfo.player_position.x, "1":"%7.2f" % PlayerInfo.player_position.y}) +  
+#		#"\nKB: " + str(global_position.snapped(Vector2(0.01,0.01))) + 
+#		"\nKB: {0}, {1}".format({"0":"%7.2f" % global_position.x, "1":"%7.2f" % global_position.y}) +  
+#		"\nDir to: {0}, {1}".format({"0":"%7.2f" % dir_to.x, "1":"%7.2f" % dir_to.y}) +  
+#		"\nPoint to: {0}, {1}".format({"0":"%7.2f" % diff_to.x, "1":"%7.2f" % diff_to.y})  
+#		#"\nDT: %7.2f" % dist_to 
 #	) 
 
-	move_and_slide(dir_to * 90.0 )
+# "Hi, {0} v{version}".format({0:"Godette", "version":"%0.2f" % 3.114})
+#"Hi, {0} v{1}".format(["Godette", "3.0"], "{_}")
+
+	move_and_slide(dir_to * 180.0 )
 	
 #	flip_tracker += delta
 #	if flip_tracker < 10:

src/game_camera.gd

@@ -10,31 +10,67 @@ onready var window_scale :float = (OS.window_size / game_size).x
 
 onready var actual_cam_pos := global_position
 
+export var acceleration := 2
+export var deceleration := 800.0
+export var max_speed := 60.0
+export var snap_unit := 10
+
 export var tracking_node_path :NodePath
 var _tracking_node :KinematicBody2D
 
 func _ready():
 	_tracking_node = get_node(tracking_node_path)
 
+var velocity :float = 0
+var tracking_pos := Vector2(0,0)
 # Called every frame. 'delta' is the elapsed time since the previous frame.
 func _process(delta):
 	#var tracking_pos = PlayerInfo.player_position
 #	var tracking_pos = lerp(global_position, _tracking_node.global_position , 0.7)
-	var tracking_pos =  _tracking_node.global_position.round()
+	#var tracking_pos =  _tracking_node.global_position.round()
+	var tp =  _tracking_node.global_position.floor()
+
+	var snapped_target_pos = Vector2(
+		round(tp.x / snap_unit) * snap_unit,
+		round(tp.y / snap_unit) * snap_unit
+	)
+
+#	if tracking_pos.distance_to(tp) >= 4: # tile width? 
+#		tracking_pos = tp.snapped(Vector2(2,2))
+	tracking_pos = snapped_target_pos
 	
 #	actual_cam_pos = lerp(actual_cam_pos, tracking_pos, delta * 5)
-	actual_cam_pos = lerp(actual_cam_pos, tracking_pos, delta * 5)
+	#actual_cam_pos = lerp(actual_cam_pos, tracking_pos, .2)
+	var distance_to := global_position.distance_to(tracking_pos)
+	
+	if distance_to < snap_unit:
+		velocity = 1 
+	else:
+		velocity += delta * distance_to
+
+
+	# Clamp to max speed
+	if velocity > max_speed:
+		velocity = max_speed
+
+	actual_cam_pos = actual_cam_pos.move_toward(tracking_pos, velocity)
+	#actual_cam_pos = global_position
+	#actual_cam_pos = tracking_pos.floor()
 	#position = actual_cam_pos
-	var cam_subpixel_pos = actual_cam_pos.round() - actual_cam_pos
+	#var cam_subpixel_pos = actual_cam_pos.round() - actual_cam_pos
+	var cam_subpixel_pos :Vector2 = global_position - tracking_pos
+	#cam_subpixel_pos = cam_subpixel_pos.snapped(Vector2(0.2,0.2))
+	global_position = actual_cam_pos.floor()
 	
-#	LevelInfo.viewport_container.material.set_shader_param("cam_offset", cam_subpixel_pos )
+	#LevelInfo.viewport_container.material.set_shader_param("cam_offset", cam_subpixel_pos )
 
-	global_position = actual_cam_pos.round()
+	#global_position = actual_cam_pos.round()
 
 
 	UiManager.debug_text = ("SP: " + str(cam_subpixel_pos.snapped(Vector2(0.01,0.01))) + 
-		"\nCP: " + str (position.snapped(Vector2(0.01,0.01))) +
+		"\nCP: " + str (global_position.snapped(Vector2(0.1,0.1))) +
-		"\nTP: " + str(tracking_pos.snapped(Vector2(0.01,0.01))) 
+		"\nTP: " + str(tracking_pos) + 
+		"\nDT: " + str(distance_to) 
 	)