<1>/* Graphics Not Rendered in HTML */



                <2>/* Graphics Not Rendered in HTML */







                <3>/* Graphics Not Rendered in HTML */




















                <4>/* Graphics Not Rendered in HTML */









                                                                 <5>/* Graphics Not Rendered in HTML */



























                                                                 <6>/* Graphics Not Rendered in HTML */












RegDefault("ZealOS/Varoom", "F64 best_score=9999;\n");
RegExe("ZealOS/Varoom");

F64  distance, t0, tf;
Bool game_over;

#define BORDER          7500
#define RADIUS          10000
#define WIDTH           2000
#define SHOULDER        200
#define D_theta                 (2 * pi / 360)  //Curve track slice is one degree.
#define D_S             (2 * pi * RADIUS / 360) //Straight track is degree at 10000.
#define DIPS            5
#define DIP_DEPTH       50
class Track
{
        Track                   *next, *last;
        I32                              num;
        CColorROPU16     c, pad;
        I64                              x, z;
        F64                              theta, d;
        CD3I32                   left[4], center[4], right[4];

} track_head, *track_start[MP_PROCESSORS_NUM], *track_end[MP_PROCESSORS_NUM];

CDC *track_map;
#define MAP_BITS        9
I64  t_minx, t_maxx, t_minz, t_maxz;

#define BUSHES_NUM      512
class Bush
{
        CD3I32   p;
        Bool     sym, pad[3];
        U8              *img;

} b[BUSHES_NUM];

#define CARS_NUM        8
class Car
{
        CD3I32   p;
        F64              theta, dtheta, speed;
        U8              *img;
        Track   *t;

} c[CARS_NUM];

I64 DipY(I64 x, I64 z)
{
        F64 m, a;

        R2P(&m, &a, x, z);

        return DIP_DEPTH * m * Cos(DIPS * a) / RADIUS;
}

#define CAR_LENGTH      400

F64 Diptheta(I64 x, I64 z, F64 theta)
{
        F64 y_front, y_back;

        y_front = DipY(x - CAR_LENGTH / 2 * Cos(theta), z - CAR_LENGTH / 2 * Sin(theta));
        y_back  = DipY(x + CAR_LENGTH / 2 * Cos(theta), z + CAR_LENGTH / 2 * Sin(theta));

        return ASin((y_front - y_back) / CAR_LENGTH);
}

Track *TrackFind(Track *_tmpt, I64 x, I64 z)
{
        Track   *res = _tmpt, *tmpt;
        I64              dd, best = SqrI64(res->x - x) + SqrI64(res->z - z);

        tmpt = _tmpt;
        while (TRUE)
        {
                tmpt = tmpt->next;
                if (tmpt == &track_head)
                        tmpt = tmpt->next;
                dd = SqrI64(tmpt->x - x) + SqrI64(tmpt->z - z);
                if (dd < best)
                {
                        best = dd;
                        res = tmpt;
                }
                else
                        break;
        }
        tmpt = _tmpt;
        while (TRUE)
        {
                tmpt = tmpt->last;
                if (tmpt == &track_head)
                        tmpt = tmpt->last;
                dd = SqrI64(tmpt->x - x) + SqrI64(tmpt->z - z);
                if (dd < best)
                {
                        best = dd;
                        res = tmpt;
                }
                else
                        break;
        }

        return res;
}

U0 TrackSlice(F64 *_x, F64 *_z, F64 theta, F64 d)
{
        F64              x = *_x, z = *_z, c = Cos(theta), s = Sin(theta), dx = d * s, dz = -d * c;
        Track   *tmpt, *last = track_head.last;

        if (last == &track_head)
                last = NULL;

        tmpt =CAlloc(sizeof(Track));
        if (last)
        {
                MemCopy(&tmpt->center[0], &last->center[3], sizeof(CD3I32));
                MemCopy(&tmpt->center[1], &last->center[2], sizeof(CD3I32));
        }
        tmpt->center[2].x = x + (WIDTH / 2) * c + dx;
        tmpt->center[2].z = z + (WIDTH / 2) * s + dz;
        tmpt->center[2].y = DipY(tmpt->center[2].x, tmpt->center[2].z);
        tmpt->center[3].x = x - (WIDTH / 2) * c + dx;
        tmpt->center[3].z = z - (WIDTH / 2) * s + dz;
        tmpt->center[3].y = DipY(tmpt->center[3].x, tmpt->center[3].z);

        if (last)
        {
                MemCopy(&tmpt->left[0], &last->left[3], sizeof(CD3I32));
                MemCopy(&tmpt->left[1], &last->left[2], sizeof(CD3I32));
        }
        tmpt->left[2].x = x - (WIDTH / 2) * c + dx;
        tmpt->left[2].z = z - (WIDTH / 2) * s + dz;
        tmpt->left[2].y = DipY(tmpt->left[2].x, tmpt->left[2].z);
        tmpt->left[3].x = x - (WIDTH / 2 + SHOULDER) * c + dx;
        tmpt->left[3].z = z - (WIDTH / 2 + SHOULDER) * s + dz;
        tmpt->left[3].y = DipY(tmpt->left[3].x, tmpt->left[3].z);

        if (last)
        {
                MemCopy(&tmpt->right[0], &last->right[3], sizeof(CD3I32));
                MemCopy(&tmpt->right[1], &last->right[2], sizeof(CD3I32));
        }
        tmpt->right[2].x = x + (WIDTH / 2 + SHOULDER) * c + dx;
        tmpt->right[2].z = z + (WIDTH / 2 + SHOULDER) * s + dz;
        tmpt->right[2].y = DipY(tmpt->right[2].x, tmpt->right[2].z);
        tmpt->right[3].x = x + (WIDTH / 2) * c + dx;
        tmpt->right[3].z = z + (WIDTH / 2) * s + dz;
        tmpt->right[3].y = DipY(tmpt->right[3].x, tmpt->right[3].z);

        tmpt->x         = x;
        tmpt->z         = z;
        tmpt->theta             = theta;
        tmpt->num       = track_head.last->num + 1;
        tmpt->d         = track_head.last->d + d;

        QueueInsert(tmpt, track_head.last);

        if (tmpt->num & 1)
                tmpt->c = RED;
        else
                tmpt->c = WHITE;

        if (x < t_minx)
                t_minx = x;

        if (x > t_maxx)
                t_maxx = x;

        if (z < t_minz)
                t_minz = z;

        if (z > t_maxz)
                t_maxz = z;

        x += dx;
        *_x = x;
        z += dz;
        *_z = z;

        if (x < t_minx)
                t_minx = x;

        if (x > t_maxx)
                t_maxx = x;

        if (z < t_minz)
                t_minz = z;

        if (z > t_maxz)
                t_maxz = z;
}

U0 CoupleEnds()
{
        Track *first = track_head.next, *last = track_head.last;

        MemCopy(&first->center[0], &last->center[3], sizeof(CD3I32));
        MemCopy(&first->center[1], &last->center[2], sizeof(CD3I32));
        MemCopy(&first->left[0],   &last->left[3],       sizeof(CD3I32));
        MemCopy(&first->left[1],   &last->left[2],       sizeof(CD3I32));
        MemCopy(&first->right[0],  &last->right[3],  sizeof(CD3I32));
        MemCopy(&first->right[1],  &last->right[2],  sizeof(CD3I32));
}

U0 InitTrack()
{
        I64              i, j;
        Track   *tmpt;
        F64              x, z, theta, d;

        MemSet(&track_head, 0, sizeof(Track));
        QueueInit(&track_head);

        t_minx = t_minz = I64_MAX;
        t_maxx = t_maxz = I64_MIN;

        x = 0;
        z = 0;
        theta = 0;
        for (d = 0; d < 6 * RADIUS; d += D_S)
                TrackSlice(&x, &z, theta, D_S);

        for (i = 0; i < 180; i++, theta += D_theta)
                TrackSlice(&x, &z, theta, D_theta * RADIUS);

        for (d = 0; d < RADIUS; d += D_S)
                TrackSlice(&x, &z, theta, D_S);

        for (i = 0; i < 90; i++, theta -= D_theta)
                TrackSlice(&x, &z, theta, D_theta * RADIUS);

        for (i = 0; i < 180; i++, theta += D_theta)
                TrackSlice(&x, &z, theta, D_theta * RADIUS);

        for (i = 0; i < 90; i++, theta -= D_theta)
                TrackSlice(&x, &z, theta, D_theta * RADIUS);

        for (d = 0; d < RADIUS; d += D_S)
                TrackSlice(&x, &z, theta, D_S);

        for (i = 0; i < 180; i++, theta += D_theta)
                TrackSlice(&x, &z, theta, D_theta * RADIUS);

        CoupleEnds;

        tmpt = track_head.next;
        for (i = 0; i < mp_count; i++)
        {
                j = (i + 1) * track_head.last->num / mp_count + 1;
                track_start[i] = tmpt;
                while (tmpt != &track_head && tmpt->num != j)
                        tmpt = tmpt->next;
                track_end[i] = tmpt;
        }

        t_minx -= BORDER;
        t_minz -= BORDER;
        t_maxx += BORDER;
        t_maxz += BORDER;
        track_map = DCNew((t_maxx - t_minx + 1 << MAP_BITS - 1) >> MAP_BITS, (t_maxz - t_minz + 1 << MAP_BITS - 1) >> MAP_BITS);

        track_map->color = LTGRAY;
        GrRect(track_map, 0, 0, track_map->width, track_map->height);
        tmpt=track_head.next;
        track_map->color = YELLOW;
        track_map->thick = 3;
        while (tmpt != &track_head)
        {
                GrPlot3(track_map, track_map->width - (tmpt->x - t_minx) >> MAP_BITS, (tmpt->z - t_minz) >> MAP_BITS, 0);
                tmpt = tmpt->next;
        }
}

#define HORIZON_DIP             200

Bool PrepPoly(CD3I32 *p, I64 *r, I64 cx, I64 h, CD3I32 *poly)
{
        I64 x, y, z, i;
        F64 s;

        for (i = 0; i < 4; i++)
        {
                x = p[i].x - c[0].p.x;
                y = p[i].y - c[0].p.y;
                z = p[i].z - c[0].p.z;
                Mat4x4MulXYZ(r, &x, &y, &z);
                s = 100.0 / (AbsI64(z) + 50);
                poly[i].y = s * y + h;
                if (z < -200 || !(-h < poly[i].y < 2 * h))
                        return FALSE;
                poly[i].x = s * x + cx;
                poly[i].z = z + GR_Z_ALL;
        }

        return TRUE;
}

I64 mp_not_done_flags;

U0 MPUpdateWin(CDC *dc2)
{
        CTask   *task = dc2->win_task;
        I64      i, x, y, z, w = task->pix_width, h = task->pix_height, r[16], cx = w >> 1;
        F64      s, dip_theta = Diptheta(c[0].p.x, c[0].p.z, c[0].theta);
        Car     *tmpc;
        CD3I32   poly[4];
        Track   *tmpt, *tmpt1;
        CDC     *dc = DCAlias(gr.dc2, task);

        Mat4x4IdentEqu(r);
        Mat4x4RotY(r, pi - c[0].theta);
        Mat4x4RotX(r, 75 * pi / 180 - dip_theta);

        dc->depth_buf = dc2->depth_buf;

        //Track
        tmpt  = track_start[Gs->num];
        tmpt1 = track_end  [Gs->num];
        while (tmpt != tmpt1)
        {
                dc->color = DKGRAY;
                if (PrepPoly(&tmpt->center, r, cx, h, poly))
                {
                        GrFillPoly3(dc, 4, poly);
                        dc->color = tmpt->c;
                        if (PrepPoly(&tmpt->left, r, cx, h, poly))
                                GrFillPoly3(dc, 4, poly);
                        if (PrepPoly(&tmpt->right, r, cx, h, poly))
                                GrFillPoly3(dc, 4, poly);
                }
                tmpt = tmpt->next;
        }

        dc->flags |= DCF_TRANSFORMATION;
        for (i = Gs->num; i < BUSHES_NUM; i += mp_count)
        {
                x = b[i].p.x - c[0].p.x;
                y = b[i].p.y - c[0].p.y;
                z = b[i].p.z - c[0].p.z;
                Mat4x4MulXYZ(r, &x, &y, &z);
                if (z > 0)
                {
                        s = 100.0 / (AbsI64(z) + 50);
                        Mat4x4IdentEqu(dc->r);
                        Mat4x4Scale(dc->r, s * 2);
                        DCMat4x4Set(dc, dc->r);
                        if (b[i].sym)
                        {
                                dc->flags |= DCF_SYMMETRY | DCF_JUST_MIRROR;
                                DCSymmetrySet(dc, s * x + cx, s * y + h, s * x + cx, s * y + h + 10);
                        }
                        Sprite3B(dc, s * x + cx, s * y + h, z + GR_Z_ALL, b[i].img);
                        dc->flags&=~(DCF_SYMMETRY | DCF_JUST_MIRROR);
                }
        }
        for (i = Gs->num + 1; i < CARS_NUM; i += mp_count)
        {
                tmpc = &c[i];
                x = tmpc->p.x - c[0].p.x;
                y = tmpc->p.y - c[0].p.y;
                z = tmpc->p.z - c[0].p.z;
                Mat4x4MulXYZ(r, &x, &y, &z);
                if (z > 0)
                {
                        s = 100.0 / (AbsI64(z) + 50);
                        Mat4x4IdentEqu(dc->r);
                        Mat4x4Scale(dc->r, s * 2);
                        Mat4x4RotX(dc->r, Diptheta(tmpc->p.x, tmpc->p.z, -tmpc->theta));
                        Mat4x4RotY(dc->r, tmpc->theta - c[0].theta);
                        DCMat4x4Set(dc, dc->r);
                        Sprite3B(dc, s * x + cx, s * y + h, z + GR_Z_ALL, tmpc->img);
                }
        }
        dc->depth_buf = NULL;
        DCDel(dc);
        LBtr(&mp_not_done_flags, Gs->num);
}

U0 VRTransform(CDC *dc, I64 *x, I64 *y, I64 *z)
{
        I64 zz;

        Mat4x4MulXYZ(dc->r, x, y, z);
        zz = 400 + *z;
        if (zz < 1)
                zz = 1;
        *x = 400 * *x / zz;
        *y = 400 * *y / zz;
        *x += dc->x;
        *y += dc->y;
        *z += dc->z;
}

U0 DrawIt(CTask *task, CDC *dc)
{
        I64      i, x, y, z, 
                         w = task->pix_width, 
                         h = task->pix_height, r[16], 
                         cx = w >> 1;
        F64      s, dip_theta = Diptheta(c[0].p.x, c[0].p.z, c[0].theta);
        Car     *tmpc = &c[0];

        dc->color = LTCYAN;
        GrRect(dc, 0, 0, w, HORIZON_DIP * Sin(dip_theta) + FONT_HEIGHT * 4.5);

        Mat4x4IdentEqu(r);
        Mat4x4RotY(r, pi - c[0].theta);
        Mat4x4RotX(r, 75 * pi / 180 - dip_theta);

        DCDepthBufAlloc(dc);

        //Sun
        x = c[0].p.x;
        y = 0;
        z = 1000000 - c[0].p.z;
        Mat4x4MulXYZ(r, &x, &y, &z);
        s = 100.0 / (AbsI64(z) + 50);
        if (y < 0)
        {
                dc->color = BROWN;
                GrCircle(dc, s * x + cx, 15 + HORIZON_DIP * Sin(dip_theta), 15);
                dc->color = YELLOW;
                GrFloodFill(dc, s * x + cx, 15 + HORIZON_DIP * Sin(dip_theta));
        }

        mp_not_done_flags = 1 << mp_count - 1;
        for (i = 0; i < mp_count; i++)
                JobQueue(&MPUpdateWin, dc, i);
        while (mp_not_done_flags)
                Yield;

        Mat4x4IdentEqu(r);
        Mat4x4RotY(r, tmpc->dtheta);
        Mat4x4RotX(r, 0.4 - 8 * dip_theta); //Made this up
        dc->transform = &VRTransform;
        dc->x = task->pix_width >> 1;
        dc->y = task->pix_height - 150;
        dc->z = GR_Z_ALL;
        Sprite3Mat4x4B(dc, 0, 0, -100, c[0].img, r);

        //Map
        GrBlot(dc, w - track_map->width, h - track_map->height, track_map);

        dc->thick = 2;
        for (i = 0; i < CARS_NUM; i++)
        {
                if (i)
                        dc->color = LTPURPLE;
                else
                        dc->color = LTCYAN;
                GrPlot3(dc, w - (c[i].p.x - t_minx) >> MAP_BITS, h - track_map->height + (c[i].p.z - t_minz) >> MAP_BITS, 0);
        }

        if (game_over)
        {
                dc->color = LTRED;
                if (tf)
                {
                        s = tf - t0;
                        if (Blink)
                                GrPrint(dc, (w - FONT_WIDTH * 14) / 2, (h - FONT_HEIGHT) / 2, "Game Completed");
                }
                else
                {
                        s = 99.9;
                        if (Blink)
                                GrPrint(dc, (w - FONT_WIDTH * 9) / 2, (h - FONT_HEIGHT) / 2, "Game Over");
                }
        }
        else
                s = tS-t0;
        dc->color = BLACK;
        GrPrint(dc, 0, 0, "%0.1f%% Time:%0.2f Best:%0.2f", 100.0 * distance / track_head.last->d, s, best_score);
}

U0 AnimateTask(I64)
{
        Car     *tmpc;
        I64              i, x, z;
        Bool     on_track;
        Track   *tmpt, *tmpt2;

        while (TRUE)
        {
                if (!game_over)
                        Sound(12.0 * Log2(c[0].speed / 500 + 0.7));
                else
                        Sound;
                for (i = 0; i < CARS_NUM; i++)
                {
                        tmpc = &c[i];
                        tmpc->p.x -= 0.01 * tmpc->speed * Cos(tmpc->theta - pi / 2);
                        tmpc->p.z += 0.01 * tmpc->speed * Sin(tmpc->theta - pi / 2);
                        tmpt = TrackFind(tmpc->t, tmpc->p.x, tmpc->p.z);
                        if (i)
                        {
                                if (tmpt != tmpc->t)
                                {
                                        tmpt2 = tmpt->next;
                                        if (tmpt2 == &track_head)
                                                tmpt2 = tmpt2->next;
                                        tmpc->theta = Arg(-tmpt2->z + tmpc->p.z, -tmpt2->x + tmpc->p.x);
                                }
                        }
                        else
                        {
                                tmpc->theta += 0.01 * tmpc->dtheta;
                                x =track_map->width - (tmpc->p.x - t_minx) >> MAP_BITS;
                                z = (tmpc->p.z - t_minz) >> MAP_BITS;
                                if (GrPeek(track_map, x, z) != YELLOW)
                                {
                                        on_track = FALSE;
                                        tmpc->speed -= 0.01 * tmpc->speed;
                                        if (tmpc->speed < 0)
                                                tmpc->speed = 0;
                                }
                                else
                                        on_track = TRUE;
                        }
                        tmpc->t = tmpt;
                        tmpc->p.y = DipY(tmpc->p.x, tmpc->p.z);
                }
                if (!game_over && on_track)
                {
                        for (i = 1; i < CARS_NUM; i++)
                                if (D3I32DistSqr(&c[i].p, &c[0].p) < CAR_LENGTH >> 1 * CAR_LENGTH >> 1)
                                {
                                        game_over = TRUE;
                                        Noise(500, 22, 34);
                                        Sleep(500);
                                        break;
                                }
                        if (!game_over)
                        {
                                distance += 0.01 * c[0].speed;
                                if (distance > track_head.last->d && c[0].t->num < track_head.last->num >> 1)
                                {
                                        tf = tS;
                                        game_over = TRUE;
                                        Beep;
                                        if (tf - t0 < best_score)
                                        {
                                                best_score = tf - t0;
                                                Beep;
                                        }
                                }
                        }
                }
                Sleep(10);
        }
}

U8 *imgs[8]={<1>, <1>, <2>, <2>, <3>, <4>, <4>, <4>};


U0 InitBushes()
{
        Bush    *tmpb;
        I64              i, j, x, z;

        track_map->color = LTGREEN;
        track_map->thick = 1;
        for (i = 0; i < BUSHES_NUM; i++)
        {
                tmpb = &b[i];

ib_restart:
                tmpb->p.x = Rand * (t_maxx - t_minx) + t_minx;
                tmpb->p.z = Rand * (t_maxz - t_minz) + t_minz;
                x = track_map->width - (tmpb->p.x - t_minx) >> MAP_BITS;
                z = (tmpb->p.z - t_minz) >> MAP_BITS;
                for (j = 0; j < 8; j++)
                        if (GrPeek(track_map, x + gr_x_offsets[j], z + gr_y_offsets[j]) != LTGRAY)
                                goto ib_restart;

                GrPlot(track_map, x, z);
                tmpb->p.y = DipY(tmpb->p.x, tmpb->p.z);
                tmpb->sym = RandU16 & 1;
                tmpb->img = imgs[i & 7];
        }
}


U0 Init()
{
        Car     *tmpc;
        Track   *tmpt;
        F64      d;
        I64      i;

        InitTrack;
        InitBushes;
        tmpt = track_head.next;
        for (i = 0; i < CARS_NUM; i++)
        {
                tmpc = &c[i];
                tmpc->t         = tmpt;
                tmpc->p.x       = tmpt->x;
                tmpc->p.z       = tmpt->z;
                tmpc->p.y       = DipY(tmpc->p.x, tmpc->p.z);
                tmpc->theta             = -tmpt->theta;
                tmpc->dtheta    = 0;
                if (!i)
                {
                        tmpc->img       = <5>;
                        tmpc->speed     = 0;
                }
                else
                {
                        tmpc->img       = <6>;
                        tmpc->speed     = 2500.0;
                }
                d = (i + 1) * track_head.last->d / CARS_NUM;
                while (tmpt->next != &track_head && tmpt->d < d)
                        tmpt = tmpt->next;
        }
        distance = 0;
        tf = 0;
        t0 = tS;
        game_over = FALSE;
}

U0 CleanUp()
{
        while (mp_not_done_flags)
                Yield;
        QueueDel(&track_head, TRUE);
        DCDel(track_map);
}

U0 Varoom()
{
        I64 sc, last = counts.timer;

        Bool is_up_pressed;
        Bool is_down_pressed;
        Bool is_left_pressed;
        Bool is_right_pressed;
        Bool is_nl_pressed;
        Bool is_esc_pressed;

        Bool is_key_pressed;

        I64 sc_nl = Char2ScanCode('\n'); // scancode for typing newline

        MenuPush(
                                "File {"
                                "  Abort(,CH_SHIFT_ESC);"
                                "  Exit(,CH_ESC);"
                                "}"
                                "Play {"
                                "  Restart(,'\n');"
                                "  Accelerator(,,SC_CURSOR_UP);"
                                "  Brake(,,SC_CURSOR_DOWN);"
                                "  Left(,,SC_CURSOR_LEFT);"
                                "  Right(,,SC_CURSOR_RIGHT);"
                                "}"
                                );
        SettingsPush; //See SettingsPush
        try
        {
                Fs->text_attr = YELLOW << 4 + BLUE;
                Fs->win_inhibit = WIG_TASK_DEFAULT - WIF_SELF_FOCUS - WIF_SELF_GRAB_SCROLL - WIF_FOCUS_TASK_MENU;
                AutoComplete;
                WinBorder;
                WinMax;
                DocCursor;
                DocClear;
                Init;
                PaletteSetLight(FALSE);
                Fs->draw_it = &DrawIt;
                Fs->animate_task = Spawn(&AnimateTask, NULL, "Animate",, Fs);
                while (TRUE)
                {
                        is_up_pressed           = Bt(kbd.down_bitmap, SC_CURSOR_UP);
                        is_down_pressed         = Bt(kbd.down_bitmap, SC_CURSOR_DOWN);
                        is_left_pressed         = Bt(kbd.down_bitmap, SC_CURSOR_LEFT);
                        is_right_pressed        = Bt(kbd.down_bitmap, SC_CURSOR_RIGHT);
                        is_nl_pressed           = Bt(kbd.down_bitmap, sc_nl);
                        is_esc_pressed          = Bt(kbd.down_bitmap, SC_ESC);

                        if (is_left_pressed)    c[0].dtheta             -= .000003 * (counts.timer - last);
                        if (is_right_pressed)   c[0].dtheta             += .000003 * (counts.timer - last);
                        if (is_up_pressed)              c[0].speed  += .01 * (counts.timer - last);
                        if (is_down_pressed)
                        {
                                c[0].speed -= .03 * (counts.timer - last);
                                if (c[0].speed < 0)
                                        c[0].speed = 0;
                        }
                        if (is_nl_pressed)
                        {
                                CleanUp;
                                Init;
                        }
                        if (is_esc_pressed)
                                goto vr_done;

                        last = counts.timer;

                        LBts(&Fs->task_flags, TASKf_IDLE);
                        Yield;
                        LBtr(&Fs->task_flags, TASKf_IDLE);


/*                      switch (KeyGet(&sc))
                        {
                                case 0:
                                        switch (sc.u8[0])
                                        {

                                                case SC_CURSOR_LEFT:
                                                        c[0].dtheta -= pi / 60;
                                                        break;

                                                case SC_CURSOR_RIGHT:
                                                        c[0].dtheta += pi / 60;
                                                        break;

                                                case SC_CURSOR_UP:
                                                        c[0].speed += 300;
                                                        break;

                                                case SC_CURSOR_DOWN:
                                                        c[0].speed -= 900;
                                                        if (c[0].speed < 0)
                                                                c[0].speed = 0;
                                                        break;
                                        }
                                        break;
                                case '\n':
                                        CleanUp;
                                        Init;
                                        break;
                                case CH_SHIFT_ESC:
                                case CH_ESC:
                                        goto vr_done;
                        }
*/
                }
vr_done: //Don't goto out of try
        }
        catch
                PutExcept;
        SettingsPop;
        FlushMessages; // if Varoom included in Cmd line, fixes SHIFT_ESC quitting current cmd line.
        mp_not_done_flags = 0; // fix for CleanUp hanging on a Yield while loop ...
        CleanUp;
        MenuPop;
        RegWrite("ZealOS/Varoom", "F64 best_score=%5.4f;\n", best_score);
}

Varoom;