type Point : record
    x : real
    y : real
end record

function slope (p : Point) : real %calculates the slope of the line from (0, 0) to p
    result arcsind (p.y/sqrt (p.x**2 + p.y**2))
end slope

function slope2 (x : real, y : real) : real
    result arcsind (y/sqrt (x**2+y**2))
end slope2
   
var p0 : Point %Not really p0. Just used as a guide to show the 'original' direction
var p1 : Point %midpoint of the bezier
var p2 : Point %endpoint of the bezier

p0.x := 200 %some random initial values.
p0.y := 200

p1.x := 75
p1.y := 75
p2.x := 150
p2.y := 150

var offsetX := 0 %offset for drawing. Non-zero values kinda mess with the controls
var offsetY := 0

var keys : array char of boolean
View.Set ("offscreenonly")

%this draws the bezier given coordinates. t = time
proc drawBezier (x0 : real, y0 : real, x1 : real, y1 : real, x2 : real, y2: real, t : real)
    var x : real
    var y: real
    x := (1-t)**2*x0 + 2*(1-t)*t*x1+t**2*x2
    y := (1-t)**2*y0 + 2*(1-t)*t*y1+t**2*y2
    Draw.Dot (round (x)+offsetX, round (y)+offsetY, green)
end drawBezier
   

%var angle : real
var mx, my, mb : int

loop
Mouse.Where (mx, my, mb)

if mb = 1 then
    p2.y := my
    p2.x := mx
    p1.x := (p2.x + p0.x) /4 %these are the two lines I'm having trouble with. I need length((0, 0), p1) to match length (p1, p2). When slope (p2) = slope (p0), the bezier should be linear.
    p1.y := (p2.y + p0.y) / 4
end if

Draw.Line (0+offsetX, 0+offsetY, round (p0.x)+offsetX, round (p0.y)+offsetY, black)
Draw.Line (0+offsetX, 0+offsetY, round (p1.x)+offsetX, round (p1.y)+offsetY, red)
Draw.Line (round (p1.x)+offsetX, round (p1.y)+offsetY, round (p2.x)+offsetX, round (p2.y)+offsetY, red)

for i : 0..60
    drawBezier (0, 0, p1.x, p1.y, p2.x, p2.y, 1.0/60*i)
end for

put Math.Distance (0, 0, p1.x, p1.y)
put Math.Distance (p1.x, p1.y, p2.x, p2.y)
%Draw.Line (round (p3.x), round (p3.y), round (p4.x), round (p4.y), red)
%Draw.Line (0, 0, round (p2.x), round (p2.y), black)

View.Update
delay (10)
cls
end loop

type Point :
    record
        x : real
        y : real
    end record

function slope (p : Point) : real %calculates the slope of the line from (0, 0) to p
    result arcsind (p.y / sqrt (p.x ** 2 + p.y ** 2))
end slope

% Distance from origin to p squared
fcn norm2 (p : Point) : real
    result p.x * p.x + p.y * p.y
end norm2

proc drawBezier (x0 : real, y0 : real, x1 : real, y1 : real, x2 : real, y2 : real, t : real)
    var x : real
    var y : real
    x := (1 - t) ** 2 * x0 + 2 * (1 - t) * t * x1 + t ** 2 * x2
    y := (1 - t) ** 2 * y0 + 2 * (1 - t) * t * y1 + t ** 2 * y2
    Draw.Dot (round (x), round (y), green)
end drawBezier

var p0 : Point %Not really p0. Just used as a guide to show the 'original' direction
var p1 : Point %midpoint of the bezier
var p2 : Point %endpoint of the bezier

p0.x := 200 %some random initial values.
p0.y := 200

const a0 : real := slope (p0)

p1.x := 75
p1.y := 75
p2.x := 150
p2.y := 150

var mx, my, mb : int

loop
    Mouse.Where (mx, my, mb)

    if mb = 1 then
        p2.y := my
        p2.x := mx

        % Please excuse the terrible naming, a0, a1, a2 correspond to slope() for p0, p1, p2
       
        var a2 : real := slope (p2)
        var a : real := (a0 - a2) / 2 % angle between lines from origin to p0 and p1 (equal to angle between lines from origin to p1 and p2)
        var len : real := sqrt (norm2 (p2) / (2 * (1 - cosd (180 - 2 * a))))
        var a1 : real := a2 + a

        p1.x := len * cosd (a1)
        p1.y := len * sind (a1)
    end if
    Draw.Line (0, 0, round (p0.x), round (p0.y), black)
    Draw.Line (0, 0 , round (p1.x), round (p1.y), red)
    Draw.Line (round (p1.x), round (p1.y), round (p2.x), round (p2.y), red)

    for i : 0 .. 60
        drawBezier (0, 0, p1.x, p1.y, p2.x, p2.y, 1.0 / 60 * i)
    end for
    View.Update
    delay (10)
    cls
end loop

type Point :
    record
        x : real
        y : real
    end record

function slope (p : Point) : real %calculates the slope of the line from (0, 0) to p
    var out : real := arcsind (p.y / sqrt (p.x ** 2 + p.y ** 2))
    result out
end slope

function subtractPoint (a : Point, b : Point) : Point
    var out : Point
    out.x := a.x - b.x
    out.y := a.y - b.y
    result out
end subtractPoint

% Distance from origin to p squared
fcn norm2 (p : Point) : real
    result p.x * p.x + p.y * p.y
end norm2

proc drawBezier (x0 : real, y0 : real, x1 : real, y1 : real, x2 : real, y2 : real, t : real)
    var x : real
    var y : real
    x := (1 - t) ** 2 * x0 + 2 * (1 - t) * t * x1 + t ** 2 * x2
    y := (1 - t) ** 2 * y0 + 2 * (1 - t) * t * y1 + t ** 2 * y2
    Draw.Dot (round (x), round (y), green)
end drawBezier

var p0 : Point %Not really p0. Just used as a guide to show the 'original' direction
var p1 : Point %midpoint of the bezier
var p2 : Point %endpoint of the bezier

p0.x := 200 %some random initial values.
p0.y := 200

var a0 : real := slope (p0)

p1.x := 75
p1.y := 75
p2.x := 150
p2.y := 150

var offsetX : real := 0
var offsetY : real := 0

var mx, my, mb : int
var keys : array char of boolean
var keyPressed : boolean := false
View.Set ("offscreenonly")
var s : real
var track : boolean := false

loop
    Mouse.Where (mx, my, mb)
    Input.KeyDown (keys)
    mx -= round (offsetX)
    my -= round (offsetY)
    if keys (KEY_ENTER) and keyPressed = false then
        keyPressed := true

        offsetX += p2.x
        offsetY += p2.y
        p0.x := p2.x - p1.x
        p0.y := p2.y - p1.y
        p2.x := p0.x
        p2.y := p0.y
        p1.x := p2.x/2
        p1.y := p2.y / 2
        a0 := slope (p0)
       % p1.x := 75 * cosd (a1)
       % p1.y := 75 * sind (a1)
    elsif not keys (KEY_ENTER) then
        keyPressed := false
    end if
       
    if mb = 1 and mx < p2.x +5 and mx > p2.x -5 and my < p2.y + 5 and my > p2.y - 5 then
        track := true
    elsif mb = 0 then
        track := false
    end if
   
    if track = true then
        p2.y := my
        p2.x := mx
        % Please excuse the terrible naming, a0, a1, a2 correspond to slope() for p0, p1, p2
       
        var a2 : real := slope (p2)
        var a : real := (a0 - a2) / 2 % angle between lines from origin to p0 and p1 (equal to angle between lines from origin to p1 and p2)
        var len : real := sqrt (norm2 (p2) / (2 * (1 - cosd (180 - 2 * a))))
        var a1 : real := a2 + a

        p1.x := len * cosd (a1)
        p1.y := len * sind (a1)
    end if
    %Draw.Line (round (offsetX), round (offsetY), round (p0.x+offsetX), round (p0.y+offsetY), black)
    Draw.Line (round (offsetX), round (offsetY), round (p1.x+offsetX), round (p1.y+offsetY), red)
    Draw.Line (round (p1.x+offsetX), round (p1.y+offsetY), round (p2.x+offsetX), round (p2.y+offsetY), red)
    Draw.FillOval (round (p2.x + offsetX), round (p2.y + offsetY), 5, 5, blue)
    for i : 0 .. 60
        drawBezier (offsetX, offsetY, p1.x+offsetX, p1.y+offsetY, p2.x+offsetX, p2.y+offsetY, 1.0 / 60 * i)
    end for
    View.Update
    delay (10)
    cls
end loop

var a2 : real := slope (p2)
put dot (p2, p0)
if (p2.x < 0) then
    % The angle is greater than 90 deg (or less than -90 deg)
    % We need to adjust the value based on whether p2 is above or below the line from (offsetX, offsetY) to p0
    if (p2.x * p0.y / p0.x < p2.y) then
        a2 := 180 - a2
    else
        a2 := -180 - a2
    end if
end if