Pivoting the Character along parts

So I’ve been trying to wrap my head around achieving accurate player movement along the faces of different parts (Spheres, Parts, Cylinders) for pretty much the entire day so far. My math is probably worst than a 5th grader’s, that much I know.

I want to add a mechanic in my game where the users would be able to scale up walls and hang upside with ease. Knowing that my math isn’t so hot, this would be impossible to achieve.
So, I have did some digging around the Forums and the internet in general for a snippet of code in which would help me understand and came across a few examples/ sources.


With a lead to go off of, I thank @Tinarg for the source code, it got me one step closer to my goal. After removing a few things and editing others so that it would be easier for me to implement, it produced good behavior, then no so good behavior.

There are two problems that I’ve encountered actually.
1.) The alignment of the character is off centered when scaling along objects that aren’t on the global axis.

2.) Parts like Cylinders and Spheres return incorrect results.

Arragh! Math >_<
After tinkering and reading the output for some time, it is still hard for me to narrow down just what is going on (I’m blaming my lack of math intuition). I am totally stumped and would gladly appreciate any guidance. Here are some snippets from the local script.

Snippet #1

--From http://devforum.roblox.com/t/vector-math-help/32659/5
function Calculate_LookVector(MoveDirection,Normal)

local function clamp(value, min, max)
	return (value < min and min) or (value > max and max) or value

local function rotateBy(vec, axis, angle)
	local cosAngle = math.cos(angle)
	local sinAngle = math.sin(angle)
	local axisDotA = axis:Dot(vec)

	return Vector3.new(
		axis.X*axisDotA * (1-cosAngle) + vec.X*cosAngle + (-axis.Z*vec.Y + axis.Y*vec.Z)*sinAngle,
		axis.Y*axisDotA * (1-cosAngle) + vec.Y*cosAngle + (axis.Z*vec.X  - axis.X*vec.Z)*sinAngle,
		axis.Z*axisDotA * (1-cosAngle) + vec.Z*cosAngle + (-axis.Y*vec.X + axis.X*vec.Y)*sinAngle

   local a = Vector3.new(0, 1, 0).unit --Original Vector a
   local b = MoveDirection.unit --Original Vector b
   local a2 = Normal.unit --New Vector a

   local axis = a:Cross(a2)
   axis = axis.magnitude == 0 and a:Cross(b).unit or axis.unit
   local angle = math.acos(clamp(a:Dot(a2), -1, 1))

   local b2 = rotateBy(b, axis, angle) --New Vector b
   return b2

Snippet #2

function Start()
Connection = RunService.Heartbeat:Connect(function(Tick)
	local LookVector = Calculate_LookVector(Humanoid.MoveDirection,Current_Angle)		
	local Backward_Ray_Pos = Root.Position-(Current_Angle*3.05)+(LookVector*1.1)		
	local Ray_Forward = Ray.new(Root.Position,LookVector*1.3)
	local Ray_Downward = Ray.new(Root.Position,-Current_Angle*3.1)
	local Ray_Backward = Ray.new(Backward_Ray_Pos,-LookVector*3)
	local Part_Test1, Point_Test1, Normal_Test1 = game.Workspace:FindPartOnRayWithWhitelist(Ray_Forward,game.Workspace.TestingStuff:GetChildren())
	local Part_Test2, Point_Test2, Normal_Test2 = game.Workspace:FindPartOnRayWithWhitelist(Ray_Downward,game.Workspace.TestingStuff:GetChildren())
	local Part_Test3, Point_Test3, Normal_Test3 = game.Workspace:FindPartOnRayWithWhitelist(Ray_Backward,game.Workspace.TestingStuff:GetChildren())

	if Part_Test1 and Check_Stickable(Part_Test1) then
		Normal = Normal_Test1
		Point = Point_Test1
		Part = Part_Test1
	else if Part_Test2 and Check_Stickable(Part_Test2) then
		Normal = Normal_Test2
		Point = Point_Test2
		Part = Part_Test2
	else if Part_Test3 and Check_Stickable(Part_Test3) then
		Normal = Normal_Test3
		Point = Point_Test3
		Part = Part_Test3
		Normal = nil
		Point = nil
		Part = nil
	if Normal then
		Stick_Part = Part
		Current_Angle = Normal	
		Current_Point = Point
		if Normal.Magnitude > 0 then
			Root.CFrame = CFrame.new(Point)+(Current_Angle*3)

	if Humanoid.MoveDirection.Magnitude > 0 then
		Root.CFrame = CFrame.new(Root.CFrame.p+((LookVector*0.28)/(Tick / (1 / 60))))
		Move = Move:lerp((CFrame.Angles(0,math.pi*0.5, 0) * CFrame.new(Humanoid.MoveDirection)).p, .1 * (Tick / (1 / 60)))					
	   Root.CFrame = CFrame.new(Root.CFrame.p, Root.CFrame.p + Current_Angle) * CFrame.Angles(-math.pi*0.5,math.pi,0) * CFrame.new(Vector3.new(), Move)		

Forgot to attach the placefile… My bad DeScript.rbxl (41.0 KB)