Code cleanup

3d/kinematic_character/cubio.gd

@@ -13,46 +13,45 @@ const MAX_SLOPE_ANGLE = 30
 
 func _physics_process(delta):
 	var dir = Vector3() # Where does the player intend to walk to
-	var cam_xform = get_node("target/camera").get_global_transform()
+	var cam_xform = $target/camera.get_global_transform()
 	
-	if (Input.is_action_pressed("move_forward")):
+	if Input.is_action_pressed("move_forward"):
 		dir += -cam_xform.basis[2]
-	if (Input.is_action_pressed("move_backwards")):
+	if Input.is_action_pressed("move_backwards"):
 		dir += cam_xform.basis[2]
-	if (Input.is_action_pressed("move_left")):
+	if Input.is_action_pressed("move_left"):
 		dir += -cam_xform.basis[0]
-	if (Input.is_action_pressed("move_right")):
+	if Input.is_action_pressed("move_right"):
 		dir += cam_xform.basis[0]
 	
 	dir.y = 0
 	dir = dir.normalized()
 	
-	vel.y += delta*g
+	vel.y += delta * g
 	
 	var hvel = vel
 	hvel.y = 0
 	
-	var target = dir*MAX_SPEED
+	var target = dir * MAX_SPEED
 	var accel
-	if (dir.dot(hvel) > 0):
+	if dir.dot(hvel) > 0:
 		accel = ACCEL
 	else:
 		accel = DEACCEL
 	
-	hvel = hvel.linear_interpolate(target, accel*delta)
+	hvel = hvel.linear_interpolate(target, accel * delta)
 	
 	vel.x = hvel.x
 	vel.z = hvel.z
 	
-	vel = move_and_slide(vel,Vector3(0,1,0))
+	vel = move_and_slide(vel, Vector3(0,1,0))
 	
-	if (is_on_floor() and Input.is_action_pressed("jump")):
+	if is_on_floor() and Input.is_action_pressed("jump"):
 		vel.y = JUMP_SPEED
 	
 	var crid = get_node("../elevator1").get_rid()
 
 
-
 func _on_tcube_body_enter(body):
-	if (body == self):
+	if body == self:
 		get_node("../ty").show()

3d/kinematic_character/follow_camera.gd

@@ -22,15 +22,15 @@ func _physics_process(dt):
 	# Regular delta follow
 	
 	# Check ranges
-	if (delta.length() < min_distance):
-		delta = delta.normalized()*min_distance
-	elif (delta.length() > max_distance):
-		delta = delta.normalized()*max_distance
+	if delta.length() < min_distance:
+		delta = delta.normalized() * min_distance
+	elif delta.length() > max_distance:
+		delta = delta.normalized() * max_distance
 	
 	# Check upper and lower height
-	if (delta.y > max_height):
+	if delta.y > max_height:
 		delta.y = max_height
-	if (delta.y < min_height):
+	if delta.y < min_height:
 		delta.y = min_height
 	
 	pos = target + delta
@@ -39,15 +39,15 @@ func _physics_process(dt):
 	
 	# Turn a little up or down
 	var t = transform
-	t.basis = Basis(t.basis[0], deg2rad(angle_v_adjust))*t.basis
+	t.basis = Basis(t.basis[0], deg2rad(angle_v_adjust)) * t.basis
 	transform = t
 
 
 func _ready():
 	# Find collision exceptions for ray
 	var node = self
-	while(node):
-		if (node is RigidBody):
+	while node:
+		if node is RigidBody:
 			collision_exception.append(node.get_rid())
 			break
 		else:

3d/material_testers/tester.gd

@@ -27,26 +27,24 @@ func _ready():
 
 func _unhandled_input(ev):
 
-	if (ev is InputEventMouseButton and ev.button_index == BUTTON_WHEEL_UP):
-		if (zoom<ZOOM_MAX):
-			zoom+=ZOOM_SPEED
+	if ev is InputEventMouseButton and ev.button_index == BUTTON_WHEEL_UP:
+		if zoom < ZOOM_MAX:
+			zoom += ZOOM_SPEED
 			get_node("camera/base/rotation/camera").translation.z = -zoom
 
-	if (ev is InputEventMouseButton and ev.button_index == BUTTON_WHEEL_DOWN):
-		if (zoom>0):
-			zoom-=ZOOM_SPEED
+	if ev is InputEventMouseButton and ev.button_index == BUTTON_WHEEL_DOWN:
+		if zoom > 0:
+			zoom -= ZOOM_SPEED
 			get_node("camera/base/rotation/camera").translation.z = -zoom
 	
-	if (ev is InputEventMouseMotion and ev.button_mask & BUTTON_MASK_LEFT):
+	if ev is InputEventMouseMotion and ev.button_mask & BUTTON_MASK_LEFT:
 		rot_y += ev.relative.x * ROT_SPEED	
 		rot_x += ev.relative.y * ROT_SPEED
-		rot_y = clamp(rot_y,-180,180)
-		rot_x = clamp(rot_x,0,150)
+		rot_y = clamp(rot_y, -180, 180)
+		rot_x = clamp(rot_x, 0, 150)
 		var t = Transform()
-		t = t.rotated(Vector3(0,0,1),rot_x * PI / 180.0)
-		t = t.rotated(Vector3(0,1,0),-rot_y * PI / 180.0)
-		
-		
+		t = t.rotated(Vector3(0, 0, 1), rot_x * PI / 180.0)
+		t = t.rotated(Vector3(0, 1, 0), -rot_y * PI / 180.0)
 		get_node("camera/base").transform.basis = t.basis
 		
 	
@@ -58,27 +56,24 @@ func _process(delta):
 	var from_p = from_xform.origin
 	var from_r = Quat(from_xform.basis)
 	
-	p = from_p.linear_interpolate(p,INTERP_SPEED*delta)
-	r = from_r.slerp(r,INTERP_SPEED*delta)
+	p = from_p.linear_interpolate(p, INTERP_SPEED * delta)
+	r = from_r.slerp(r, INTERP_SPEED * delta)
 	
 	var m = Transform(r)
-	m.origin=p
+	m.origin = p
 	
-	get_node("camera").transform=m
+	get_node("camera").transform = m
 	get_node("ui/label").text = get_node("testers").get_child(tester_index).get_name()
 			
 	
-
 func _on_prev_pressed():
-	if (tester_index > 0):
-		tester_index-=1
-	
-	pass # replace with function body
+	if tester_index > 0:
+		tester_index -= 1
 
 
 func _on_next_pressed():
-	if (tester_index < get_node("testers").get_child_count() -1):
-		tester_index+=1
+	if tester_index < get_node("testers").get_child_count() -1:
+		tester_index += 1
 
 
 func _on_bg_item_selected( ID ):

3d/navmesh/navmesh.gd

@@ -15,15 +15,15 @@ var draw_path = true
 
 
 func _process(delta):
-	if (path.size() > 1):
-		var to_walk = delta*SPEED
+	if path.size() > 1:
+		var to_walk = delta * SPEED
 		var to_watch = Vector3(0, 1, 0)
-		while(to_walk > 0 and path.size() >= 2):
+		while to_walk > 0 and path.size() >= 2:
 			var pfrom = path[path.size() - 1]
 			var pto = path[path.size() - 2]
 			to_watch = (pto - pfrom).normalized()
 			var d = pfrom.distance_to(pto)
-			if (d <= to_walk):
+			if d <= to_walk:
 				path.remove(path.size() - 1)
 				to_walk -= d
 			else:
@@ -36,10 +36,10 @@ func _process(delta):
 		
 		var t = Transform()
 		t.origin = atpos
-		t=t.looking_at(atpos + atdir, Vector3(0, 1, 0))
+		t = t.looking_at(atpos + atdir, Vector3(0, 1, 0))
 		get_node("robot_base").set_transform(t)
 		
-		if (path.size() < 2):
+		if path.size() < 2:
 			path = []
 			set_process(false)
 	else:
@@ -52,7 +52,7 @@ func _update_path():
 	path.invert()
 	set_process(true)
 
-	if (draw_path):
+	if draw_path:
 		var im = get_node("draw")
 		im.set_material_override(m)
 		im.clear()
@@ -67,8 +67,8 @@ func _update_path():
 
 
 func _input(event):
-#	if (event extends InputEventMouseButton and event.button_index == BUTTON_LEFT and event.pressed):
-	if (event.is_class("InputEventMouseButton") and event.button_index == BUTTON_LEFT and event.pressed):
+#	if event extends InputEventMouseButton and event.button_index == BUTTON_LEFT and event.pressed:
+	if event is InputEventMouseButton and event.button_index == BUTTON_LEFT and event.pressed:
 		var from = get_node("cambase/Camera").project_ray_origin(event.position)
 		var to = from + get_node("cambase/Camera").project_ray_normal(event.position)*100
 		var p = get_closest_point_to_segment(from, to)
@@ -78,9 +78,9 @@ func _input(event):
 
 		_update_path()
 	
-	if (event.is_class("InputEventMouseMotion")):
-		if (event.button_mask&(BUTTON_MASK_MIDDLE+BUTTON_MASK_RIGHT)):
-			camrot += event.relative.x*0.005
+	if event is InputEventMouseMotion:
+		if event.button_mask&(BUTTON_MASK_MIDDLE+BUTTON_MASK_RIGHT):
+			camrot += event.relative.x * 0.005
 			get_node("cambase").set_rotation(Vector3(0, camrot, 0))
 			print("camrot ", camrot)
 

3d/platformer/coin.gd

@@ -6,6 +6,6 @@ var taken = false
 
 
 func _on_coin_body_enter(body):
-	if (not taken and body is preload("res://player.gd")):
+	if not taken and body is preload("res://player.gd"):
 		get_node("anim").play("take")
 		taken = true

3d/platformer/enemy.gd

@@ -20,10 +20,10 @@ func _integrate_forces(state):
 	var lv = state.get_linear_velocity()
 	var g = state.get_total_gravity()
 
-	lv += g*delta # Apply gravity
+	lv += g * delta # Apply gravity
 	var up = -g.normalized()
 	
-	if (dying):
+	if dying:
 		state.set_linear_velocity(lv)
 		return
 	
@@ -31,12 +31,12 @@ func _integrate_forces(state):
 		var cc = state.get_contact_collider_object(i)
 		var dp = state.get_contact_local_normal(i)
 		
-		if (cc):
-			if (cc is preload("res://bullet.gd") and not cc.disabled):
+		if cc:
+			if cc is preload("res://bullet.gd") and not cc.disabled:
 				set_mode(MODE_RIGID)
 				dying = true
 				#lv = s.get_contact_local_normal(i)*400
-				state.set_angular_velocity(-dp.cross(up).normalized()*33.0)
+				state.set_angular_velocity(-dp.cross(up).normalized() * 33.0)
 				get_node("AnimationPlayer").play("impact")
 				get_node("AnimationPlayer").queue("explode")
 				set_friction(1)
@@ -52,23 +52,23 @@ func _integrate_forces(state):
 	var dir = get_node("Armature").get_transform().basis[2].normalized()
 	var deaccel_dir = dir
 	
-	if (advance):
-		if (dir.dot(lv) < max_speed):
-			lv += dir*accel*delta
+	if advance:
+		if dir.dot(lv) < max_speed:
+			lv += dir * accel * delta
 		deaccel_dir = dir.cross(g).normalized()
 	else:
-		if (prev_advance):
+		if prev_advance:
 			rot_dir = 1 # randf()*2.0 - 1.0
 		
-		dir = Basis(up, rot_dir*rot_speed*delta).xform(dir)
+		dir = Basis(up, rot_dir * rot_speed * delta).xform(dir)
 		get_node("Armature").set_transform(Transform().looking_at(-dir, up))
 	
 	var dspeed = deaccel_dir.dot(lv)
-	dspeed -= deaccel*delta
-	if (dspeed < 0):
+	dspeed -= deaccel * delta
+	if dspeed < 0:
 		dspeed = 0
 	
-	lv = lv - deaccel_dir*deaccel_dir.dot(lv) + deaccel_dir*dspeed
+	lv = lv - deaccel_dir * deaccel_dir.dot(lv) + deaccel_dir * dspeed
 	
 	state.set_linear_velocity(lv)
 	prev_advance = advance

3d/platformer/follow_camera.gd

@@ -21,15 +21,15 @@ func _physics_process(dt):
 	# Regular delta follow
 	
 	# Check ranges
-	if (delta.length() < min_distance):
-		delta = delta.normalized()*min_distance
-	elif (delta.length() > max_distance):
-		delta = delta.normalized()*max_distance
+	if  delta.length() < min_distance:
+		delta = delta.normalized() * min_distance
+	elif  delta.length() > max_distance:
+		delta = delta.normalized() * max_distance
 	
 	# Check upper and lower height
-	if (delta.y > max_height):
+	if delta.y > max_height:
 		delta.y = max_height
-	if (delta.y < min_height):
+	if delta.y < min_height:
 		delta.y = min_height
 		
 	# Check autoturn
@@ -39,22 +39,22 @@ func _physics_process(dt):
 	var col = ds.intersect_ray(target, target + delta, collision_exception)
 	var col_right = ds.intersect_ray(target, target + Basis(up, deg2rad(-autoturn_ray_aperture)).xform(delta), collision_exception)
 	
-	if (!col.empty()):
+	if !col.empty():
 		# If main ray was occluded, get camera closer, this is the worst case scenario
 		delta = col.position - target	
-	elif (!col_left.empty() and col_right.empty()):
+	elif !col_left.empty() and col_right.empty():
 		# If only left ray is occluded, turn the camera around to the right
-		delta = Basis(up, deg2rad(-dt*autoturn_speed)).xform(delta)
-	elif (col_left.empty() and !col_right.empty()):
+		delta = Basis(up, deg2rad(-dt * autoturn_speed)).xform(delta)
+	elif col_left.empty() and !col_right.empty():
 		# If only right ray is occluded, turn the camera around to the left
-		delta = Basis(up, deg2rad(dt*autoturn_speed)).xform(delta)
+		delta = Basis(up, deg2rad(dt  *autoturn_speed)).xform(delta)
 	else:
 		# Do nothing otherwise, left and right are occluded but center is not, so do not autoturn
 		pass
 	
 	# Apply lookat
-	if (delta == Vector3()):
-		delta = (pos - target).normalized()*0.0001
+	if delta == Vector3():
+		delta = (pos - target).normalized() * 0.0001
 
 	pos = target + delta
 	
@@ -62,15 +62,15 @@ func _physics_process(dt):
 	
 	# Turn a little up or down
 	var t = get_transform()
-	t.basis = Basis(t.basis[0], deg2rad(angle_v_adjust))*t.basis
+	t.basis = Basis(t.basis[0], deg2rad(angle_v_adjust)) * t.basis
 	set_transform(t)
 
 
 func _ready():
 	# Find collision exceptions for ray
 	var node = self
-	while(node):
-		if (node is RigidBody):
+	while node:
+		if node is RigidBody:
 			collision_exception.append(node.get_rid())
 			break
 		else:

3d/platformer/player.gd

@@ -40,144 +40,141 @@ func adjust_facing(p_facing, p_target, p_step, p_adjust_rate, current_gn):
 	
 	var ang = atan2(y,x)
 	
-	if (abs(ang) < 0.001): # Too small
+	if abs(ang) < 0.001: # Too small
 		return p_facing
 	
 	var s = sign(ang)
-	ang = ang*s
-	var turn = ang*p_adjust_rate*p_step
+	ang = ang * s
+	var turn = ang * p_adjust_rate * p_step
 	var a
-	if (ang < turn):
+	if ang < turn:
 		a = ang
 	else:
 		a = turn
-	ang = (ang - a)*s
+	ang = (ang - a) * s
 	
-	return (n*cos(ang) + t*sin(ang))*p_facing.length()
+	return (n * cos(ang) + t * sin(ang)) * p_facing.length()
 
 
 func _physics_process(delta):
 	
 	var lv = linear_velocity
-	var g = Vector3(0,-9.8,0)
+	var g = Vector3(0, -9.8, 0)
 
 #	var d = 1.0 - delta*state.get_total_density()
 #	if (d < 0):
 #		d = 0
-	lv += g*delta # Apply gravity
+	lv += g * delta # Apply gravity
 	
 	var anim = ANIM_FLOOR
 	
 	var up = -g.normalized() # (up is against gravity)
 	var vv = up.dot(lv) # Vertical velocity
-	var hv = lv - up*vv # Horizontal velocity
+	var hv = lv - up * vv # Horizontal velocity
 	
 	var hdir = hv.normalized() # Horizontal direction
 	var hspeed = hv.length() # Horizontal speed
 	
-
-	
 	var dir = Vector3() # Where does the player intend to walk to
 	var cam_xform = get_node("target/camera").get_global_transform()
 	
-	if (Input.is_action_pressed("move_forward")):
+	if Input.is_action_pressed("move_forward"):
 		dir += -cam_xform.basis[2]
-	if (Input.is_action_pressed("move_backwards")):
+	if Input.is_action_pressed("move_backwards"):
 		dir += cam_xform.basis[2]
-	if (Input.is_action_pressed("move_left")):
+	if Input.is_action_pressed("move_left"):
 		dir += -cam_xform.basis[0]
-	if (Input.is_action_pressed("move_right")):
+	if Input.is_action_pressed("move_right"):
 		dir += cam_xform.basis[0]
 	
 	var jump_attempt = Input.is_action_pressed("jump")
 	var shoot_attempt = Input.is_action_pressed("shoot")
 	
-	var target_dir = (dir - up*dir.dot(up)).normalized()
+	var target_dir = (dir - up * dir.dot(up)).normalized()
 	
-	if (is_on_floor()):
+	if is_on_floor():
 		var sharp_turn = hspeed > 0.1 and rad2deg(acos(target_dir.dot(hdir))) > sharp_turn_threshold
 		
-		if (dir.length() > 0.1 and !sharp_turn):
-			if (hspeed > 0.001):
+		if dir.length() > 0.1 and !sharp_turn:
+			if hspeed > 0.001:
 				#linear_dir = linear_h_velocity/linear_vel
 				#if (linear_vel > brake_velocity_limit and linear_dir.dot(ctarget_dir) < -cos(Math::deg2rad(brake_angular_limit)))
 				#	brake = true
 				#else
-				hdir = adjust_facing(hdir, target_dir, delta, 1.0/hspeed*turn_speed, up)
+				hdir = adjust_facing(hdir, target_dir, delta, 1.0 / hspeed * turn_speed, up)
 				facing_dir = hdir
 			else:
 				hdir = target_dir
 			
-			if (hspeed < max_speed):
-				hspeed += accel*delta
+			if hspeed < max_speed:
+				hspeed += accel * delta
 		else:
-			hspeed -= deaccel*delta
-			if (hspeed < 0):
+			hspeed -= deaccel * delta
+			if hspeed < 0:
 				hspeed = 0
 		
-		hv = hdir*hspeed
+		hv = hdir * hspeed
 		
 		var mesh_xform = get_node("Armature").get_transform()
 		var facing_mesh = -mesh_xform.basis[0].normalized()
-		facing_mesh = (facing_mesh - up*facing_mesh.dot(up)).normalized()
+		facing_mesh = (facing_mesh - up * facing_mesh.dot(up)).normalized()
 		
-		if (hspeed>0):
+		if hspeed>0:
 			facing_mesh = adjust_facing(facing_mesh, target_dir, delta, 1.0/hspeed*turn_speed, up)
 		var m3 = Basis(-facing_mesh, up, -facing_mesh.cross(up).normalized()).scaled(CHAR_SCALE)
 		
 		get_node("Armature").set_transform(Transform(m3, mesh_xform.origin))
 		
-		if (not jumping and jump_attempt):
+		if not jumping and jump_attempt:
 			vv = 7.0
 			jumping = true
 			get_node("sound_jump").play()
 	else:
-		if (vv > 0):
+		if vv > 0:
 			anim = ANIM_AIR_UP
 		else:
 			anim = ANIM_AIR_DOWN
 		
 		var hs
-		if (dir.length() > 0.1):
-			hv += target_dir*(accel*0.2)*delta
+		if dir.length() > 0.1:
+			hv += target_dir * (accel * 0.2) * delta
 			if (hv.length() > max_speed):
 				hv = hv.normalized()*max_speed
 		else:
-			if (air_idle_deaccel):
-				hspeed = hspeed - (deaccel*0.2)*delta
-				if (hspeed < 0):
+			if air_idle_deaccel:
+				hspeed = hspeed - (deaccel * 0.2) * delta
+				if hspeed < 0:
 					hspeed = 0
-				
-				hv = hdir*hspeed
+				hv = hdir * hspeed
 	
-	if (jumping and vv < 0):
+	if jumping and vv < 0:
 		jumping = false
 	
 	lv = hv + up*vv
 	
-	if (is_on_floor()):
+	if is_on_floor():
 		movement_dir = lv
 		
 	linear_velocity = move_and_slide(lv,-g.normalized())
 	
-	if (shoot_blend > 0):
-		shoot_blend -= delta*SHOOT_SCALE
+	if shoot_blend > 0:
+		shoot_blend -= delta * SHOOT_SCALE
 		if (shoot_blend < 0):
 			shoot_blend = 0
 	
-	if (shoot_attempt and not prev_shoot):
+	if shoot_attempt and not prev_shoot:
 		shoot_blend = SHOOT_TIME
 		var bullet = preload("res://bullet.scn").instance()
 		bullet.set_transform(get_node("Armature/bullet").get_global_transform().orthonormalized())
 		get_parent().add_child(bullet)
-		bullet.set_linear_velocity(get_node("Armature/bullet").get_global_transform().basis[2].normalized()*20)
+		bullet.set_linear_velocity(get_node("Armature/bullet").get_global_transform().basis[2].normalized() * 20)
 		bullet.add_collision_exception_with(self) # Add it to bullet
 		get_node("sound_shoot").play()
 	
 	prev_shoot = shoot_attempt
 	
-	if (is_on_floor()):
-		get_node("AnimationTreePlayer").blend2_node_set_amount("walk", hspeed/max_speed)
+	if is_on_floor():
+		get_node("AnimationTreePlayer").blend2_node_set_amount("walk", hspeed / max_speed)
 	
 	get_node("AnimationTreePlayer").transition_node_set_current("state", anim)
 	get_node("AnimationTreePlayer").blend2_node_set_amount("gun", min(shoot_blend, 1.0))

3d/truck_town/vehicle.gd

@@ -10,30 +10,30 @@ var steer_target = 0
 export var engine_force_value = 40
 
 func _physics_process(delta):
-	if (Input.is_action_pressed("ui_left")):
+	if Input.is_action_pressed("ui_left"):
 		steer_target = STEER_LIMIT
-	elif (Input.is_action_pressed("ui_right")):
+	elif Input.is_action_pressed("ui_right"):
 		steer_target = -STEER_LIMIT
 	else:
 		steer_target = 0
 	
-	if (Input.is_action_pressed("ui_up")):
+	if Input.is_action_pressed("ui_up"):
 		engine_force = engine_force_value
 	else:
 		engine_force = 0
 	
-	if (Input.is_action_pressed("ui_down")):
+	if Input.is_action_pressed("ui_down"):
 		brake = 1
 	else:
 		brake = 0.0
 	
-	if (steer_target < steer_angle):
-		steer_angle -= STEER_SPEED*delta
-		if (steer_target > steer_angle):
+	if steer_target < steer_angle:
+		steer_angle -= STEER_SPEED * delta
+		if steer_target > steer_angle:
 			steer_angle = steer_target
-	elif (steer_target > steer_angle):
-		steer_angle += STEER_SPEED*delta
-		if (steer_target < steer_angle):
+	elif steer_target > steer_angle:
+		steer_angle += STEER_SPEED * delta
+		if steer_target < steer_angle:
 			steer_angle = steer_target
 	
 	steering = steer_angle

misc/joypads/joypads.gd

@@ -29,11 +29,11 @@ func _physics_process(delta):
 		get_node("axes/axis_prog" + str(axis)).set_value(100*axis_value)
 		get_node("axes/axis_val" + str(axis)).set_text(str(axis_value))
 		# Show joypad direction indicators
-		if (axis <= JOY_ANALOG_RY):
-			if (abs(axis_value) < DEADZONE):
+		if axis <= JOY_ANALOG_RY:
+			if abs(axis_value) < DEADZONE:
 				get_node("diagram/axes/" + str(axis) + "+").hide()
 				get_node("diagram/axes/" + str(axis) + "-").hide()
-			elif (axis_value > 0):
+			elif axis_value > 0:
 				get_node("diagram/axes/" + str(axis) + "+").show()
 				get_node("diagram/axes/" + str(axis) + "-").hide()
 			else:
@@ -42,7 +42,7 @@ func _physics_process(delta):
 
 	# Loop through the buttons and highlight the ones that are pressed
 	for btn in range(JOY_BUTTON_0, JOY_BUTTON_MAX):
-		if (Input.is_joy_button_pressed(joy_num, btn)):
+		if Input.is_joy_button_pressed(joy_num, btn):
 			get_node("buttons/btn" + str(btn)).add_color_override("font_color", Color(1, 1, 1, 1))
 			get_node("diagram/buttons/" + str(btn)).show()
 		else:

misc/sensors/main.gd

@@ -19,7 +19,7 @@ func get_basis_for_arrow(p_vector):
 	
 	# get an arbitrary vector we can use to calculate our other two vectors
 	var v = Vector3(1.0, 0.0, 0.0)
-	if (abs(v.dot(rotate.y)) > 0.9):
+	if abs(v.dot(rotate.y)) > 0.9:
 		v = Vector3(0.0, 1.0, 0.0)
 	
 	# use our vector to get a vector perpendicular to our two vectors
@@ -82,7 +82,7 @@ func drift_correction(p_basis, p_grav):
 	var dot = p_basis.y.dot(real_up)
 	
 	# if our dot is 1.0 we're good
-	if (dot < 1.0):
+	if dot < 1.0:
 		# the cross between our two vectors gives us a vector perpendicular to our two vectors
 		var axis = p_basis.y.cross(real_up).normalized()
 		var correction = Basis(axis, acos(dot))
@@ -138,4 +138,3 @@ func _process(delta):
 	gyro_and_grav.transform.basis = drift_correction(new_basis, grav)
 	
 	
-

misc/threads/thread.gd

@@ -22,7 +22,7 @@ func _bg_load_done():
 
 
 func _on_load_pressed():
-	if (thread.is_active()):
+	if thread.is_active():
 		# Already working
 		return
 	print("START THREAD!")

misc/tween/main.gd

@@ -96,13 +96,13 @@ func reset_tween():
 		tween.interpolate_method(sprite, "set_modulate", get_node("colors/color_from/picker").get_pick_color(), get_node("colors/color_to/picker").get_pick_color(), 2, state.trans, state.eases)
 		tween.interpolate_property(sprite, "modulate", get_node("colors/color_to/picker").get_pick_color(), get_node("colors/color_from/picker").get_pick_color(), 2, state.trans, state.eases, 2)
 	else:
-		sprite.set_modulate(Color(1,1,1,1))
+		sprite.set_modulate(Color(1, 1, 1, 1))
 
 	if get_node("modes/scale").is_pressed():
 		tween.interpolate_method(sprite, "set_scale", Vector2(0.5, 0.5), Vector2(1.5, 1.5), 2, state.trans, state.eases)
 		tween.interpolate_property(sprite, "scale", Vector2(1.5, 1.5), Vector2(0.5, 0.5), 2, state.trans, state.eases, 2)
 	else:
-		sprite.set_scale(Vector2(1,1))
+		sprite.set_scale(Vector2(1, 1))
 
 	if get_node("modes/rotate").is_pressed():
 		tween.interpolate_method(sprite, "set_rotation_degrees", 0, 360, 2, state.trans, state.eases)
@@ -144,7 +144,7 @@ func _on_tween_step(object, key, elapsed, value):
 	var tween = get_node("tween")
 	var runtime = tween.get_runtime()
 
-	var ratio = 100*(elapsed/runtime)
+	var ratio = 100 * (elapsed / runtime)
 	timeline.set_value(ratio)
 
 
@@ -154,7 +154,7 @@ func _on_timeline_value_changed(value):
 
 	var tween = get_node("tween")
 	var runtime = tween.get_runtime()
-	tween.seek(runtime*value/100)
+	tween.seek(runtime * value / 100)
 
 
 func on_callback(arg):

misc/window_management/control.gd

@@ -8,21 +8,21 @@ onready var observer = $"../Observer"
 func _physics_process(delta):
 	var modetext = "Mode:\n"
 
-	if (OS.is_window_fullscreen()):
+	if OS.is_window_fullscreen():
 		modetext += "Fullscreen\n"
 	else:
 		modetext += "Windowed\n"
 
-	if (!OS.is_window_resizable()):
+	if !OS.is_window_resizable():
 		modetext += "FixedSize\n"
 
-	if (OS.is_window_minimized()):
+	if OS.is_window_minimized():
 		modetext += "Minimized\n"
 
-	if (OS.is_window_maximized()):
+	if OS.is_window_maximized():
 		modetext += "Maximized\n"
 
-	if (Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED):
+	if Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED:
 		modetext += "MouseGrab\n"
 		$Label_MouseModeCaptured_KeyInfo.show()
 	else:
@@ -38,7 +38,7 @@ func _physics_process(delta):
 	$Label_Screen0_Position.text = str("Screen0 Position:\n", OS.get_screen_position())
 	$Label_Screen0_DPI.text = str("Screen0 DPI:\n", OS.get_screen_dpi())
 
-	if (OS.get_screen_count() > 1):
+	if OS.get_screen_count() > 1:
 		$Button_Screen0.show()
 		$Button_Screen1.show()
 		$Label_Screen1_Resolution.show()
@@ -65,58 +65,58 @@ func _physics_process(delta):
 
 func check_wm_api():
 	var s = ""
-	if (!OS.has_method("get_screen_count")):
+	if !OS.has_method("get_screen_count"):
 		s += " - get_screen_count()\n"
 
-	if (!OS.has_method("get_current_screen")):
+	if !OS.has_method("get_current_screen"):
 		s += " - get_current_screen()\n"
 
-	if (!OS.has_method("set_current_screen")):
+	if !OS.has_method("set_current_screen"):
 		s += " - set_current_screen()\n"
 
-	if (!OS.has_method("get_screen_position")):
+	if !OS.has_method("get_screen_position"):
 		s += " - get_screen_position()\n"
 
-	if (!OS.has_method("get_screen_size")):
+	if !OS.has_method("get_screen_size"):
 		s += " - get_screen_size()\n"
 
-	if (!OS.has_method("get_window_position")):
+	if !OS.has_method("get_window_position"):
 		s += " - get_window_position()\n"
 
-	if (!OS.has_method("set_window_position")):
+	if !OS.has_method("set_window_position"):
 		s += " - set_window_position()\n"
 
-	if (!OS.has_method("get_window_size")):
+	if !OS.has_method("get_window_size"):
 		s += " - get_window_size()\n"
 
-	if (!OS.has_method("set_window_size")):
+	if !OS.has_method("set_window_size"):
 		s += " - set_window_size()\n"
 
-	if (!OS.has_method("set_window_fullscreen")):
+	if !OS.has_method("set_window_fullscreen"):
 		s += " - set_window_fullscreen()\n"
 
-	if (!OS.has_method("is_window_fullscreen")):
+	if !OS.has_method("is_window_fullscreen"):
 		s += " - is_window_fullscreen()\n"
 
-	if (!OS.has_method("set_window_resizable")):
+	if !OS.has_method("set_window_resizable"):
 		s += " - set_window_resizable()\n"
 
-	if (!OS.has_method("is_window_resizable")):
+	if !OS.has_method("is_window_resizable"):
 		s += " - is_window_resizable()\n"
 
-	if (!OS.has_method("set_window_minimized")):
+	if !OS.has_method("set_window_minimized"):
 		s += " - set_window_minimized()\n"
 
-	if (!OS.has_method("is_window_minimized")):
+	if !OS.has_method("is_window_minimized"):
 		s += " - is_window_minimized()\n"
 
-	if (!OS.has_method("set_window_maximized")):
+	if !OS.has_method("set_window_maximized"):
 		s += " - set_window_maximized()\n"
 
-	if (!OS.has_method("is_window_maximized")):
+	if !OS.has_method("is_window_maximized"):
 		s += " - is_window_maximized()\n"
 
-	if (s.length() == 0):
+	if s.length() == 0:
 		return true
 	else:
 		$"ImplementationDialog/Text".text += s
@@ -125,16 +125,16 @@ func check_wm_api():
 
 
 func _ready():
-	if (not check_wm_api()):
+	if not check_wm_api():
 		set_physics_process(false)
 		set_process_input(false)
 
 
 func _input(event):
-	if (event is InputEventMouseMotion):
+	if event is InputEventMouseMotion:
 		mousepos = event.position
 
-	if (event is InputEventKey):
+	if event is InputEventKey:
 		if Input.is_action_pressed("mouse_mode_visible"):
 			observer.state = observer.STATE_MENU
 			_on_Button_MouseModeVisible_pressed()
@@ -164,28 +164,28 @@ func _on_Button_Screen1_pressed():
 
 
 func _on_Button_Fullscreen_pressed():
-	if (OS.is_window_fullscreen()):
+	if OS.is_window_fullscreen():
 		OS.set_window_fullscreen(false)
 	else:
 		OS.set_window_fullscreen(true)
 
 
 func _on_Button_FixedSize_pressed():
-	if (OS.is_window_resizable()):
+	if OS.is_window_resizable():
 		OS.set_window_resizable(false)
 	else:
 		OS.set_window_resizable(true)
 
 
 func _on_Button_Minimized_pressed():
-	if (OS.is_window_minimized()):
+	if OS.is_window_minimized():
 		OS.set_window_minimized(false)
 	else:
 		OS.set_window_minimized(true)
 
 
 func _on_Button_Maximized_pressed():
-	if (OS.is_window_maximized()):
+	if OS.is_window_maximized():
 		OS.set_window_maximized(false)
 	else:
 		OS.set_window_maximized(true)

networking/multiplayer_bomber/bomb.gd

@@ -5,18 +5,18 @@ var from_player
 
 # Called from the animation
 func explode():
-	if (not is_network_master()):
+	if not is_network_master():
 		# But will call explosion only on master
 		return
 	for p in in_area:
-		if (p.has_method("exploded")):
+		if p.has_method("exploded"):
 			p.rpc("exploded", from_player) # Exploded has a master keyword, so it will only be received by the master
 
 func done():
 	queue_free()
 
 func _on_bomb_body_enter(body):
-	if (not body in in_area):
+	if not body in in_area:
 		in_area.append(body)
 
 func _on_bomb_body_exit(body):

networking/multiplayer_bomber/gamestate.gd

@@ -27,8 +27,8 @@ func _player_connected(id):
 
 # Callback from SceneTree
 func _player_disconnected(id):
-	if (get_tree().is_network_server()):
-		if (has_node("/root/world")): # Game is in progress
+	if get_tree().is_network_server():
+		if has_node("/root/world"): # Game is in progress
 			emit_signal("game_error", "Player " + players[id] + " disconnected")
 			end_game()
 		else: # Game is not in progress
@@ -57,7 +57,7 @@ func _connected_fail():
 # Lobby management functions
 
 remote func register_player(id, new_player_name):
-	if (get_tree().is_network_server()):
+	if get_tree().is_network_server():
 		# If we are the server, let everyone know about the new player
 		rpc_id(id, "register_player", 1, player_name) # Send myself to new dude
 		for p_id in players: # Then, for each remote player
@@ -88,7 +88,7 @@ remote func pre_start_game(spawn_points):
 		player.position=spawn_pos
 		player.set_network_master(p_id) #set unique id as master
 
-		if (p_id == get_tree().get_network_unique_id()):
+		if p_id == get_tree().get_network_unique_id():
 			# If node for this peer id, set name
 			player.set_player_name(player_name)
 		else:
@@ -102,7 +102,7 @@ remote func pre_start_game(spawn_points):
 	for pn in players:
 		world.get_node("score").add_player(pn, players[pn])
 
-	if (not get_tree().is_network_server()):
+	if not get_tree().is_network_server():
 		# Tell server we are ready to start
 		rpc_id(1, "ready_to_start", get_tree().get_network_unique_id())
 	elif players.size() == 0:
@@ -116,10 +116,10 @@ var players_ready = []
 remote func ready_to_start(id):
 	assert(get_tree().is_network_server())
 
-	if (not id in players_ready):
+	if not id in players_ready:
 		players_ready.append(id)
 
-	if (players_ready.size() == players.size()):
+	if players_ready.size() == players.size():
 		for p in players:
 			rpc_id(p, "post_start_game")
 		post_start_game()
@@ -159,7 +159,7 @@ func begin_game():
 	pre_start_game(spawn_points)
 
 func end_game():
-	if (has_node("/root/world")): # Game is in progress
+	if has_node("/root/world"): # Game is in progress
 		# End it
 		get_node("/root/world").queue_free()
 

networking/multiplayer_bomber/lobby.gd

@@ -9,31 +9,31 @@ func _ready():
 	gamestate.connect("game_error", self, "_on_game_error")
 
 func _on_host_pressed():
-	if (get_node("connect/name").text == ""):
-		get_node("connect/error_label").text="Invalid name!"
+	if get_node("connect/name").text == "":
+		get_node("connect/error_label").text = "Invalid name!"
 		return
 
 	get_node("connect").hide()
 	get_node("players").show()
-	get_node("connect/error_label").text=""
+	get_node("connect/error_label").text = ""
 
 	var player_name = get_node("connect/name").text
 	gamestate.host_game(player_name)
 	refresh_lobby()
 
 func _on_join_pressed():
-	if (get_node("connect/name").text == ""):
-		get_node("connect/error_label").text="Invalid name!"
+	if get_node("connect/name").text == "":
+		get_node("connect/error_label").text = "Invalid name!"
 		return
 
 	var ip = get_node("connect/ip").text
-	if (not ip.is_valid_ip_address()):
-		get_node("connect/error_label").text="Invalid IPv4 address!"
+	if not ip.is_valid_ip_address():
+		get_node("connect/error_label").text = "Invalid IPv4 address!"
 		return
 
 	get_node("connect/error_label").text=""
-	get_node("connect/host").disabled=true
-	get_node("connect/join").disabled=true
+	get_node("connect/host").disabled = true
+	get_node("connect/join").disabled = true
 
 	var player_name = get_node("connect/name").text
 	gamestate.join_game(ip, player_name)
@@ -44,15 +44,15 @@ func _on_connection_success():
 	get_node("players").show()
 
 func _on_connection_failed():
-	get_node("connect/host").disabled=false
-	get_node("connect/join").disabled=false
+	get_node("connect/host").disabled = false
+	get_node("connect/join").disabled = false
 	get_node("connect/error_label").set_text("Connection failed.")
 
 func _on_game_ended():
 	show()
 	get_node("connect").show()
 	get_node("players").hide()
-	get_node("connect/host").disabled=false
+	get_node("connect/host").disabled = false
 	get_node("connect/join").disabled
 
 func _on_game_error(errtxt):
@@ -67,7 +67,7 @@ func refresh_lobby():
 	for p in players:
 		get_node("players/list").add_item(p)
 
-	get_node("players/start").disabled=not get_tree().is_network_server()
+	get_node("players/start").disabled = not get_tree().is_network_server()
 
 func _on_start_pressed():
 	gamestate.begin_game()

networking/multiplayer_bomber/player.gd

@@ -11,7 +11,7 @@ export var stunned = false
 sync func setup_bomb(bomb_name, pos, by_who):
 	var bomb = preload("res://bomb.tscn").instance()
 	bomb.set_name(bomb_name) # Ensure unique name for the bomb
-	bomb.position=pos
+	bomb.position = pos
 	bomb.from_player = by_who
 	# No need to set network mode to bomb, will be owned by master by default
 	get_node("../..").add_child(bomb)
@@ -23,23 +23,23 @@ var bomb_index = 0
 func _physics_process(delta):
 	var motion = Vector2()
 
-	if (is_network_master()):
-		if (Input.is_action_pressed("move_left")):
+	if is_network_master():
+		if Input.is_action_pressed("move_left"):
 			motion += Vector2(-1, 0)
-		if (Input.is_action_pressed("move_right")):
+		if Input.is_action_pressed("move_right"):
 			motion += Vector2(1, 0)
-		if (Input.is_action_pressed("move_up")):
+		if Input.is_action_pressed("move_up"):
 			motion += Vector2(0, -1)
-		if (Input.is_action_pressed("move_down")):
+		if Input.is_action_pressed("move_down"):
 			motion += Vector2(0, 1)
 
 		var bombing = Input.is_action_pressed("set_bomb")
 
-		if (stunned):
+		if stunned:
 			bombing = false
 			motion = Vector2()
 
-		if (bombing and not prev_bombing):
+		if bombing and not prev_bombing:
 			var bomb_name = get_name() + str(bomb_index)
 			var bomb_pos = position
 			rpc("setup_bomb", bomb_name, bomb_pos, get_tree().get_network_unique_id())
@@ -49,36 +49,36 @@ func _physics_process(delta):
 		rset("slave_motion", motion)
 		rset("slave_pos", position)
 	else:
-		position=slave_pos
+		position = slave_pos
 		motion = slave_motion
 
 	var new_anim = "standing"
-	if (motion.y < 0):
+	if motion.y < 0:
 		new_anim = "walk_up"
-	elif (motion.y > 0):
+	elif motion.y > 0:
 		new_anim = "walk_down"
-	elif (motion.x < 0):
+	elif motion.x < 0:
 		new_anim = "walk_left"
-	elif (motion.x > 0):
+	elif motion.x > 0:
 		new_anim = "walk_right"
 
-	if (stunned):
+	if stunned:
 		new_anim = "stunned"
 
-	if (new_anim != current_anim):
+	if new_anim != current_anim:
 		current_anim = new_anim
 		get_node("anim").play(current_anim)
 
 	# FIXME: Use move_and_slide
-	move_and_slide(motion*MOTION_SPEED)
-	if (not is_network_master()):
+	move_and_slide(motion * MOTION_SPEED)
+	if not is_network_master():
 		slave_pos = position # To avoid jitter
 
 slave func stun():
 	stunned = true
 
 master func exploded(by_who):
-	if (stunned):
+	if stunned:
 		return
 	rpc("stun") # Stun slaves
 	stun() # Stun master - could use sync to do both at once

networking/multiplayer_bomber/score.gd

@@ -4,11 +4,11 @@ var player_labels = {}
 
 func _process(delta):
 	var rocks_left = get_node("../rocks").get_child_count()
-	if (rocks_left == 0):
+	if rocks_left == 0:
 		var winner_name = ""
 		var winner_score = 0
 		for p in player_labels:
-			if (player_labels[p].score > winner_score):
+			if player_labels[p].score > winner_score:
 				winner_score = player_labels[p].score
 				winner_name = player_labels[p].name
 

networking/multiplayer_pong/ball.gd

@@ -1,72 +1,68 @@
-
 extends Area2D
 
-const DEFAULT_SPEED=80
+const DEFAULT_SPEED = 80
 
-var direction = Vector2(1,0)
+var direction = Vector2(1, 0)
 var ball_speed = DEFAULT_SPEED
-var stopped=false
-
+var stopped = false
 
 
 onready var screen_size = get_viewport_rect().size
 
+
 sync func _reset_ball(for_left):
-	
 	position = screen_size /2
-	if (for_left):
-		direction = Vector2(-1,0)
+	if for_left:
+		direction = Vector2(-1, 0)
 	else:
-		direction = Vector2( 1,0)
+		direction = Vector2(1, 0)
 
 	ball_speed = DEFAULT_SPEED
 
+
 sync func stop():
-	stopped=true
+	stopped = true
 
-func _process(delta):
-	
+
+func _process(delta):	
 	# ball will move normally for both players
 	# even if it's sightly out of sync between them
 	# so each player sees the motion as smooth and not jerky
 	
-	if (not stopped):
+	if not stopped:
 		translate( direction * ball_speed * delta ) 
 	
 	# check screen bounds to make ball bounce
 	
 	var ball_pos = position
-	if ((ball_pos.y < 0 and direction.y < 0) or (ball_pos.y > screen_size.y and direction.y > 0)):
+	if (ball_pos.y < 0 and direction.y < 0) or (ball_pos.y > screen_size.y and direction.y > 0):
 		direction.y = -direction.y
 		
-	if (is_network_master()):
+	if is_network_master():
 		# only master will decide when the ball is out in the left side (it's own side)
 		# this makes the game playable even if latency is high and ball is going fast
 		# otherwise ball might be out in the other player's screen but not this one
 		
-		if (ball_pos.x < 0 ):
-			get_parent().rpc("update_score",false)
-			rpc("_reset_ball",false)
+		if ball_pos.x < 0:
+			get_parent().rpc("update_score", false)
+			rpc("_reset_ball", false)
 	else:
 		# only the slave will decide when the ball is out in the right side (it's own side)
 		# this makes the game playable even if latency is high and ball is going fast
 		# otherwise ball might be out in the other player's screen but not this one
 		
-		if (ball_pos.x > screen_size.x):
-			get_parent().rpc("update_score",true)
-			rpc("_reset_ball",true)
+		if ball_pos.x > screen_size.x:
+			get_parent().rpc("update_score", true)
+			rpc("_reset_ball", true)
 		
 	
-sync func bounce(left,random):
-	
+sync func bounce(left, random):
 	#using sync because both players can make it bounce
-	if (left):		
+	if left:		
 		direction.x = abs(direction.x)
 	else:
 		direction.x = -abs(direction.x)
 		
 	ball_speed *= 1.1
-	direction.y = random*2.0 - 1
+	direction.y = random * 2.0 - 1
 	direction = direction.normalized()
-
-

networking/multiplayer_pong/lobby.gd

@@ -1,4 +1,3 @@
-
 extends Control
 
 const DEFAULT_PORT = 8910 # some random number, pick your port properly
@@ -9,14 +8,14 @@ const DEFAULT_PORT = 8910 # some random number, pick your port properly
 func _player_connected(id):
 	#someone connected, start the game!
 	var pong = load("res://pong.tscn").instance()
-	pong.connect("game_finished",self,"_end_game",[],CONNECT_DEFERRED) # connect deferred so we can safely erase it from the callback
+	pong.connect("game_finished", self, "_end_game", [], CONNECT_DEFERRED) # connect deferred so we can safely erase it from the callback
 	
 	get_tree().get_root().add_child(pong)
 	hide()
 
 func _player_disconnected(id):
 
-	if (get_tree().is_network_server()):
+	if get_tree().is_network_server():
 		_end_game("Client disconnected")
 	else:
 		_end_game("Server disconnected")
@@ -42,7 +41,7 @@ func _server_disconnected():
 ##### Game creation functions ######
 
 func _end_game(with_error=""):
-	if (has_node("/root/pong")):
+	if has_node("/root/pong"):
 		#erase pong scene
 		get_node("/root/pong").free() # erase immediately, otherwise network might show errors (this is why we connected deferred above)
 		show()
@@ -52,11 +51,11 @@ func _end_game(with_error=""):
 	get_node("panel/join").set_disabled(false)
 	get_node("panel/host").set_disabled(false)
 	
-	_set_status(with_error,false)
+	_set_status(with_error, false)
 
-func _set_status(text,isok):
+func _set_status(text, isok):
 	#simple way to show status		
-	if (isok):
+	if isok:
 		get_node("panel/status_ok").set_text(text)
 		get_node("panel/status_fail").set_text("")
 	else:
@@ -64,11 +63,10 @@ func _set_status(text,isok):
 		get_node("panel/status_fail").set_text(text)
 
 func _on_host_pressed():
-	
 	var host = NetworkedMultiplayerENet.new()
 	host.set_compression_mode(NetworkedMultiplayerENet.COMPRESS_RANGE_CODER)
-	var err = host.create_server(DEFAULT_PORT,1) # max: 1 peer, since it's a 2 players game
-	if (err!=OK):
+	var err = host.create_server(DEFAULT_PORT, 1) # max: 1 peer, since it's a 2 players game
+	if err != OK:
 		#is another server running?
 		_set_status("Can't host, address in use.",false)
 		return
@@ -76,31 +74,29 @@ func _on_host_pressed():
 	get_tree().set_network_peer(host)
 	get_node("panel/join").set_disabled(true)
 	get_node("panel/host").set_disabled(true)
-	_set_status("Waiting for player..",true)
+	_set_status("Waiting for player..", true)
 
 func _on_join_pressed():
-	
 	var ip = get_node("panel/address").get_text()
-	if (not ip.is_valid_ip_address()):
-		_set_status("IP address is invalid",false)
+	if not ip.is_valid_ip_address():
+		_set_status("IP address is invalid", false)
 		return
 	
 	var host = NetworkedMultiplayerENet.new()
 	host.set_compression_mode(NetworkedMultiplayerENet.COMPRESS_RANGE_CODER)
-	host.create_client(ip,DEFAULT_PORT)
+	host.create_client(ip, DEFAULT_PORT)
 	get_tree().set_network_peer(host)
 	
-	_set_status("Connecting..",true)
-
+	_set_status("Connecting..", true)
 
 
 ### INITIALIZER ####
 	
 func _ready():
 	# connect all the callbacks related to networking
-	get_tree().connect("network_peer_connected",self,"_player_connected")
-	get_tree().connect("network_peer_disconnected",self,"_player_disconnected")
-	get_tree().connect("connected_to_server",self,"_connected_ok")
-	get_tree().connect("connection_failed",self,"_connected_fail")
-	get_tree().connect("server_disconnected",self,"_server_disconnected")
+	get_tree().connect("network_peer_connected", self, "_player_connected")
+	get_tree().connect("network_peer_disconnected", self, "_player_disconnected")
+	get_tree().connect("connected_to_server", self, "_connected_ok")
+	get_tree().connect("connection_failed", self, "_connected_fail")
+	get_tree().connect("server_disconnected", self, "_server_disconnected")
 	

networking/multiplayer_pong/paddle.gd

@@ -5,62 +5,51 @@ export var left=false
 const MOTION_SPEED=150
 
 var motion = 0
-var you_hidden=false
+var you_hidden = false
 
 onready var screen_size = get_viewport_rect().size
 
 #synchronize position and speed to the other peers
-slave func set_pos_and_motion(p_pos,p_motion):
-	position=p_pos
-	motion=p_motion
+slave func set_pos_and_motion(p_pos, p_motion):
+	position = p_pos
+	motion = p_motion
 
 func _hide_you_label():
-	you_hidden=true
+	you_hidden = true
 	get_node("you").hide()
 
 func _process(delta):
-		
 	#is the master of the paddle		
-	if (is_network_master()):		
-	
+	if is_network_master():		
 		motion = 0
-		if (Input.is_action_pressed("move_up")):
+		if Input.is_action_pressed("move_up"):
 			motion -= 1
-		elif (Input.is_action_pressed("move_down")):
+		elif Input.is_action_pressed("move_down"):
 			motion += 1
 
-		if (not you_hidden and motion!=0):
+		if not you_hidden and motion != 0:
 			_hide_you_label()
-
-									
-		motion*=MOTION_SPEED
+			
+		motion *= MOTION_SPEED
 		
 		#using unreliable to make sure position is updated as fast as possible, even if one of the calls is dropped
-		rpc_unreliable("set_pos_and_motion",position,motion)
+		rpc_unreliable("set_pos_and_motion", position, motion)
 		
 	else:
-		if (not you_hidden):
+		if not you_hidden:
 			_hide_you_label()
-		
-	
+			
 	translate( Vector2(0,motion*delta) )
 	
 	# set screen limits
-	
 	var pos = position
 	
-	if (pos.y < 0 ):
-		position = Vector2( pos.x, 0) 
-	elif (pos.y > screen_size.y):	
-		position = Vector2( pos.x, screen_size.y)
-	
+	if pos.y < 0:
+		position = Vector2(pos.x, 0) 
+	elif pos.y > screen_size.y:	
+		position = Vector2(pos.x, screen_size.y)
 	
 	
 func _on_paddle_area_enter( area ):
-	
-	if (is_network_master()):
-		area.rpc("bounce",left,randf()) #random for new direction generated on each peer
-
-	
-		
-		
+	if is_network_master():
+		area.rpc("bounce", left, randf()) #random for new direction generated on each peer

networking/multiplayer_pong/pong.gd

@@ -1,7 +1,6 @@
-
 extends Node2D
 
-const SCORE_TO_WIN=10
+const SCORE_TO_WIN = 10
 
 var score_left = 0
 var score_right = 0
@@ -9,25 +8,24 @@ var score_right = 0
 signal game_finished()
 
 sync func update_score(add_to_left):
-	if (add_to_left):
-		
-		score_left+=1
-		get_node("score_left").set_text( str(score_left) )
+	if add_to_left:
+		score_left += 1
+		get_node("score_left").set_text(str(score_left))
 	else:
 		
-		score_right+=1
-		get_node("score_right").set_text( str(score_right) )
+		score_right += 1
+		get_node("score_right").set_text(str(score_right))
 		
 	var game_ended = false
 	
-	if (score_left==SCORE_TO_WIN):
+	if score_left == SCORE_TO_WIN:
 		get_node("winner_left").show()
-		game_ended=true
-	elif (score_right==SCORE_TO_WIN):
+		game_ended = true
+	elif score_right == SCORE_TO_WIN:
 		get_node("winner_right").show()
-		game_ended=true
+		game_ended = true
 		
-	if (game_ended):
+	if game_ended:
 		get_node("exit_game").show()
 		get_node("ball").rpc("stop")
 
@@ -35,11 +33,9 @@ func _on_exit_game_pressed():
 	emit_signal("game_finished")	
 
 func _ready():
-	
 	# by default, all nodes in server inherit from master
 	# while all nodes in clients inherit from slave
-		
-	if (get_tree().is_network_server()):		
+	if get_tree().is_network_server():		
 		#if in the server, get control of player 2 to the other peeer, this function is tree recursive by default
 		get_node("player2").set_network_master(get_tree().get_network_connected_peers()[0])
 	else:
@@ -47,6 +43,6 @@ func _ready():
 		get_node("player2").set_network_master(get_tree().get_network_unique_id())
 	
 	#let each paddle know which one is left, too
-	get_node("player1").left=true
-	get_node("player2").left=false
-	print("unique id: ",get_tree().get_network_unique_id())
+	get_node("player1").left = true
+	get_node("player2").left = false
+	print("unique id: ", get_tree().get_network_unique_id())

plugins/custom_import_plugin/import_plugin.gd

@@ -41,7 +41,7 @@ func get_option_visibility(option, options):
 func import(source_file, save_path, options, r_platform_variants, r_gen_files):
 	var file = File.new()
 	var err = file.open(source_file, File.READ)
-	if (err != OK):
+	if err != OK:
 		return err
 
 	var line = file.get_line()

plugins/custom_material_creator/Silly_material_creator.gd

@@ -20,7 +20,6 @@ func load_pressed():
 
 
 func save_file_selected(path):
-	
 	# Get the values from the sliders and color picker
 	var color = get_node("ColorPicker_albedo").color
 	var metallic = get_node("HSlider_metallic").value
@@ -45,14 +44,11 @@ func save_file_selected(path):
 	return true
 
 
-
 func load_file_selected(path):
-	
 	# Using the passed in editor interface, get the selected nodes in the editor
 	var editor_selection = editor_interface.get_selection()
 	var selected_nodes = editor_selection.get_selected_nodes()
 	
-	
 	var file = File.new()
 	var SpatialMaterial_Silly = null
 	
@@ -91,7 +87,5 @@ func load_file_selected(path):
 	else:
 		return false
 	
-	
 	# If we somehow get here, then return false (failure)
 	return false
-

plugins/custom_material_creator/Silly_material_resource.gd

@@ -7,7 +7,6 @@ extends Node
 #
 # See material_import.gd for more information
 
-
 var albedo_color
 var metallic_strength
 var roughness_strength
@@ -58,4 +57,3 @@ func make_material():
 	mat.roughness = roughness_strength
 	
 	return mat
-

plugins/custom_material_creator/material_import.gd

@@ -18,7 +18,7 @@ func _enter_tree():
 	io_material_dialog = preload("res://addons/custom_import_plugin/Custom_material_dock.tscn").instance()
 	io_material_dialog.editor_interface = get_editor_interface();
 	
-	add_control_to_dock( DOCK_SLOT_LEFT_UL, io_material_dialog )
+	add_control_to_dock(DOCK_SLOT_LEFT_UL, io_material_dialog)
 
 func _exit_tree():
-	remove_control_from_docks(io_material_dialog)
+	remove_control_from_docks(io_material_dialog)

viewport/2d_in_3d/pong.gd

@@ -21,18 +21,18 @@ func _process(delta):
 	ball_pos += direction * ball_speed * delta
 	
 	# Flip when touching roof or floor
-	if ((ball_pos.y < 0 and direction.y < 0) or (ball_pos.y > screen_size.y and direction.y > 0)):
+	if (ball_pos.y < 0 and direction.y < 0) or (ball_pos.y > screen_size.y and direction.y > 0):
 		direction.y = -direction.y
 	
 	# Flip, change direction and increase speed when touching pads
-	if ((left_rect.has_point(ball_pos) and direction.x < 0) or (right_rect.has_point(ball_pos) and direction.x > 0)):
+	if (left_rect.has_point(ball_pos) and direction.x < 0) or (right_rect.has_point(ball_pos) and direction.x > 0):
 		direction.x = -direction.x
 		ball_speed *= 1.1
 		direction.y = randf() * 2.0 - 1
 		direction = direction.normalized()
 	
 	# Check gameover
-	if (ball_pos.x < 0 or ball_pos.x > screen_size.x):
+	if ball_pos.x < 0 or ball_pos.x > screen_size.x:
 		ball_pos = screen_size * 0.5
 		ball_speed = INITIAL_BALL_SPEED
 		direction = Vector2(-1, 0)
@@ -42,18 +42,18 @@ func _process(delta):
 	# Move left pad
 	var left_pos = get_node("left").get_position()
 	
-	if (left_pos.y > 0 and Input.is_action_pressed("left_move_up")):
+	if left_pos.y > 0 and Input.is_action_pressed("left_move_up"):
 		left_pos.y += -PAD_SPEED * delta
-	if (left_pos.y < screen_size.y and Input.is_action_pressed("left_move_down")):
+	if left_pos.y < screen_size.y and Input.is_action_pressed("left_move_down"):
 		left_pos.y += PAD_SPEED * delta
 	
 	get_node("left").set_position(left_pos)
 	
 	# Move right pad
 	var right_pos = get_node("right").get_position()
-	if (right_pos.y > 0 and Input.is_action_pressed("right_move_up")):
+	if right_pos.y > 0 and Input.is_action_pressed("right_move_up"):
 		right_pos.y += -PAD_SPEED * delta
-	if (right_pos.y < screen_size.y and Input.is_action_pressed("right_move_down")):
+	if right_pos.y < screen_size.y and Input.is_action_pressed("right_move_down"):
 		right_pos.y += PAD_SPEED * delta
 	
 	get_node("right").set_position(right_pos)

viewport/3d_in_2d/3D_in_2D.gd

@@ -6,9 +6,9 @@ var sprite = null
 var viewport_sprite = null
 
 # variables for the sprite animation
-const MAX_FRAME_FOR_SPITE = 4
+const MAX_FRAME_FOR_SPRITE = 4
 const FRAME_SWITCH_TIME = 0.2
-var frame_swtich_timer = 0
+var frame_switch_timer = 0
 
 func _ready():
 	viewport = get_node("Viewport")
@@ -28,9 +28,9 @@ func _ready():
 
 # Simple frame based animation
 func _process(delta):
-	frame_swtich_timer += delta
-	if (frame_swtich_timer >= FRAME_SWITCH_TIME):
-		frame_swtich_timer -= FRAME_SWITCH_TIME
+	frame_switch_timer += delta
+	if frame_switch_timer >= FRAME_SWITCH_TIME:
+		frame_switch_timer -= FRAME_SWITCH_TIME
 		sprite.frame += 1
-	if (sprite.frame > MAX_FRAME_FOR_SPITE):
+	if sprite.frame > MAX_FRAME_FOR_SPRITE:
 		sprite.frame = 0

viewport/gui_in_3d/gui_3d.gd

@@ -1,4 +1,3 @@
-
 extends Spatial
 
 # Member variables
@@ -12,12 +11,12 @@ func _input(event):
 	var is_mouse_event = false
 	var mouse_events = [InputEventMouseButton, InputEventMouseMotion, InputEventScreenDrag, InputEventScreenTouch]
 	for mouse_event in mouse_events:
-		if (event is mouse_event):
+		if event is mouse_event:
 			is_mouse_event = true
 			break
   
 	# If it is, then pass the event to the viewport
-	if (is_mouse_event == false):
+	if is_mouse_event == false:
 		viewport.input(event)
 
 
@@ -26,7 +25,7 @@ func _on_area_input_event(camera, event, click_pos, click_normal, shape_idx):
 	# Use click pos (click in 3d space, convert to area space)
 	var pos = get_node("Area").get_global_transform().affine_inverse()
 	# the click pos is not zero, then use it to convert from 3D space to area space
-	if (click_pos.x != 0 or click_pos.y != 0 or click_pos.z != 0):
+	if click_pos.x != 0 or click_pos.y != 0 or click_pos.z != 0:
 		pos *= click_pos
 		last_click_pos = click_pos
 	else:
@@ -34,7 +33,7 @@ func _on_area_input_event(camera, event, click_pos, click_normal, shape_idx):
 		# and move it according to the relative position of the event.
 		# NOTE: this is not an exact 1-1 conversion, but it's pretty close
 		pos *= last_click_pos
-		if (event is InputEventMouseMotion or event is InputEventScreenDrag):
+		if event is InputEventMouseMotion or event is InputEventScreenDrag:
 			pos.x += event.relative.x / viewport.size.x
 			pos.y += event.relative.y / viewport.size.y
 			last_click_pos = pos
@@ -55,9 +54,9 @@ func _on_area_input_event(camera, event, click_pos, click_normal, shape_idx):
 	# Set the position in event
 	event.position = pos
 	event.global_position = pos
-	if (prev_pos == null):
+	if not prev_pos:
 		prev_pos = pos
-	if (event is InputEventMouseMotion):
+	if event is InputEventMouseMotion:
 		event.relative = pos - prev_pos
 	prev_pos = pos
 	
@@ -68,4 +67,4 @@ func _on_area_input_event(camera, event, click_pos, click_normal, shape_idx):
 func _ready():
 	viewport = get_node("Viewport")
 	get_node("Area").connect("input_event", self, "_on_area_input_event")
-  
+