RegDefault("ZealOS/Titanium","I64 best_score=0;\n");
RegExe("ZealOS/Titanium");

#define MAP_HEIGHT      4096

#define B_LEN           10
#define B_SPEED         5
#define B_NUM           128
class Bullet
{
        I64  x, y, dx, dy, dx2, dy2;
        Bool dead, missile, pad[6];

} b[B_NUM];
I64 bullets_fired, missile_bmp;

I64 x, y, dx, dy, finish_line;
F64 theta, t0, tf, sound_timeout;

#define PHASES_GROUPS   8
#define HACK_DIST               5

#define U_ENEMY_NUM     (PHASES_GROUPS * 64)
#define U_FRIENDLY_NUM  (PHASES_GROUPS * 16)
#define U_NUM                   (U_FRIENDLY_NUM + U_ENEMY_NUM)
class Unit
{
        I64  x, y, best_dd;
        F64  theta, phase;
        Bool friendly, dead, tank, CIA, pad[4];

} u[U_NUM];

#define ET_MAN                  0
#define ET_TANK                 1
#define ET_MISSILE              2
#define ET_BUILDING     3
#define E_NUM                   512
class Explosion
{
        I64  x, y, num, type;
        F64  t0, tf;
        Bool dead, pad[7];

} e[E_NUM];

I64  total_score, friendly_fire, enemy_by_friendly, friendly_left, enemy_left, main_loop_pass;
Bool game_over;





                                <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 */



U8 *friendly_imgs[4] = {<5>, <4>, <5>, <6>};




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



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


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



U8 *CIA_neeger_imgs[4] = {<8>, <7>, <8>, <9>};




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




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




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




U8 *friendly_hacking_imgs[4] = {<10>, <11>, <10>, <12>};




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



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



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



U8 *enemy_imgs[4] = {<14>, <13>, <14>, <15>};




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




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




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











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









U8 *enemy_hacking_imgs[4] = {<17>, <16>, <17>, <18>};







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




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








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




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





#define LS_APTS_NUM             20
#define LS_MOUNTAINS_NUM        3
#define LS_NUM                          128
class LandScapeItem
{
        I64 x, y;
        U8 *img;

} ls[LS_NUM];

#define LS_TYPES                                4
U8 *landscape_imgs[LS_TYPES] = {<20>, <21>, <22>, <23>};

U0 ExplosionDraw(CDC *dc, Explosion *tmpe, I64 y)
{
        I64 i, n1, n2, n3, n4, n5;
        F64 t=(tS-tmpe->t0)/(tmpe->tf-tmpe->t0);

        Seed(tmpe->num + 1);

        switch (tmpe->type)
        {
                case ET_MAN:            n1 = 8;   n2 = 0;       n3 = 0;  n4 = 18;       n5 = 28;        break;
                case ET_TANK:           n1 = 64;  n2 = 14;      n3 = 24; n4 = 60;       n5 = 90;        break;
                case ET_MISSILE:        n1 = 128; n2 = 30;      n3 = 60; n4 = 100;      n5 = 200; break;
                case ET_BUILDING:       n1 = 128; n2 = 80;      n3 = 80; n4 = 200;      n5 = 300; break;
        }
        for (i = 0; i < n1; i++)
        {
                if (i & 2)
                        switch (tmpe->type)
                        {
                                case ET_MAN:
                                        if (i & 1)
                                                dc->color = WHITE;
                                        else
                                                dc->color = LTGRAY;
                                        break;

                                case ET_MISSILE:
                                        if (i & 1)
                                        {
                                                if (i & 4)
                                                        dc->color = RED;
                                                else
                                                        dc->color = DKGRAY;
                                        }
                                        else
                                                dc->color=YELLOW;
                                        break;

                                case ET_TANK:
                                        if (i & 1)
                                        {
                                                if (i & 4)
                                                        dc->color = RED;
                                                else
                                                        dc->color = DKGRAY;
                                        }
                                        else
                                                dc->color = LTRED;
                                        break;

                                case ET_BUILDING:
                                        if (i & 1)
                                        {
                                                if (i & 4)
                                                        dc->color = BLACK;
                                                else
                                                        dc->color = DKGRAY;
                                        }
                                        else
                                                dc->color = LTGRAY;
                                        break;
                        }
                else if (i & 1)
                        dc->color = WHITE;
                else
                        dc->color = LTGRAY;
                GrLine(dc, tmpe->x + n2 * (Rand - .5), y + n3 / 2 * Rand, tmpe->x + n4 * t * (Rand - .5), y - n5 / 2 * t * Rand);
        }
}

I64 mp_not_done_flags;
U0 MPMenDraw(CDC *dc2)
{
        CTask           *task = dc2->win_task;
        CDC                     *dc = DCAlias(dc2, task);
        I64                      i, r[16], lo = Gs->num * U_NUM / mp_count, hi = (Gs->num + 1) * U_NUM / mp_count, 
                                 yy, phase, scroll_y = MAP_HEIGHT - 100 - 100 * (tS - t0);
        Unit            *tmpu;
        Explosion       *tmpe;
        U8                      *tmps, **_tmps;
        F64                      tt, ts = tS;

        for (i = Gs->num; i < E_NUM; i += mp_count)
        {
                tmpe = &e[i];
                yy = (tmpe->y - scroll_y) & (MAP_HEIGHT - 1);
                if (-32 <= yy <= task->pix_bottom + 32 && !tmpe->dead)
                {
                        ExplosionDraw(dc, tmpe, yy);
                        if (tS > tmpe->tf)
                                tmpe->dead = TRUE;
                }
        }
        for (i = lo; i < hi; i++)
        {
                tmpu = &u[i];
                yy = (tmpu->y - scroll_y) & (MAP_HEIGHT - 1);
                if (-32 <= yy <= task->pix_bottom + 32)
                {
                        if (!tmpu->dead)
                        {
                                Mat4x4IdentEqu(r);
                                Mat4x4RotY(r, tmpu->theta);
                                Mat4x4RotX(r, pi / 6);
                                Mat4x4Scale(r, 0.3);
                                if (tmpu->tank)
                                        Sprite3Mat4x4B(dc, tmpu->x, yy, GR_Z_ALL, <19>, r);
                                else
                                {
                                        if (tmpu->best_dd < (2 * HACK_DIST) * (2 * HACK_DIST))
                                        {//It's neat so times 2
                                                if (tmpu->friendly)
                                                        _tmps = friendly_hacking_imgs;
                                                else
                                                        _tmps = enemy_hacking_imgs;
                                                tt = 4 * Wrap(tmpu->phase + 20 * ts, 0) / (2 * pi);
                                        }
                                        else
                                        {
                                                if (tmpu->friendly)
                                                {
                                                        if (tmpu->CIA && Blink)
                                                                _tmps = CIA_neeger_imgs;
                                                        else
                                                                _tmps = friendly_imgs;
                                                }
                                                else
                                                        _tmps = enemy_imgs;
                                                tt = 4 * Wrap(tmpu->phase + 5 * ts, 0) / (2 * pi);
                                        }
                                        phase = tt;
                                        tt %= 1.0;
                                        tmps = SpriteInterpolate(tt, _tmps[phase & 3], _tmps[(phase + 1) & 3]);
                                        Sprite3Mat4x4B(dc, tmpu->x, yy, GR_Z_ALL, tmps, r);
                                        Free(tmps);
                                }
                        }
                }
        }

        dc->depth_buf = NULL;
        DCDel(dc);
        LBtr(&mp_not_done_flags, Gs->num);
        Seed; //Return Executive task to timer-based.
}

U0 MissilePos(I64 m, F64 theta, I64 *_x, I64 *_y)
{
        I64 n;

        if (m < 2)
                n = -1;
        else
                n = 1;
        *_x = x + 3.0 * Cos(theta) - (15.0 - (m & 1) << 3) * Cos(theta - n * pi / 2);
        *_y = y + 3.0 * Sin(theta) - (15.0 - (m & 1) << 3) * Sin(theta - n * pi / 2);
}

U0 DrawIt(CTask *task, CDC *dc)
{
        I64              i, m, xx, yy, scroll_y = MAP_HEIGHT - 100 - 100 * (tS - t0);
        F64              tt, ts = tS;
        Bullet  *tmpb;

        dc->color = ROPF_DITHER | BROWN << 16 | YELLOW;
        GrRect3(dc, 0, 0, 0, dc->width, dc->height);

        for (i = 0; i < LS_NUM; i++)
        {
                yy = (ls[i].y - scroll_y) & (MAP_HEIGHT - 1);
                if (-32 <= yy <= task->pix_bottom + 32)
                        Sprite3(dc, ls[i].x, yy, 0, ls[i].img);
        }

        dc->thick = 3;
        dc->color = BROWN;
        GrLine3(dc, 0,   (finish_line - scroll_y) & (MAP_HEIGHT - 1), 0, GR_WIDTH,
                                         (finish_line - scroll_y) & (MAP_HEIGHT - 1), 0);

        dc->color = LTGRAY;
        for (i = 0, tmpb = b; i < B_NUM; i++, tmpb++)
                if (!tmpb->dead)
                {
                        if (tmpb->missile)
                                Sprite3ZB(dc, tmpb->x >> 32, tmpb->y >> 32, 0, <2>, pi / 2 + Arg(tmpb->dx, tmpb->dy));
                        else
                                GrLine(dc, tmpb->x >> 32, tmpb->y >> 32, 
                                                        (tmpb->x + tmpb->dy * B_LEN) >> 32, 
                                                        (tmpb->y + tmpb->dx * B_LEN) >> 32);
                }

        DCDepthBufAlloc(dc);
        mp_not_done_flags = 1 << mp_count - 1;
        for (i = 0; i < mp_count; i++)
                JobQueue(&MPMenDraw, dc, i);
        while (mp_not_done_flags)
                Yield;
        Free(dc->depth_buf);
        dc->depth_buf = NULL;

        for (m = 0; m < 4; m++)
                if (Bt(&missile_bmp, m))
                {
                        MissilePos(m, theta, &xx, &yy);
                        Sprite3ZB(dc, xx, yy, 0, <3>, theta);
                }
        Sprite3ZB(dc, x, y, 0, <1>, theta);

        if (tf)
        {
                tt = tf;
                dc->color = RED;
                if (game_over && Blink)
                        GrPrint(dc, task->pix_width / 2 - 9 * FONT_WIDTH / 2, task->pix_height / 2, "Game Over");
        }
        else
        {
                tt = ts;
                if (!enemy_left || !friendly_left)
                        game_over = TRUE;
        }
        dc->color = BLACK;
        GrPrint(dc, 0, 0, "Enemy:%d Friends:%d Friendly Fire:%d Time:%6.2f Bullets:%d", 
                                enemy_left, friendly_left, friendly_fire, tt-t0, bullets_fired);
        GrPrint(dc, 0, 8, "Total Score:%,d High Score:%,d", total_score, best_score);
}

Explosion *ExplosionNew(I64 x, I64 y)
{
        I64 i;

        for (i = 0; i < E_NUM; i++)
                if (e[i].dead)
                {
                        e[i].x = x;
                        e[i].y = y;
                        e[i].dead = FALSE;
                        return &e[i];
                }

        return NULL;
}

U0 ManDie(Unit *tmpu, Bool by_human)
{
        Explosion *tmpe;

        tmpu->dead = TRUE;
        if (by_human)
        {
                if (tmpe = ExplosionNew(tmpu->x, tmpu->y))
                {
                        tmpe->t0 = tS;
                        if (tmpu->tank)
                        {
                                tmpe->type = ET_TANK;
                                tmpe->tf = tmpe->t0 + 0.40;
                        }
                        else
                        {
                                tmpe->type = ET_MAN;
                                tmpe->tf = tmpe->t0 + 0.20;
                        }
                }
        }

        if (tmpu->friendly)
        {
                friendly_left--;
                if (by_human)
                        friendly_fire++;
        }
        else
        {
                enemy_left--;
                if (!by_human)
                        enemy_by_friendly++;
        }
        if (by_human && !sound_timeout)
        {
                sound_timeout = tS + 0.01;
                if (tmpu->friendly)
                        Sound(46);
                else
                        Sound(22);
        }
}

U0 ExplosionDo(I64 x, I64 y, I64 scroll_y)
{
        I64                      i, x2, y2;
        Explosion       *tmpe;
        Unit            *tmpu;

        if (tmpe = ExplosionNew(x, y + scroll_y))
        {
                tmpe->t0 = tS;
                tmpe->type = ET_MISSILE;
                tmpe->tf = tmpe->t0 + 1.0;
        }
        for (i = 0, tmpu = u; i < U_NUM; i++, tmpu++)
        {
                if (!tmpu->dead)
                {
                        x2 = tmpu->x;
                        y2 = (tmpu->y - scroll_y) & (MAP_HEIGHT - 1);
                        if (SqrI64(x - x2) + SqrI64(y - y2) < 100 * 100)
                                ManDie(tmpu, TRUE);
                }
        }
        for (i = 0; i < LS_APTS_NUM; i++)
        {
                x2 = ls[i].x;
                y2 = (ls[i].y - scroll_y) & (MAP_HEIGHT - 1);
                if (SqrI64(x-x2)+SqrI64(y-y2)<100*100)
                {
                        if (tmpe = ExplosionNew(x2, y2 + scroll_y))
                        {
                                tmpe->t0 = tS;
                                tmpe->type = ET_BUILDING;
                                tmpe->tf = tmpe->t0 + 2.0;
                        }
                }
        }
}

U0 CheckCollisions()
{
        I64              i, n1, x, y, scroll_y = MAP_HEIGHT - 100 - 100 * (tS - t0);
        Unit    *tmpu;
        Bullet  *tmpb;
        CDC     *dc2 = DCNew(GR_WIDTH, GR_HEIGHT);

        dc2->color = LTRED;
        for (i = 0, tmpb = b; i < B_NUM; i++, tmpb++)
                if (!tmpb->dead && !tmpb->missile)      //Bullets not missiles
                        GrLine(dc2, tmpb->x >> 32, tmpb->y >> 32, 
                                                (tmpb->x + tmpb->dx * B_LEN) >> 32, 
                                                (tmpb->y + tmpb->dy * B_LEN) >> 32);

        dc2->color       = ROP_COLLISION;
        dc2->bkcolor = BLACK;
        for (i = 0, tmpu = u; i < U_NUM; i++, tmpu++)
        {
                if (!tmpu->dead)
                {
                        x = tmpu->x;
                        y = (tmpu->y - scroll_y) & (MAP_HEIGHT - 1);
                        if (0 <= x < GR_WIDTH && 0 <= y < GR_HEIGHT)
                        {
                                dc2->collision_count = 0;
                                GrRect(dc2, x - 3, y - 9, 6, 8);
                                if (dc2->collision_count)
                                        ManDie(tmpu, TRUE);
                        }
                }
        }
        DCDel(dc2);

        for (i = 0, tmpb = b; i < B_NUM; i++, tmpb++)
                if (!tmpb->dead && tmpb->missile) 
                { //Missiles not bullets
                        x = tmpb->x >> 32;
                        y = tmpb->y >> 32;
                        for (i = 0, tmpu = u; i < U_NUM; i++, tmpu++)
                        {
                                if (tmpu->tank)
                                        n1 = 16;
                                else
                                        n1 = 6;
                                if (!tmpu->dead &&
                                        AbsI64(x - tmpu->x - n1) + AbsI64(y - (tmpu->y - scroll_y) & (MAP_HEIGHT - 1) + n1) < n1 << 1)
                                {
                                        tmpb->dead = TRUE;
                                        ExplosionDo(x, y, scroll_y);
                                }
                        }
                        if (!tmpb->dead)
                                for (i = 0; i < LS_APTS_NUM; i++)
                                        if (2 * SqrI64(x - ls[i].x) + 3 * SqrI64(y + 35 - (ls[i].y - scroll_y) & (MAP_HEIGHT - 1)) < 2 * 60 * 60)
                                        {
                                                tmpb->dead = TRUE;
                                                ExplosionDo(x, y, scroll_y);
                                        }
                }
}

U0 Init()
{
        I64   i, xx, yy, scroll_y = MAP_HEIGHT - 100;
        Unit *tmpu;

        sound_timeout = 0;
        Sound;

        total_score = 0;
        game_over = FALSE;
        main_loop_pass = 0;

        x = Fs->pix_width >> 1;
        y = 0.9 * Fs->pix_height;
        finish_line = scroll_y + y;
        dx = 0;
        dy = 0;
        theta = -pi / 2;

        for (i = 0; i < LS_NUM; i++)
        {
                ls[i].x = (Fs->pix_width - 100) * RandU32 / U32_MAX + 50;
                ls[i].y = (MAP_HEIGHT    - 100) * RandU32 / U32_MAX + 50;
                ls[i].img = landscape_imgs[RandU16 % (LS_TYPES - 2)];
        }

        for (i = 0; i < LS_APTS_NUM; i++)
                ls[i].img = landscape_imgs[LS_TYPES - 1]; //Apartment

        for (; i < LS_APTS_NUM + LS_MOUNTAINS_NUM; i++)
                ls[i].img = landscape_imgs[LS_TYPES - 2]; //mountain

        MemSet(u, 0, sizeof(u));
        for (i = 0, tmpu = u; i < U_NUM; i++, tmpu++)
        {
                if (i < U_FRIENDLY_NUM)
                {
                        tmpu->friendly = TRUE;
                        if (!(i & 7))
                        {
                                xx = (Fs->pix_width - 200) * RandU32 / U32_MAX;
                                yy = (MAP_HEIGHT        - 200) * RandU32 / U32_MAX;
                        }
                        if (!(i & 63))
                                tmpu->CIA = TRUE;
                        else
                                tmpu->CIA = FALSE;
                }
                else
                {
                        tmpu->friendly = FALSE;
                        if (!(i & 31))
                        {
                                xx = (Fs->pix_width - 200) * RandU32 / U32_MAX;
                                yy = (MAP_HEIGHT        - 200) * RandU32 / U32_MAX;
                        }
                        if (!(i & 15))
                                tmpu->tank = TRUE;
                }
                tmpu->dead              = FALSE;
                tmpu->x                 = xx + 64 * RandI32 / I32_MAX + 100;
                tmpu->y                 = yy + 64 * RandU32 / I32_MAX - 64 + 100;
                tmpu->best_dd   = I64_MAX;
                tmpu->theta                     = pi / 2;
                tmpu->phase             = 2 * pi * Rand;
        }
        for (i = 0; i < B_NUM; i++)
                b[i].dead = TRUE;
        for (i = 0; i < E_NUM; i++)
        {
                e[i].dead = TRUE;
                e[i].num = i;
        }
        friendly_left = U_FRIENDLY_NUM;
        enemy_left        = U_ENEMY_NUM;
        enemy_by_friendly = 0;
        bullets_fired =0;
        missile_bmp = 15;
        friendly_fire = 0;
        t0 = tS;
        tf = 0;
}

U0 FireBullet()
{
        I64              i, j;
        F64              a;
        Bullet  *tmpb;

        for (i = 0; i < B_NUM - 1; i++)
                if (b[i].dead)
                        break;
        tmpb = &b[i];

        j = x + 28.0 * Cos(theta);
        tmpb->x = j << 32;
        j = y + 28.0 * Sin(theta);
        tmpb->y = j << 32;

        tmpb->dx2 = (B_SPEED * Cos(theta) + dx) * 0x100000000;
        tmpb->dy2 =  B_SPEED * Sin(theta) * 0x100000000;
        a = Arg(tmpb->dx2, tmpb->dy2);
        tmpb->dx = Sin(a) * 0x100000000;
        tmpb->dy = Cos(a) * 0x100000000;
        bullets_fired++;
        tmpb->dead = FALSE;
        tmpb->missile = FALSE;
        if (!sound_timeout)
        {
                sound_timeout = tS + 0.0005;
                Sound(74);
        }
}

Bool FireMissile(I64 n)
{
        I64              i, m;
        F64              a;
        Bullet  *tmpb;
        Bool     res = FALSE;

        m = n;
        if (Btr(&missile_bmp, ++m) || Btr(&missile_bmp, ++m))
                res = TRUE;

        if (res)
        {
                for (i = 0; i < B_NUM - 1; i++)
                        if (b[i].dead)
                                break;
                tmpb = &b[i];

                MissilePos(m, theta, &tmpb->x, &tmpb->y);
                tmpb->x <<= 32;
                tmpb->y <<= 32;

                tmpb->dx2 = (B_SPEED * Cos(theta) + dx) * 0x100000000;
                tmpb->dy2 =  B_SPEED * Sin(theta) * 0x100000000;
                a=Arg(tmpb->dx2, tmpb->dy2);
                tmpb->dx = Sin(a) * 0x100000000;
                tmpb->dy = Cos(a) * 0x100000000;
                tmpb->dead = FALSE;
                tmpb->missile = TRUE;
                if (!sound_timeout)
                {
                        sound_timeout = tS + 0.0005;
                        Sound(74);
                }
        }
}

U0 MenMove(I64 phase_group)
{
        I64 i, j, dd, best, best_dd;

        for (i = phase_group; i < U_FRIENDLY_NUM; i += PHASES_GROUPS)
        {
                if (!u[i].dead)
                {
                        best = U_FRIENDLY_NUM;
                        best_dd = I64_MAX;
                        for (j = U_FRIENDLY_NUM; j < U_NUM; j++)
                        {
                                if (!u[j].dead)
                                {
                                        dd = SqrI64(u[i].x - u[j].x) + SqrI64(u[i].y - u[j].y);
                                        if (dd < best_dd)
                                        {
                                                best_dd = dd;
                                                best = j;
                                        }
                                }
                        }
                        u[i].best_dd = best_dd;
                        if (best_dd != I64_MAX)
                        {
                                u[i].x += 4 * SignI64(u[best].x - u[i].x);
                                u[i].y += 4 * SignI64(u[best].y - u[i].y);
                                u[i].theta = Arg(u[best].x - u[i].x, u[best].y - u[i].y);
                        }
                }
        }
        for (i = U_FRIENDLY_NUM + phase_group; i < U_NUM; i += PHASES_GROUPS)
        {
                if (!u[i].dead)
                {
                        best = 0;
                        best_dd = I64_MAX;
                        for (j = 0; j < U_FRIENDLY_NUM; j++)
                        {
                                if (!u[j].dead)
                                {
                                        dd = SqrI64(u[i].x - u[j].x) + SqrI64(u[i].y - u[j].y);
                                        if (dd < best_dd)
                                        {
                                                best_dd = dd;
                                                best = j;
                                        }
                                }
                        }
                        u[i].best_dd = best_dd;
                        if (best_dd != I64_MAX)
                        {
                                u[i].x += 4 * SignI64(u[best].x - u[i].x);
                                u[i].y += 4 * SignI64(u[best].y - u[i].y);
                                u[i].theta = Arg(u[best].x - u[i].x, u[best].y - u[i].y);
                        }
                }
        }
}

U0 MenFight(I64 phase_group)
{
        I64 i, j, dd, best, best_dd;

        for (i = phase_group; i < U_FRIENDLY_NUM; i += PHASES_GROUPS)
        {
                if (!u[i].dead)
                {
                        best = U_FRIENDLY_NUM;
                        best_dd = I64_MAX;
                        for (j = U_FRIENDLY_NUM; j < U_NUM; j++)
                        {
                                if (!u[j].dead && u[i].y - u[j].y < 8)
                                {
                                        dd = SqrI64(u[i].x - u[j].x) + SqrI64(u[i].y - u[j].y);
                                        if (dd < best_dd)
                                        {
                                                best_dd = dd;
                                                best = j;
                                        }
                                }
                        }
                        u[i].best_dd = best_dd;
                        if (best_dd < HACK_DIST * HACK_DIST && !(RandU16 & 1))
                                ManDie(&u[best], FALSE);
                }
        }
        for (i = U_FRIENDLY_NUM + phase_group; i < U_NUM; i += PHASES_GROUPS)
        {
                if (!u[i].dead)
                {
                        best = 0;
                        best_dd = I64_MAX;
                        for (j = 0; j < U_FRIENDLY_NUM; j++)
                        {
                                if (!u[j].dead&& u[i].y - u[j].y < 8)
                                {
                                        dd = SqrI64(u[i].x - u[j].x) + SqrI64(u[i].y - u[j].y);
                                        if (dd < best_dd)
                                        {
                                                best_dd = dd;
                                                best = j;
                                        }
                                }
                        }
                        u[i].best_dd = best_dd;
                        if (best_dd < HACK_DIST * HACK_DIST && !(RandU16 & 1))
                                ManDie(&u[best], FALSE);
                }
        }
}

U0 Titanium()
{
        I64  i, message_code, ch, sc;
        Bool gun_on;

        I64 next_update_jiffy;
        SettingsPush; //See SettingsPush

        MenuPush(       "File {"
                                "  Abort(,CH_SHIFT_ESC);"
                                "  Exit(,CH_ESC);"
                                "}"
                                "Play {"
                                "  Restart(,'\n');"
                                "  Fire(,CH_SPACE);"
                                "  Left(,,SC_CURSOR_LEFT);"
                                "  Right(,,SC_CURSOR_RIGHT);"
                                "  LeftMissile(,,SC_CURSOR_LEFT|SCF_CTRL);"
                                "  RightMissile(,,SC_CURSOR_RIGHT|SCF_CTRL);"
                                "}"
                                );
        AutoComplete;
        WinBorder;
        WinMax;
        DocCursor;
        DocClear;

        "\nScoring:\n"
                                "\tEnemy Killed\t\t+3\n"
                                "\tEnemy by Friendly\t+5\n"
                                "\tFriendly Fire\t\t-100\n"
                                "\tBullets Fired\t\t-1\n"
                                "\tGame Time\t\t-10 per second\n"
                                "\tSurviving Friendlies\t+250\n\n"
                                "Sweep side-to-side while shooting, "
                                "holding down $GREEN$<SPACE>$FG$.\n\n";
        PressAKey;

        Init;
        DocClear;
        Fs->draw_it = &DrawIt;

        gun_on = FALSE;

        try
        {
                while (TRUE)
                {
                        next_update_jiffy = counts.jiffies + JIFFY_FREQ / 100;
                        while (message_code = MessageScan(&ch, &sc, 1 << MESSAGE_KEY_DOWN + 1 << MESSAGE_KEY_UP))
                        {
                                switch (message_code)
                                {
                                        case MESSAGE_KEY_DOWN:
                                                switch (ch)
                                                {
                                                        case 0:
                                                                switch (sc.u8[0])
                                                                {
                                                                        case SC_CURSOR_RIGHT:
                                                                                if (sc & SCF_CTRL)
                                                                                        FireMissile(1);
                                                                                break;

                                                                        case SC_CURSOR_LEFT:
                                                                                if (sc & SCF_CTRL)
                                                                                        FireMissile(-1);
                                                                                break;
                                                                }
                                                                break;

                                                        case CH_SHIFT_ESC:
                                                        case CH_ESC:
                                                                goto to_done;

                                                        case '\n':
                                                                Init;
                                                                break;

                                                        case CH_SPACE:
                                                                gun_on = TRUE;
                                                                break;
                                                }
                                                break;

                                        case MESSAGE_KEY_UP:
                                                if (ch == CH_SPACE)
                                                        gun_on = FALSE;
                                                else if (sc.u8[0] == SC_CURSOR_RIGHT || sc.u8[0] == SC_CURSOR_LEFT)
                                                        theta = -pi / 2;
                                                break;
                                }
                        }

                        for (i = 0; i < B_NUM; i++)
                        {
                                if (!b[i].dead)
                                {
                                        b[i].x += b[i].dx2;
                                        b[i].y += b[i].dy2;
                                        if (b[i].y < 0 || b[i].x < 0 || b[i].x >> 32 >= Fs->pix_width || b[i].y >> 32 >= Fs->pix_height)
                                                b[i].dead = TRUE;
                                }
                        }

                        dx = 0;
                        if (!Bt(kbd.down_bitmap, SC_CTRL))
                        {
                                if (Bt(kbd.down_bitmap, SC_CURSOR_LEFT))
                                {
                                        theta = -pi / 2 - 15.0 * pi / 180.0;
                                        dx = -2;
                                }
                                else if (Bt(kbd.down_bitmap, SC_CURSOR_RIGHT))
                                {
                                        theta = -pi / 2 + 15.0 * pi / 180.0;
                                        dx = 2;
                                }
                        }
                        x += dx;
                        while (x >= Fs->pix_width)
                                x -= Fs->pix_width;
                        while (x < 0)
                                x += Fs->pix_width;

                        //It takes too much CPU do do all these all the time.
                        switch [main_loop_pass & 7]
                        {
                                case 0:
                                        switch [main_loop_pass >> 3 & 7]
                                        {
                                                case 0:
                                                        if (--y < 20)
                                                                game_over = TRUE;
                                                case 2:
                                                case 4:
                                                case 6:
                                                        MenFight(main_loop_pass >> 4 % PHASES_GROUPS);
                                                        break;

                                                case 1:
                                                case 3:
                                                case 5:
                                                case 7:
                                                        MenMove (main_loop_pass >> 4 % PHASES_GROUPS);
                                                        break;
                                        }

                                case 4:
                                        break;

                                case 2:
                                case 6:
                                        if (gun_on)
                                                FireBullet;
                                        break;

                                case 1:
                                case 3:
                                case 5:
                                case 7:
                                        CheckCollisions;
                                        break;
                        }
                        main_loop_pass++;

                        if (sound_timeout && tS > sound_timeout)
                        {
                                sound_timeout = 0;
                                Sound;
                        }
                        SleepUntil(next_update_jiffy);

                        total_score = 3 * (U_ENEMY_NUM - enemy_left) +
                                                  5 * enemy_by_friendly - 100 * friendly_fire - 10 * (tS - t0) - bullets_fired;
                        if (game_over)
                        {
                                tf = tS;
                                Sleep(750);
                                FlushMessages;
                                while (!KeyScan(&ch) && friendly_left || tS - tf < 1.5)
                                {
                                        total_score += 250;
                                        Sound(86);
                                        Sleep(150);
                                        Sound;
                                        Sleep(50);
                                        friendly_left--;
                                }
                                total_score += 250 * friendly_left;
                                if (total_score > best_score)
                                        best_score = total_score;
                                if (!ch)
                                        ch = CharGet(, FALSE);
                                if (ch == CH_ESC || ch == CH_SHIFT_ESC)
                                        goto to_done;
                                gun_on = FALSE;
                                Init;
                        }
                }
to_done:
                MessageGet(,, 1 << MESSAGE_KEY_UP);
        }
        catch
                PutExcept;
        SettingsPop;
        MenuPop;
        RegWrite("ZealOS/Titanium", "I64 best_score=%d;\n", best_score);
}