'OPEN "maxfek3.dat" FOR OUTPUT AS #1
'OPEN "maxhajt.dat" FOR OUTPUT AS #2
'OPEN "gurul3.dat" FOR OUTPUT AS #3
DIM t(100): DIM o(100): DIM oo(100)
DIM pal(15): DIM Piros(15): DIM Zold(15): DIM Kek(15)
DATA 0,5,11,28,45,54,63,62,57,51,42,36,31,27
DATA 24,31,41,50,54,59,63,54,43,34,27,23,20,17
'Ezek a terkep magassagi szinei. A feher azt jelenti, hogy a biciklista atlepte a hohatart.
Piros(15) = 63: Zold(15) = 63: Kek(15) = 63
pal(15) = 65536 * Kek(15) + 256 * Zold(15) + Piros(15)
FOR i = 1 TO 14: READ Piros(i): NEXT
FOR i = 1 TO 14: READ Zold(i): NEXT
FOR i = 1 TO 15: pal(i) = 65536 * Kek(i) + 256 * Zold(i) + Piros(i): NEXT
SCREEN 12
FOR n = 0 TO 15: PALETTE n, pal(n): NEXT

ikszkozep = 400: ipszkozep = 320
pi = 3.1415925#
hanyszorfelezzen = 10
fazistervonal = 4: helyfinomsag2 = 64: sebugras = .8
utszorzo = 1.5: sebszorzo = 15
alapszint = 10000
sulypmagassag = 1.2: tengelytav = 1.5: hatraules = .05
elsotav = tengelytav / 2 + hatraules
hatsotav = tengelytav / 2 - hatraules
gordeho = .002: tapeho = .3: legellteny = .005: g0 = 9.81
maxtelj = 3

DEF fns1 = 100
DEF fns2 = 200
'DEF fns1 = 100 + SIN(polarszog / 2) * 50
'DEF fns2 = 200 + SIN(polarszog / 2) * 100
'DEF fns1 = 80 / (1 + .5 * COS(polarszog))
'DEF fns2 = 140 / (1 + .5 * COS(polarszog))
'DEF fns1 = 100 / SQR(1 + 3 * SIN(polarszog) ^ 2)
'DEF fns2 = 200 / SQR(1 + 8 * SIN(polarszog) ^ 2)
'DEF fns1 = 150 / SQR(1 + 5 * COS(polarszog) ^ 2)
'DEF fns2 = 300 / SQR(1 + 8 * COS(polarszog) ^ 2)

'lejtotlen palyak
'DEF fnf = 0
'DEF fnf = (sugar - fns1) / 3 - 50
'DEF fnf = 2 ^ ((sugar - fns2) / 10) * 20 + 50
'DEF fnf = 2 ^ ((fns1 - sugar) / 10) * 20 + 2 ^ ((sugar - fns2) / 10) * 20
'DEF fnf = -SQR((fns1 - fns2) ^ 2 / 4 - (sugar - (fns1 + fns2) / 2) ^ 2)
'DEF fnf = -SQR((fns1 - fns2) ^ 2 - (sugar - (fns1 + fns2) / 2) ^ 2) + 70
'DEF fnf = -SQR((fns1 - fns2) ^ 2 - (sugar - (2 * fns1 + fns2) / 3) ^ 2) + 70
'DEF fnf = (sugar - fns1 + 1) ^ 1.5 / 30 - 50

'lejtos palyak
'DEF fnf = -polarszog * 30 + 50
'DEF fnf = -polarszog * 10 + sugar * .087 - 20
DEF fnf = -polarszog * 10 + 2 ^ ((sugar - fns2) / 10) * 30 + 30
'DEF fnf = -polarszog * 10 + 2 ^ ((fns1 - sugar) / 10) * 20 + 2 ^ ((sugar - fns2) / 10) * 20
'DEF fnf = -polarszog * 10 - SQR((fns1 - fns2) ^ 2 / 4 - (sugar - (fns1 + fns2) / 2) ^ 2 + 100) + 30
'DEF fnf = -polarszog * 10 - SQR((fns1 - fns2) ^ 2 - (sugar - (fns1 + fns2) / 2) ^ 2) + 100
'DEF fnf = -polarszog * 10 - SQR((fns1 - fns2) ^ 2 - (sugar - (2 * fns1 + fns2) / 3) ^ 2) + 100

SCREEN 12
CLS
FOR i = 0 TO 50
 polarszog = i * pi / 50
 IF INT(i / 5) = i / 5 THEN sugarszin = 15 ELSE sugarszin = 4
 sugarlepes = (fns2 - fns1) / 20
 FOR j = 0 TO 20
  sugar = fns2 - sugarlepes * j
  IF INT(j / 5) = j / 5 THEN polarszogszin = 12 ELSE polarszogszin = 8
  a = sugar * COS(polarszog): b = sugar * SIN(polarszog)
  IF fnf < alapszint THEN alapszint = fnf
  t = a + ikszkozep: o = ipszkozep - fnf - b * .4 - 100: oo = ipszkozep - b
  IF j > 0 THEN LINE (t - 200, o)-(t1 - 200, o1), sugarszin
  IF j > 0 AND sugarszin = 15 THEN LINE (t, oo)-(t1, oo1), 15
  IF i > 0 THEN LINE (t(j) - 200, o(j))-(t - 200, o), polarszogszin
  IF i > 0 AND polarszogszin = 12 THEN LINE (t(j), oo(j))-(t, oo), 15
  t(j) = t: o(j) = o: oo(j) = oo: t1 = t: o1 = o: oo1 = oo
 NEXT j
NEXT i

FOR i = 0 TO 200
 polarszog = i * pi / 200
 sugarlepes = (fns2 - fns1) / 100
 FOR j = 0 TO 100
  sugar = fns2 - sugarlepes * j
  IF sugar < fns1 THEN GOTO ujszog
  szint = fnf
  o$ = INKEY$: IF o$ <> "" THEN GOTO nearnyekolj
  szin = INT((szint - alapszint) / 5) + 1
  a = sugar * COS(polarszog): b = sugar * SIN(polarszog)
  t = a + ikszkozep: oo = ipszkozep - b
  PSET (t, oo), szin
nemszintvonal: NEXT j
ujszog: NEXT i

nearnyekolj:
DIM SHARED mouse AS INTEGER
DIM SHARED m1 AS INTEGER
DIM SHARED m2 AS INTEGER
DIM SHARED mx AS INTEGER
DIM SHARED my AS INTEGER
DEF SEG = 0
MSEG = 256 * PEEK(51 * 4 + 3) + PEEK(51 * 4 + 2)
mouse = 256 * PEEK(51 * 4 + 1) + PEEK(51 * 4) + 2
DEF SEG = MSEG
m1 = 8:  mx = 0: my = ipszkozep: CALL absolute(m1, m2, mx, my, mouse)
hany = 20
DIM x(hany): DIM y(hany)
DIM ujx(hany): DIM ujy(hany)
DIM ux(hany): DIM uy(hany)
DIM beszuras(hany)
m1 = 1: CALL absolute(m1, m2, mx, my, mouse)

eleje: '************* kirajzolja a palyat, felulnezetben *****************
mx = 500: my = 450: i = 1
AlappontotVar: ' ********** be lehet adni az utvonal vazlatat *************
'LOCATE 28, 2: PRINT "Lepeshossz: 1-9    Uj pont: Szokoz     Vege: Enter"
'x = 500: y = 450
' KEY(11) ON: KEY(12) ON: KEY(13) ON: KEY(14) ON
'i = 1

'innen:
'IF i > 1 THEN x = x(i - 1)
'IF i > 1 THEN y = y(i - 1)

'lepked:
'ON KEY(11) GOSUB fel
'ON KEY(12) GOSUB bal
'ON KEY(13) GOSUB jobb
'ON KEY(14) GOSUB le
'PSET (x, y), 15

'o$ = INKEY$
'IF VAL(o$) > 0 THEN ugras = VAL(o$)
'IF o$ = " " THEN GOTO kov
'IF o$ = CHR$(13) THEN n = i - 1: GOTO elore
'GOTO lepked

'fel: PSET (x, y), 0: y = y - ugras: RETURN
'bal: PSET (x, y), 0: x = x - ugras: RETURN
'jobb: : PSET (x, y), 0: x = x + ugras: RETURN
'le: PSET (x, y), 0: y = y + ugras: RETURN

'kov:
'IF x = x(i - 1) AND y = y(i - 1) THEN SOUND (2000), .1: GOTO lepked
'x(i) = x: y(i) = y
'IF i > 1 THEN LINE (x(i - 1), y(i - 1))-(x(i), y(i)), 5
'i = i + 1: GOTO innen

'elore:
'FOR i = 2 TO n: PSET (x(i), y(i)): NEXT i
IF i > 1 THEN mx = x(i - 1)
IF i > 1 THEN my = y(i - 1)

UjAlappontotVar:
m1 = 3: CALL absolute(m1, m2, mx, my, mouse)
o$ = INKEY$
IF m2 = 1 THEN GOTO MegneziAzUjAlappontot
IF o$ = CHR$(13) OR m2 = 3 THEN n = i - 1: GOTO FinomitasiLepes
m3 = mx: m4 = my
GOTO UjAlappontotVar

MegneziAzUjAlappontot:
IF (mx - x(i - 1)) ^ 2 + (my - y(i - 1)) ^ 2 < 100 THEN SOUND (1000), .1: GOTO UjAlappontotVar
' (nem szabad ket szomszedos pontnak tul kozel lenni)
IF i < 3 THEN GOTO NemKellElessegkorlatozas
IF (mx - x(i - 1)) * (x(i - 1) - x(i - 2)) + (my - y(i - 1)) * (y(i - 1) - y(i - 2)) <= 0 THEN SOUND (1000), .1: GOTO UjAlappontotVar
' (nem szabad tul meredek kanyart beadni az alappontokkal)

NemKellElessegkorlatozas:
x(i) = mx: y(i) = my
m1 = 2: CALL absolute(m1, m2, mx, my, mouse)
IF i > 1 THEN LINE (x(i - 1), y(i - 1))-(x(i), y(i)), 15
m1 = 1: CALL absolute(m1, m2, mx, my, mouse)
SOUND (2000), .1
i = i + 1
IF i > 20 THEN n = 20: GOTO FinomitasiLepes
GOTO AlappontotVar

FinomitasiLepes: ' ********* kirajzolja az eppen legfinomabb pontsort **********
finomitasszam = 0

' ********* felezomerolegesek szerkesztese **********
' felezomeroleges egyenlete fx * x + fy * y = s
' Az (fx,fy) vektor az elmozdulas vektora a megfelelo pontok kozott.
' A "bal" es "jobb" a ket szogfelezot jelenti.

FOR i = 3 TO n - 1
IF (x(i - 1) - x(i)) ^ 2 + (y(i - 1) - y(i)) ^ 2 < helyfinomsag2 THEN GOTO MarTulFinom
fx1bal = x(i) - x(i - 2): fy1bal = y(i) - y(i - 2)
fx2bal = x(i - 1) - x(i - 2): fy2bal = y(i - 1) - y(i - 2)
fx1jobb = x(i - 1) - x(i + 1): fy1jobb = y(i - 1) - y(i + 1)
fx2jobb = x(i) - x(i + 1): fy2jobb = y(i) - y(i + 1)
fx = x(i) - x(i - 1): fy = y(i) - y(i - 1)
x0 = (x(i) + x(i - 1)) / 2: y0 = (y(i) + y(i - 1)) / 2
ss = fx * x0 + fy * y0: 'a normalvektoros egyenlet konstans oldala

' ********* szogfelezok szerkesztese **********
' e vektor az i-edik szogfelezo iranyvektora
' a szogfelezok egyenlete ey * x - ex * y = t

exbal = fx1bal / SQR(fx1bal ^ 2 + fy1bal ^ 2) + fx2bal / SQR(fx2bal ^ 2 + fy2bal ^ 2)
eybal = fy1bal / SQR(fx1bal ^ 2 + fy1bal ^ 2) + fy2bal / SQR(fx2bal ^ 2 + fy2bal ^ 2)
exjobb = fx1jobb / SQR(fx1jobb ^ 2 + fy1jobb ^ 2) + fx2jobb / SQR(fx2jobb ^ 2 + fy2jobb ^ 2)
eyjobb = fy1jobb / SQR(fx1jobb ^ 2 + fy1jobb ^ 2) + fy2jobb / SQR(fx2jobb ^ 2 + fy2jobb ^ 2)
tbal = eybal * x(i - 2) - exbal * y(i - 2)
tjobb = eyjobb * x(i + 1) - exjobb * y(i + 1)

' az i-edik felezomerolegest (amely az i-edik pont elotti
' szakaszhoz tartozik) elmetsszuk az i-2-edik ill. az i+1-edik
' ponthoz tartozo szogfelezovel. A mtp-ok: g es h, egy nevezetes
' tetel szerint a korulirt korokon vannak. Az ilyen modon szerkesztett
' metszespont akkor nem egyertelmu, ha a haromszog, ami kore a kort
' irjuk, egyenlo szaru. Ezert erdemes megtiltani, hogy az utvazlat
' harom szomszedos alappontja derekszognel elesebb szoget hatarozzon meg.
' Az uj pont (u) a ket korivfelezo pont kozt van ugy, hogy az uj gorbulet
' a ket regi gorbulet atlaga legyen. Igy jon letre a finomitas.

k = fx * exbal + fy * eybal: l = fx * exjobb + fy * eyjobb
gx = (ss * exbal + fy * tbal) / k: gy = (ss * eybal - fx * tbal) / k
hx = (ss * exjobb + fy * tjobb) / l: hy = (ss * eyjobb - fx * tjobb) / l
p1 = SQR((gx - x0) ^ 2 + (gy - y0) ^ 2) * SGN((gx - x0) * fy - (gy - y0) * fx)
p2 = SQR((hx - x0) ^ 2 + (hy - y0) ^ 2) * SGN((hx - x0) * fy - (hy - y0) * fx)
tav = SQR(fx ^ 2 + fy ^ 2) / 2
IF p1 + p2 = 0 THEN finomitasszam = finomitasszam + 1: beszuras(finomitasszam) = i: ux(finomitasszam) = x0: uy(finomitasszam) = y0: GOTO FinomitoPontKiirasa
tenyezo = (p1 ^ 2 + tav ^ 2) * (p2 ^ 2 + tav ^ 2) / (p1 * p2 + tav ^ 2) / (p1 + p2)
IF tenyezo < 0 THEN pe = tenyezo + SQR(tenyezo ^ 2 - tav ^ 2)
IF tenyezo >= 0 THEN pe = tenyezo - SQR(tenyezo ^ 2 - tav ^ 2)
finomitasszam = finomitasszam + 1
ux(finomitasszam) = x0 + fy * pe / tav / 2
uy(finomitasszam) = y0 - fx * pe / tav / 2
beszuras(finomitasszam) = i
'azaz az i-edik regi pont ele a "finomitasszam"-adik uj pontot kell beszurni.

FinomitoPontKiirasa:
PSET (ux(finomitasszam), uy(finomitasszam))
MarTulFinom: NEXT i
IF finomitasszam = 0 THEN GOTO simitas

' ***********  uj pontok besorolasa ****************
hany = n + finomitasszam
REDIM ujx(hany): REDIM ujy(hany)
marbeszurt = 0
ujx(1) = x(1): ujy(1) = y(1): ujx(2) = x(2): ujy(2) = y(2)

FOR i = 3 TO n - 1
IF marbeszurt >= finomitasszam THEN GOTO EzNemBeszuras

VanMegBeszuras:
IF beszuras(marbeszurt + 1) <> i THEN GOTO EzNemBeszuras
ujx(i + marbeszurt) = ux(marbeszurt + 1)
ujy(i + marbeszurt) = uy(marbeszurt + 1)
marbeszurt = marbeszurt + 1

EzNemBeszuras:
ujx(i + marbeszurt) = x(i): ujy(i + marbeszurt) = y(i)
ujproba: NEXT i

NincsTobbBeszuras:
ujx(hany - 1) = x(n - 1): ujy(hany - 1) = y(n - 1)
ujx(hany) = x(n): ujy(hany) = y(n)
REDIM x(hany): REDIM y(hany): REDIM ux(hany): REDIM uy(hany): REDIM beszuras(hany)
n = hany
FOR j = 1 TO n: x(j) = ujx(j): y(j) = ujy(j): NEXT j
GOTO FinomitasiLepes

simitas:
FOR i = 1 TO n - 2: x(i) = x(i + 1): y(i) = y(i + 1): NEXT i
n = n - 2
'FOR i = 1 TO n - 1: x(i) = (x(i) + x(i + 1)) / 2: y(i) = (y(i) + y(i + 1)) / 2: NEXT i
'n = n - 1
DIM z(n)

'*************************************************************
'** lepesrol lepesre vegigmegy a vegleges finomitott gorben **
'*************************************************************

FOR j = 1 TO n
 sugar = SQR((x(j) - ikszkozep) ^ 2 + (y(j) - ipszkozep) ^ 2)
 IF x(j) = ikszkozep THEN polarszog = pi / 2: GOTO megvan1
 polarszog = ATN((ipszkozep - y(j)) / (x(j) - ikszkozep))
 IF polarszog < 0 THEN polarszog = polarszog + pi
megvan1: z(j) = fnf
NEXT j

regiviztav = SQR((x(1) - x(2)) ^ 2 + (y(1) - y(2)) ^ 2): i = 2

ujhely: 'terben tovabblep *************
sebesseg = 0
IF i = n THEN END

'************ pontbeli vizszintes gorbuletet szamol ****************
ujviztav = SQR((x(i) - x(i + 1)) ^ 2 + (y(i) - y(i + 1)) ^ 2)
sugar = SQR((x(i) - ikszkozep) ^ 2 + (y(i) - ipszkozep) ^ 2)
IF x(i) = ikszkozep THEN polarszog = pi / 2: GOTO megvan2
polarszog = ATN((ipszkozep - y(i)) / (x(i) - ikszkozep))
IF polarszog < 0 THEN polarszog = polarszog + pi
megvan2:

lejtoszog = ATN((z(i - 1) - z(i)) / regiviztav)
LOCATE 2, 1: PRINT "lejtofok:"; INT(lejtoszog / pi * 1800) / 10; "   "
a = sugar * COS(polarszog)
b = sugar * SIN(polarszog)
t = a + ikszkozep
o = ipszkozep - z(i) - b * .4 - 100
CIRCLE (t - 200, o), 2, 15
CIRCLE (x(i), y(i)), 2, 15
ikszbalra = x(i) + (y(i) - y(i - 1)) / regiviztav
ipszbalra = y(i) - (x(i) - x(i - 1)) / regiviztav
sugar = SQR((ikszbalra - ikszkozep) ^ 2 + (ipszbalra - ipszkozep) ^ 2)
IF ikszbalra = ikszkozep THEN polarszog = pi / 2: GOTO megvan3
polarszog = ATN((ipszkozep - ipszbalra) / (ikszbalra - ikszkozep))
IF polarszog < 0 THEN polarszog = polarszog + pi
megvan3: zbalra = fnf
oldalszog = ATN(z(i) - zbalra)
LOCATE 3, 1: PRINT "oldalfok="; INT(oldalszog / pi * 1800) / 10; "   "
'pozitiv, ha balra van a volgy
vizvekszorzat = (x(i) - x(i - 1)) * (y(i + 1) - y(i)) - (y(i) - y(i - 1)) * (x(i + 1) - x(i))
vizszinusz = -vizvekszorzat / (regiviztav * ujviztav)
'az arc sin fv-t Taylor-sorral tudjuk csak kiszamolni
vizszog = 0
FOR j = 0 TO 10
 tag = 1 / (2 * j + 1) * vizszinusz ^ (2 * j + 1)
 FOR jj = 1 TO j: tag = tag * (2 * jj - 1) / (2 * jj): NEXT jj
 vizszog = vizszog + tag:
NEXT j
vizszgorb = vizszog / (regiviztav + ujviztav) * 2
' (az ivhossz, a gorbuleti sugar es a kozepponti szog kozti
' s=R*fi kepletbol). A gorbulet pozitiv, ha balra kanyarodik.
LOCATE 5, 1: PRINT "vizszgorb: "; INT(vizszgorb * 10000) / 10000; "   "

'************ pontbeli fuggoleges gorbuletet szamol ******************
regitav = SQR(regiviztav ^ 2 + (z(i - 1) - z(i)) ^ 2): s = s + regitav
vetulet = ((x(i + 1) - x(i)) * (x(i) - x(i - 1)) + (y(i + 1) - y(i)) * (y(i) - y(i - 1))) / regiviztav
ferdevetulet = SQR(vetulet ^ 2 + (z(i) - z(i + 1)) ^ 2)
fuggvekszorzat = regiviztav * (z(i + 1) - z(i)) - (z(i) - z(i - 1)) * vetulet
fuggszinusz = fuggvekszorzat / (regitav * ferdevetulet)
fuggszog = 0
FOR j = 0 TO 10
 tag = 1 / (2 * j + 1) * fuggszinusz ^ (2 * j + 1)
 FOR jj = 1 TO j: tag = tag * (2 * jj - 1) / (2 * jj): NEXT jj
 fuggszog = fuggszog + tag:
NEXT j
fuggorb = fuggszog / (regitav + ferdevetulet) * 2
LOCATE 4, 1: PRINT "fuggorb: "; INT(fuggorb * 10000) / 10000; "   "
'pozitiv, ha godron megy at.
regiviztav = ujviztav

'******************************************************************
MaxBiztFekerotSzamol: '********************************************
'******************************************************************

ujsebesseg: ' *********** tovabblep a fazisdiagramon v-vel **************
o$ = INKEY$: IF o$ <> "" THEN END
sebesseg = sebesseg + sebugras
IF sebesseg > 20 THEN i = i + 1: GOTO ujhely
'megallapitja azt az eroosszegt, amelyre eloszor szamolhato
'a hatso kritikus fekero.
g = g0 * COS(lejtoszog) + sebesseg ^ 2 * fuggorb
IF g <= 0 THEN i = i + 1: GOTO ujhely
dolesszog = ATN(sebesseg ^ 2 * vizszgorb / g): 'pozitiv, ha balra dol
'***** megkeresi a hatso fekero legjobboldalibb helyet.
nyomoero = g * COS(oldalszog) + sebesseg ^ 2 * vizszgorb * SIN(oldalszog)
eroosszeg = tapeho * nyomoero / 2: korrekcio = eroosszeg / 2
FOR j = 1 TO hanyszorfelezzen
 GOSUB Elojelek
 IF hatsokritfek2 > 0 THEN eroosszeg = eroosszeg + korrekcio ELSE eroosszeg = eroosszeg - korrekcio
 korrekcio = korrekcio / 2
NEXT j
eroosszeg = eroosszeg - korrekcio * 2
'(a biztonsag kedveert, hatha az utolso lepesevel tilos tartomanyba tevedt)
GOSUB Elojelek
IF hatsokritfek2 < 0 OR elsokritfek2 < 0 THEN maxfekero = -1: GOTO MaxBiztHajtoerotSzamol
IF eroosszeg < SQR(elsokritfek2) THEN maxfekero = eroosszeg: GOTO MaxBiztHajtoerotSzamol
'ha a legnagyobb fekerot a tiszta elso fekezes adja, akkor nem kell
'a csuszasvonalak metszespontjat keresni; ellenkezo esetben a metszespont
'adja a max biztonsagos fekerot.

'***** felezo gyokkereses a csuszasvonalak metszespontjahoz,
'***** az iment kiszamitott jobb oldali hatartol kezdve.
eroosszeg = eroosszeg / 2: korrekcio = eroosszeg / 2
FOR j = 1 TO hanyszorfelezzen
 GOSUB Elojelek
 IF eroosszeg < SQR(elsokritfek2) + SQR(hatsokritfek2) THEN eroosszeg = eroosszeg + korrekcio ELSE eroosszeg = eroosszeg - korrekcio
 'elso eset: a mtp-tol jobbra vagyunk
 'masodik eset: a mtp-tol balra vagyunk
 korrekcio = korrekcio / 2
NEXT j
maxfekero = eroosszeg

'******************************************************************
MaxBiztHajtoerotSzamol: ' *****************************************
'******************************************************************

' *** Lehetseges, hogy a hatso kerek nem porog ki, hanem a bicikli
' *** felagaskodik. Megkeresi ezt a pontot.
eroosszeg = -tapeho * nyomoero / 2: korrekcio = eroosszeg / 2
FOR j = 1 TO hanyszorfelezzen
 GOSUB Elojelek
 IF elsokritfek2 > 0 THEN eroosszeg = eroosszeg + korrekcio ELSE eroosszeg = eroosszeg - korrekcio
 korrekcio = korrekcio / 2
NEXT j
eroosszeg = eroosszeg - korrekcio * 2
'(a biztonsag kedveert, hatha az utolso lepesevel tilos tartomanyba tevedt)
GOSUB Elojelek
IF hatsokritfek2 < 0 OR elsokritfek2 < 0 THEN maxhajtoero = -1: GOTO MegvannakAzErok
IF eroosszeg + SQR(hatsokritfek2) > 0 THEN maxhajtoero = -eroosszeg: GOTO MegvannakAzErok

' *** Megnezi, hogy a felagaskodasi pontban a hatso kerek nem porgott-e ki.
' *** Ha igen, akkor megkeresi ezt a pontot.
eroosszeg = eroosszeg / 2: korrekcio = eroosszeg / 2
FOR j = 1 TO hanyszorfelezzen
 GOSUB Elojelek
 IF eroosszeg + SQR(hatsokritfek2) > 0 THEN eroosszeg = eroosszeg + korrekcio ELSE eroosszeg = eroosszeg - korrekcio
 korrekcio = korrekcio / 2
NEXT j
maxhajtoero = -eroosszeg
IF ABS(maxhajtoero) > maxtelj / sebesseg THEN maxhajtoero = -maxtelj / sebesseg

MegvannakAzErok: ' ***** elmegy es egyszerre kirja oket a fazisterre *****
GOSUB FazisteretRajzol
GOTO ujsebesseg

'******************************************************************
Elojelek: '********************************************************
'******************************************************************

elsofugg = g / tengelytav * (hatsotav + gordeho * COS(dolesszog) * sulypmagassag) + eroosszeg * COS(dolesszog) * sulypmagassag / tengelytav
hatsofugg = g / tengelytav * (elsotav - gordeho * COS(dolesszog) * sulypmagassag) - eroosszeg * COS(dolesszog) * sulypmagassag / tengelytav
elsovizsz = (eroosszeg + gordeho * g) * SIN(dolesszog) * sulypmagassag / tengelytav + (sebesseg * COS(lejtoszog)) ^ 2 * vizszgorb * hatsotav / tengelytav
hatsovizsz = -(eroosszeg + gordeho * g) * SIN(dolesszog) * sulypmagassag / tengelytav + (sebesseg * COS(lejtoszog)) ^ 2 * vizszgorb * elsotav / tengelytav
nyomase = elsofugg * COS(oldalszog) + elsovizsz * SIN(oldalszog)
nyomash = hatsofugg * COS(oldalszog) + hatsovizsz * SIN(oldalszog)
ferdeoldale = -elsofugg * SIN(oldalszog) + elsovizsz * COS(oldalszog)
ferdeoldalh = -hatsofugg * SIN(oldalszog) + hatsovizsz * COS(oldalszog)
elsokritfek2 = SGN(nyomase) * (tapeho * nyomase) ^ 2 - ferdeoldale ^ 2
hatsokritfek2 = SGN(nyomash) * (tapeho * nyomash) ^ 2 - ferdeoldalh ^ 2
RETURN

'***********************************************************
FazisteretRajzol:   '***************************************
'***********************************************************
'nem felulnezeti, hanem valodi sebessegek es utak

LOCATE 1, 1: PRINT "maxfekero/umg="; INT(maxfekero / nyomoero / tapeho * 1000) / 1000; "    "
gurulogyors = g0 * SIN(lejtoszog) - legellteny * sebesseg ^ 2
guruloiranyszog = ATN(gurulogyors / sebesseg * sebszorzo / utszorzo)

fekez:
IF maxfekero < 0 THEN GOTO hajt
mingyors = gurulogyors - maxfekero
miniranyszog = ATN(mingyors / sebesseg * sebszorzo / utszorzo)
LINE (s * utszorzo, 451 - sebesseg * sebszorzo)-(s * utszorzo + fazistervonal * COS(miniranyszog), 451 - sebesseg * sebszorzo - fazistervonal * SIN(miniranyszog)), 4
'WRITE #1, -100, -100
'WRITE #1, s * utszorzo, sebesseg * sebszorzo - 1
'WRITE #1, s * utszorzo + fazistervonal * COS(miniranyszog), sebesseg * sebszorzo + fazistervonal * SIN(miniranyszog) - 1

hajt:
IF maxhajtoero < 0 THEN GOTO gurul
maxgyors = gurulogyors + maxhajtoero
maxiranyszog = ATN(maxgyors / sebesseg * sebszorzo / utszorzo)
LINE (s * utszorzo, 449 - sebesseg * sebszorzo)-(s * utszorzo + fazistervonal * COS(maxiranyszog), 449 - sebesseg * sebszorzo - fazistervonal * SIN(maxiranyszog)), 7
'WRITE #2, -100, -100
'WRITE #2, s * utszorzo, sebesseg * sebszorzo + 1
'WRITE #2, s * utszorzo + fazistervonal * COS(maxiranyszog), sebesseg * sebszorzo + fazistervonal * SIN(maxiranyszog) + 1

gurul:
LINE (s * utszorzo, 450 - sebesseg * sebszorzo)-(s * utszorzo + fazistervonal * COS(guruloiranyszog), 450 - sebesseg * sebszorzo - fazistervonal * SIN(guruloiranyszog)), 10
'WRITE #3, -100, -100
'WRITE #3, s * utszorzo + fazistervonal * COS(guruloiranyszog), sebesseg * sebszorzo + fazistervonal * SIN(guruloiranyszog)
'WRITE #3, s * utszorzo, sebesseg * sebszorzo
RETURN

e:
'CLOSE #1: CLOSE #2: CLOSE #3