scroller.c

Go to the documentation of this file.

#include <stdio.h>
#include <allegro.h>
#include "include/supercsbros.h"

#define DEBUG 1

int battle = 0;

int main (void)
{

  int nticks;
  initialize();
  main_menu();
  loadsprites();

  LOCK_VARIABLE(ticks);
  LOCK_FUNCTION(ticker);
  install_int_ex(ticker, MSEC_TO_TIMER( (int)(1000 * env->diff_mod)));
  env->ticks=0;

  while (!key[KEY_ESC])
    {

      clear(buffer);
      player->oldpy = player->y; /* XXX: Here be dragons.  We keep track of last  */
      player->oldpx = player->x; /*      position for collision detection..kinda. */
      nticks = env->ticks;
      env->ticks = 0;

      for (; nticks >0; nticks--) {
        --env->counter;
      }
      if (battle == 1)
        boss_battle();
      player->collision=0;
      checkinput();
      updateplayer();
      updatebullets();
      update_enemies();
      updateitems();
      if (DEBUG) {
        draw_crosshair();
        updatestats();
      }
      updatescore();
      updatetime();
      
      vsync();
      acquire_screen();
      blit(buffer, screen, 0, 0, 0, 0, WIDTH-1, HEIGHT-1);
      release_screen();
    }

  MapFreeMem();
  allegro_exit();
  return 0;
}



void initialize()
{
  allegro_init();

  install_timer();
  install_keyboard();
  install_mouse(); 
  
  set_color_depth(32);
  set_gfx_mode(MODE, WIDTH, HEIGHT, 0, 0);
  buffer = create_bitmap (WIDTH, HEIGHT);
  clear(buffer);

  enable_hardware_cursor();
  select_mouse_cursor(MOUSE_CURSOR_ALLEGRO);
  show_mouse(screen);

  if (MapLoad(map_file))
    {
      allegro_message("Error reading the map file: %s", map_file);
      exit(1);
    }
  player = malloc(sizeof(SPRITE));
  stats  = malloc(sizeof(STATS));
  env    = malloc(sizeof(ENVIRONMENT));
  if (!player || !stats || !env) {
    allegro_message("Error allocating memory for structs...bye.");
    exit(1);
  }

  stats->health = 25;
  stats->score  = 0;
  stats->lives  = 3;

  env->counter  = 300;
  env->ticks    = 0;
  env->diff_mod = 2.00;

  player->x = 0;
  player->y = 0;

  OSinit(os_type);
  return;
}

void main_menu()
{
  int i = 0;
  int s = 3;
  
  BITMAP *bg;
  /* in order: start, settings, quit */
  BITMAP *menu_items_unselected[3];
  BITMAP *menu_items_selected[3];

  bg = load_bitmap(bg_file, NULL);
  if (!bg) {
    allegro_message("Error loading %s", bg);
    exit(1);
  }

  menu_items_unselected[0] = load_bitmap("menus/start_unselected.bmp", NULL);
  menu_items_unselected[1] = load_bitmap("menus/settings_unselected.bmp", NULL);
  menu_items_unselected[2] = load_bitmap("menus/quit_unselected.bmp", NULL);

/*   menu_items_selected[0]  = load_bitmap("menus/start_selected.bmp", NULL); */
/*   menu_items_selected[1]  = load_bitmap("menus/settings_selected.bmp", NULL); */
/*   menu_items_selected[2]  = load_bitmap("menus/quit_selected.bmp", NULL); */


  blit(bg, screen, 0, 0, 0, 0, bg->w, bg->h);
  for (i=0; i<3; i++) {
    blit(menu_items_unselected[i], screen, 0, 0, 300, (200 + i * 64), SCREEN_W-1, SCREEN_H-1);
  }
/*   blit(menu_items_selected[s], screen, 0, 0, 300, (200 + s * 64), SCREEN_W-1, SCREEN_H-1); */
  
  while (1)
    {
      mouse_b=0;
      if ((mouse_x >= 300) && (mouse_x <= 510) && (mouse_y >= 200) && (mouse_y <= 263)) s = 0;
      if ((mouse_x >= 300) && (mouse_x <= 510) && (mouse_y >= 264) && (mouse_y <= 327)) s = 1;
      if ((mouse_x >= 300) && (mouse_x <= 510) && (mouse_y >= 328) && (mouse_y <= 392)) s = 2;

      /* set selected item based on bounding rectangle */
      if (mouse_b & 1) {
        switch (s) {
        case 0: break;
        case 1: 
          blit(bg, screen, 0, 0, 0, 0, bg->w, bg->h);
          settings_menu();
          blit(bg, screen, 0, 0, 0, 0, bg->w, bg->h);
          for (i=0; i<3; i++)
            blit(menu_items_unselected[i], screen, 0, 0, 300, (200 + i * 64), SCREEN_W-1, SCREEN_H-1);
          break;
        case 2: quitgame();
        }
        if (s == 0) break;
      }
    }
  return;
}

void quitgame()
{
  allegro_exit();
  exit(0);
}

void settings_menu()
{
  int i;
  int s = 0;

  BITMAP *bg;
  //  BITMAP *difficulty_level_on[3];
  BITMAP *difficulty_level[3];
  BITMAP *on, *off, *done;
  BITMAP *difficulty, *audio;

  //  bg = load_bitmap("images/background.bmp", NULL);
  //blit(bg, screen, 0, 0, 0, 0, bg->w, bg->h);
 
  difficulty = load_bitmap("menus/difficulty.bmp", NULL);
  audio = load_bitmap("menus/audio.bmp", NULL);
  done  = load_bitmap("menus/done_unselected.bmp", NULL);
  on    = load_bitmap("menus/on_unselected.bmp", NULL);
  off   = load_bitmap("menus/off_unselected.bmp", NULL);
 
  difficulty_level[0] = load_bitmap("menus/a_unselected.bmp", NULL);
  difficulty_level[1] = load_bitmap("menus/b_unselected.bmp", NULL);
  difficulty_level[2] = load_bitmap("menus/c_unselected.bmp", NULL);
/*   difficulty_level_on[0]  = load_bitmap("menus/a_selected.bmp", NULL); */
/*   difficulty_level_on[1]  = load_bitmap("menus/b_selected.bmp", NULL); */
/*   difficulty_level_on[2]  = load_bitmap("menus/c_selected.bmp", NULL); */

  blit(difficulty, screen,0, 0, 85, 200, difficulty->w, difficulty->h);
  blit(audio, screen, 0, 0, 250, 240, audio->w, audio->h);
  blit(done, screen, 0, 0, 270, 280, done->w, done->h);
  blit(on, screen, 0, 0, 410, 240, on->w, on->h);
  blit(off, screen, 0, 0, 470, 240, off->w, off->h);

  for (i=0; i<3; i++) {
    blit(difficulty_level[i], screen, 0, 0, (400 + i * 70), 200, SCREEN_W-1, SCREEN_H-1);
  }
  
  while (1)
    {
       /* which option are we selecting? */
      if ((mouse_x >= 400) && (mouse_x <= 460) && (mouse_y >= 200) && (mouse_y <= 240)) s = 0; /* A Option */
      if ((mouse_x >= 470) && (mouse_x <= 530) && (mouse_y >= 200) && (mouse_y <= 240)) s = 1; /* B  "     */
      if ((mouse_x >= 540) && (mouse_x <= 600) && (mouse_y >= 200) && (mouse_y <= 240)) s = 2; /* C  "     */
      if ((mouse_x >= 410) && (mouse_x <= 460) && (mouse_y >= 241) && (mouse_y <= 280)) s = 3; /* Audio on */
      if ((mouse_x >= 470) && (mouse_x <= 530) && (mouse_y >= 241) && (mouse_y <= 280)) s = 4; /* Audio off*/
      if ((mouse_x >= 270) && (mouse_x <= 375) && (mouse_y >= 280) && (mouse_y <= 320)) s = 5; /* Done     */

      /* set selected item based on bounding rectangle */
      if (mouse_b & 1) {
        switch (s) {
        case 0: env->diff_mod = 0.42;   break; /* A option */
        case 1: env->diff_mod = 0.75;   break; /* B  "     */
        case 2: env->diff_mod = 1.00;   break; /* C  "     */
        case 3: env->audio_enabled = 1; break; 
        case 4: env->audio_enabled = 0; break;
        case 5: break;                         /* Just one of those days. */
        }
        if (s == 5) break;
      }
    }
  //  destroy_bitmap(bg);
  destroy_bitmap(difficulty);
  destroy_bitmap(audio);
  destroy_bitmap(done);
  destroy_bitmap(on);
  destroy_bitmap(off);
  return;
}

void ticker()
{
  ++env->ticks;
  return;
}

void updatetime()
{
  if (env->counter > 0)
    textprintf_ex(screen, font, (WIDTH-100), 5, WHITE, -1, "Time: %d", env->counter);
  else
    {
      allegro_message("You've run out of time.  We should do someting now...like restart the level!\n");
      restart_level();
    }
  return;
}

void updatescore()
{
  textprintf_ex(buffer, font, 15, 5, WHITE, -1,"Score: %d", stats->score);
  textprintf_ex(buffer, font, 105, 5, WHITE, -1, "Lives: %d", stats->lives);
  textprintf_ex(buffer, font, 210, 5, WHITE, -1, "Jump: %d", jump);
  return;
}

void updatestats()
{
  int n;
  draw_sprite(buffer, progress_player, 14, 15);
   
  for (n = 0; n < stats->health; n++) {
    draw_sprite(buffer, bar, 15+n*5, 17);
  }
  textprintf_ex(buffer, font, 300, 5, WHITE, -1, "Player->x: %d", player->x);
  textprintf_ex(buffer, font, 450, 5, WHITE, -1, "Player->y: %d", player->y);
  textprintf_ex(buffer, font, 300, 20, WHITE, -1, "Difficulty Modifier: %3f", env->diff_mod);
  textprintf_ex(buffer, font, 300, 45, WHITE, -1, "Rightfacing: %d", player->rightfacing);
  if (jump < 0) {textprintf_ex(buffer, font, 400, 300, WHITE, -1, "FALLING!");}
  if (player->collision) {textprintf_ex(buffer, font, 400, 315, WHITE, -1, "Collision!!");}
}

void updatebossstats()
{
  int n;
  draw_sprite(buffer, progress_boss, SCREEN_W - 150, 17);
   
  for (n = 0; n < bstats->health; n++) {
    draw_sprite(buffer, bar, SCREEN_W - 150 +n*5, 17);
  }
}


BITMAP *grabframe(BITMAP *source, 
                  int width, int height, 
                  int startx, int starty, 
                  int columns, int frame)
{
  BITMAP *temp = create_bitmap(width,height);
  int x = startx + (frame % columns) * width;
  int y = starty + (frame / columns) * height;
  blit(source,temp,x,y,0,0,width,height);
  return temp;
}


void loadsprites()
{
  int n;

  // used for health status stevie
  temp = load_bitmap("images/progress-player.bmp", NULL);
  progress_player = grabframe(temp,130,14,0,0,1,0);
  bar = grabframe(temp,6,10,130,2,1,0);
  destroy_bitmap(temp);

  //boss health
  temp = load_bitmap("images/progress-boss.bmp", NULL);

  progress_boss = grabframe(temp,130,14,0,0,1,0);
  bar = grabframe(temp,6,10,130,2,1,0);
  destroy_bitmap(temp);
  
  // Stevie's sprites
  temp = load_bitmap(player_bitmap, NULL);
  for (n=0; n<8; n++)
    player_images[n] = grabframe(temp,50,64,0,0,8,n);
  destroy_bitmap(temp);
    
  player = malloc(sizeof(SPRITE));
  player->x = 80;
  player->y = 100;
  player->curframe=0;
  player->framecount=0;
  player->framedelay=6;
  player->rightfacing=0;
  player->maxframe=7;
  player->width=player_images[0]->w;
  player->height=player_images[0]->h;
  player->collision=0;
    
  temp = load_bitmap(enemy_bitmap1, NULL);
  for (n=0; n<8; n++)
    mis_1_images[n] = grabframe(temp,50,64,0,0,8,n);
  destroy_bitmap(temp);

  for (n=0; n<MAX_ENEMIES; n++) {
    enemies[n] = malloc(sizeof(SPRITE));
    enemies[n]->alive = 1;
    enemies[n]->width = mis_1_images[0]->w;
    enemies[n]->height = mis_1_images[0]->h;
    enemies[n]->rightfacing = 0;
    enemies[n]->xdelay = 4;
    enemies[n]->ydelay = 0;
    enemies[n]->xcount = 5;
    enemies[n]->ycount = 0;
    enemies[n]->xspeed = 0;
    enemies[n]->yspeed = 0;
    enemies[n]->curframe = 0;
    enemies[n]->maxframe = 2;
    enemies[n]->framecount = 0;
    enemies[n]->framedelay = 10;
    enemies[n]->animdir = 1;
  }
  enemies[0]->x = 524;   enemies[0]->y = 287;
  enemies[1]->x = 1456;  enemies[1]->y = 127;
  enemies[2]->x = 2316;  enemies[2]->y = 286;
  enemies[3]->x = 2656;  enemies[3]->y = 286;
  enemies[4]->x = 3632;  enemies[4]->y = 158;
  enemies[5]->x = 5256;  enemies[5]->y = 446;
  enemies[6]->x = 5196;  enemies[6]->y = 254;
  enemies[7]->x = 5592;  enemies[7]->y = 254;
  enemies[8]->x = 6280;  enemies[8]->y = 319;
  enemies[9]->x = 7436;  enemies[9]->y = 190;


  temp = load_bitmap(boss_bitmap, NULL);
  for (n=0; n<8; n++)
    boss_images[n] = grabframe(temp,50,64,0,0,8,n);
  destroy_bitmap(temp);

  boss = malloc(sizeof(SPRITE));
  boss->x = 8890 ;
  boss->y = 126 ;
  boss->curframe = 0;
  boss->alive=1;
  boss->framecount = 0;
  boss->framedelay = 4;
  boss->maxframe=7;
  boss->width=boss_images[0]->w;
  boss->height=boss_images[0]->h;
  boss->collision = 0;
  boss->rightfacing=0;

  cd_image = load_bitmap(cd_bitmap, NULL);

  for (n=0; n<5; n++) {
    cd[n] = malloc(sizeof(SPRITE));
    cd[n]->width = cd_image->w;
    cd[n]->height= cd_image->h;
    cd[n]->alive=1;
  }
  
  cd[0]->x = 440;   cd[0]->y = 200;
  cd[1]->x = 1760;  cd[1]->y = 222;
  cd[2]->x = 3340;  cd[2]->y = 200;
  cd[3]->x = 4180;  cd[3]->y = 320;
  cd[4]->x = 5600;  cd[4]->y = 200;


  jumpdrive_image = load_bitmap(jumpdrive_bitmap, NULL);
  for (n=0; n<6; n++) {
    jumpdrive[n] = malloc(sizeof(SPRITE));
    jumpdrive[n]->width = jumpdrive_image->w;
    jumpdrive[n]->height= jumpdrive_image->h;
    jumpdrive[n]->alive=1;
  }

  jumpdrive[0]->x = 750;   jumpdrive[0]->y = 180;
  jumpdrive[1]->x = 1184;  jumpdrive[1]->y = 382;
  jumpdrive[2]->x = 2780;  jumpdrive[2]->y = 382;
  jumpdrive[3]->x = 3800;  jumpdrive[3]->y = 60;
  jumpdrive[4]->x = 5250;  jumpdrive[4]->y = 400;
  



  bullet_image = load_bitmap("objects/ball.bmp", NULL);

  for (n=0; n<MAX_BULLETS; n++) {
    bullets[n] = malloc(sizeof(SPRITE));
    bullets[n]->alive=0;
    bullets[n]->x=0;
    bullets[n]->y=0;
    bullets[n]->xspeed=6;
    bullets[n]->yspeed=0;
    bullets[n]->xdelay=0;
    bullets[n]->ydelay=0;
    bullets[n]->xcount=1;
    bullets[n]->ycount=0;
    bullets[n]->curframe=0;
    bullets[n]->maxframe=0;
    bullets[n]->animdir=0;
    bullets[n]->framedelay=0;
    bullets[n]->framecount=0;
    bullets[n]->width=bullet_image->w;
    bullets[n]->height=bullet_image->h;
  }

}

int inside(int x,int y,int left,int top,int right,int bottom)
{
    if (x > left && x < right && y > top && y < bottom)
        return 1;
    else
        return 0;
}

void updatebullet(SPRITE *spr)
{
    int n,x,y;
    int x1,y1,x2,y2;

    updatesprite(spr);

    if (spr->x < mapxoff || spr->x > mapxoff + SCREEN_W)
    {
        spr->alive = 0;
        return;
    }

    for (n=0; n<MAX_ENEMIES; n++)
    {
        if (enemies[n]->alive)
        {
          x = spr->x + spr->width/2 - mapxoff;
          y = spr->y + spr->height/2 - mapyoff;
          
          x1 = enemies[n]->x - mapxoff;
          y1 = enemies[n]->y - mapyoff;
          x2 = x1 + enemies[n]->width;
          y2 = y1 + enemies[n]->height;
          
          if (inside(x, y, x1, y1, x2, y2))
            {
              if (env->audio_enabled == 1)
                play_sample(sounds[HIT], VOLUME, PAN, PITCH, FALSE);
              enemies[n]->alive=0;
              spr->alive=0;
              //startexplosion(spr->x+16, spr->y);
              
            }
      }
    }
    if (boss->alive) {
      x = spr->x + spr->width/2 - mapxoff;
      y = spr->y + spr->height/2 - mapyoff;
      
      x1 = boss->x - mapxoff;
      y1 = boss->y - mapyoff;
      x2 = x1 + boss->width;
      y2 = y1 + boss->height;
      
      if (inside(x, y, x1, y1, x2, y2))
        {
          if (env->audio_enabled == 1)
            play_sample(sounds[HIT], VOLUME, PAN, PITCH, FALSE);
          bstats->health -= 1;
        }
    }
}

void updatebullets()
{
  int n;
  for (n=0; n<MAX_BULLETS; n++) {
    if (bullets[n]->alive) {
      updatebullet(bullets[n]);
      draw_sprite(buffer,bullet_image, bullets[n]->x-mapxoff, bullets[n]->y-mapyoff);
    }
  }
}

void updateitems()
{
  int n;
  for (n=0; n<5; n++) {
    if (cd[n]->alive) {
      draw_sprite(buffer, cd_image, cd[n]->x-mapxoff, cd[n]->y-mapyoff);
    }
    if (jumpdrive[n]->alive) {
      draw_sprite(buffer, jumpdrive_image, jumpdrive[n]->x-mapxoff, jumpdrive[n]->y-mapyoff);
    }
  }
}
void loadsounds()
{
  int n;
    if (install_sound(DIGI_AUTODETECT, MIDI_NONE, "") != 0) 
    {
        allegro_message("Error initializing sound system");
        return;
    }
    sounds[JUMP] = load_sample("jump.wav");
    if (!sounds[JUMP]) 
    {
        allegro_message("Error reading jump.wav");
        return;
    }
    sounds[HIT] = load_sample("hit.wav");
    if (!sounds[HIT]) 
    {
        allegro_message("Error reading hit.wav");
        return;
    }
    sounds[ITEM] = load_sample("item.wav");
    if (!sounds[ITEM]) 
    {
        allegro_message("Error reading item.wav");
        return;
    }
    sounds[SHOOT] = load_sample("shoot.wav");
    if (!sounds[SHOOT]) 
    {
        allegro_message("Error reading shoot.wav");
        return;
    }
    if (env->audio_enabled == 1)
      play_sample(sounds[0], VOLUME, PAN, PITCH, FALSE);
  
  for (n=0; n < NUM_SOUNDS; n ++)
     destroy_sample(sounds[n]);
}

int collided(int x, int y)
{
  BLKSTR *blockdata;
  blockdata = MapGetBlock(x/mapblockwidth, y/mapblockheight);
  if (blockdata->user1 == 5)
    stats->health -= 3;
  return blockdata->bl;
}

void draw_crosshair()
{
  // top left
  line(buffer, (player->x - 10 - mapxoff), (player->y - mapyoff), (player->x + 10 - mapxoff), (player->y - mapyoff), RED);
  line(buffer, (player->x - mapxoff), (player->y - 10 - mapyoff), (player->x - mapxoff), (player->y + 10 - mapyoff), RED);

  // bottom left
  line(buffer, (player->x - 10 - mapxoff), (player->y - mapyoff + player->height), (player->x + 10 - mapxoff), (player->y - mapyoff + player->height), RED);
  line(buffer, (player->x - mapxoff), (player->y - 10 - mapyoff + player->height), (player->x - mapxoff), (player->y + 10 - mapyoff + player->height), RED);

  // top right
  line(buffer, (player->x - 10 - mapxoff + player->width), (player->y - mapyoff), (player->x + 10 - mapxoff + player->width), (player->y - mapyoff), RED);
  line(buffer, (player->x - mapxoff + player->width), (player->y - 10 - mapyoff), (player->x - mapxoff + player->width), (player->y + 10 - mapyoff), RED);

  // bottom right
  line(buffer, (player->x - 10 - mapxoff + player->width), (player->y - mapyoff + player->height), (player->x + 10 - mapxoff + player->width), (player->y - mapyoff + player->height), RED);
  line(buffer, (player->x - mapxoff + player->width), (player->y - 10 - mapyoff + player->height), (player->x - mapxoff + player->width), (player->y + 10 - mapyoff + player->height), RED);
  return;
}


void restart_level()
{
  if (stats->lives > 0)
    {
      stats->health=25;
      env->counter=300;
      stats->score=0;
      player->x = 80;
      player->y = 100;
      player->collision=0;
      jump = JUMPIT;
    }
  else
    {
      allegro_message("Deiner gemütlichkeit is kaput!  Exiting game...\n");
      exit(0);
    }
  return;
}

void fire()
{
  int n;
  for (n=0; n<MAX_BULLETS; n++)
    {
      if (!bullets[n]->alive)
        {
          if (env->audio_enabled == 1)
            play_sample(sounds[SHOOT], VOLUME, PAN, PITCH, FALSE);
          bullets[n]->alive++;
          bullets[n]->x = player->x;
          bullets[n]->y = player->y + player->height/2;
          if (player->rightfacing)
            bullets[n]->rightfacing=1;
          else
            bullets[n]->rightfacing=0;
          return;
        }
    }
}

void updatesprite(SPRITE *spr)
{
    if (spr->xcount > spr->xdelay) {
      if (spr->rightfacing)
        spr->x += spr->xspeed;
      else
        spr->x -= spr->xspeed;
    }
    
    if (++spr->framecount > spr->framedelay) {
      spr->framecount = 0;
      if (spr->animdir == -1) {
        if (--spr->curframe < 0)
          spr->curframe = spr->maxframe;
      }
      else if (spr->animdir == 1) {
        if (++spr->curframe > spr->maxframe)
          spr->curframe = 0;
      }
    }
}


void checkinput()
{
     
 if (key[KEY_1]) {
   player->x = 8000;
   player->y = 100;
  }
  if (key[KEY_2]) {
    if (battle == 1)
      bstats->health = -1;
  }
  if (key[KEY_S]) {
    env->counter = 100000;
    remove_timer();
  }
  if (key[KEY_H]) {
    stats->health = -1;
  }
  if (key[KEY_W]) {
    jump = 45;
  }
  if (key[KEY_LCONTROL]) {
    fire();
  }
  if (key[KEY_RIGHT]) { 
    player->rightfacing = 1; 
    player->x+=4; 
    if (++player->framecount > player->framedelay) {
      player->framecount=0;
      if (++player->curframe > player->maxframe)
        player->curframe=1;
    }
  }
  else if (key[KEY_LEFT]) { 
    player->rightfacing = 0; 
    player->x-=4; 
    if (++player->framecount > player->framedelay) {
      player->framecount=0;
      if (++player->curframe > player->maxframe)
        player->curframe=1;
    }
  }
  else player->curframe=0;
  
  if (jump==JUMPIT) {
    if (!collided(player->x + player->width/2, player->y + player->height+5)) {
      jump = 0;
      player->collision=0;
    }
    
    if (key[KEY_SPACE]) {
      do_jump();
      jump = 35;
    }
  }
 
  /* this is where we're in the air, either going up or going down */
  else
    {
      if (!(collided(player->x, player->y - jump/5) || collided(player->x + player->width / 2, player->y - jump/5) || collided(player->x + player->width, player->y - jump/5)) ||
          collided(player->x, player->y + player->height/2) || collided(player->x + player->width, player->y + player->height/2) || 
          collided(player->x, player->height) || collided(player->x + player->width, player->y))
        {
          player->y -= jump/5;
          jump--;
        }
      else {
        jump = 0;
        player->collision = 1;
      }
    }
  
  if (jump<0)
    {
      if (collided(player->x + player->width/2, player->y + player->height) || collided(player->x + player->width/2, player->y))
        {
          player->collision=1;
          jump = JUMPIT;
          while (collided(player->x + player->width/2,  player->y + player->height))
            player->y -= 2;  /* in case we get stuck, push player back up */
        }
    }
  return;
}


void update_enemies()
{
  int n;
  
  for (n=0; n<10; n++) {
    if (enemies[n]->alive) {
           if ((enemies[n]->x - player->x - mapxoff) <= 600)
             enemies[n]->xspeed = 4;
           updatesprite(enemies[n]);
           draw_sprite(buffer, mis_1_images[enemies[n]->curframe],
                       enemies[n]->x - mapxoff, enemies[n]->y-mapyoff);
    }
  }
  if (boss->alive) {
    draw_sprite(buffer, boss_images[boss->curframe], boss->x-mapxoff, boss->y-mapyoff);
  } 
}


void updateplayer()
{
  int ix, iy, n;
  int x1, x2, y1, y2;
  
  if ((stats->health) < 0 && (battle == 0)) {
      allegro_message("You die.  Your corpse is quickly eaten by a grue.");
      stats->lives--;
      restart_level();
  }

  if (player->x >=  8600)
    battle = 1;
  //check for collided with foreground tiles
  if (!player->rightfacing) 
    { 
      if (collided(player->x, player->y + player->height) || collided(player->x, player->y+5)) {
        player->collision=1;
        player->x = player->oldpx; 
      }
    }
  else 
    { 
      if (collided(player->x + player->width, player->y + player->height) || collided(player->x + player->width, player->y+5)) {
        player->collision=1;
        player->x = player->oldpx; 
      }
    }   

  //check for item pickup

  for (n=0; n<5; n++) {
    if (cd[n]->alive) {
      ix = cd[n]->x + cd[n]->width/2 - mapxoff;
      iy = cd[n]->y + cd[n]->height/2 - mapyoff;
      x1 = player->x - mapxoff;
      y1 = player->y - mapyoff;
      x2 = x1 + player->width;
      y2 = y1 + player->height;
      
      if (inside(ix, iy, x1, y1, x2, y2)) {
        if (env->audio_enabled == 1)
          play_sample(sounds[ITEM], VOLUME, PAN, PITCH, FALSE);
        cd[n]->alive=0;
        stats->score += 50;
      }
    }
    if (jumpdrive[n]->alive) {
      ix = jumpdrive[n]->x + jumpdrive[n]->width/2 - mapxoff;
      iy = jumpdrive[n]->y + jumpdrive[n]->height/2 - mapyoff;
      x1 = player->x - mapxoff;
      y1 = player->y - mapyoff;
      x2 = x1 + player->width;
      y2 = y1 + player->height;
      
      if (inside(ix, iy, x1, y1, x2, y2)) {
        if (env->audio_enabled == 1)
          play_sample(sounds[ITEM], VOLUME, PAN, PITCH, FALSE);
        jumpdrive[n]->alive=0;
        stats->score += 50;
      }
    }
  }

   
  //update the map scroll position
  mapxoff = player->x + player->width/2 - WIDTH/2 + 10;
  mapyoff = player->y + player->height/2 - HEIGHT/2 + 10;
  
  
  //avoid moving beyond the map edge
  if (mapxoff < 0) mapxoff = 0;
  if (mapxoff > (mapwidth * mapblockwidth - WIDTH))
    mapxoff = mapwidth * mapblockwidth - WIDTH;
  if (mapyoff < 0) 
    mapyoff = 0;
  if (mapyoff > (mapheight * mapblockheight - HEIGHT)) 
    mapyoff = mapheight * mapblockheight - HEIGHT;
  
  //draw the background tiles
  MapDrawBG(buffer, mapxoff, mapyoff, 0, 0, WIDTH-1, HEIGHT-1);
  
  //draw foreground tiles
  MapDrawFG(buffer, mapxoff, mapyoff, 0, 0, WIDTH-1, HEIGHT-1, 0);
  
  //draw the player's sprite
  if (player->rightfacing) 
    draw_sprite(buffer, player_images[player->curframe], 
                (player->x-mapxoff), (player->y-mapyoff+1));
  else 
    draw_sprite_h_flip(buffer, player_images[player->curframe], 
                       (player->x-mapxoff), (player->y-mapyoff));
  return;
}


void do_jump()
{
  if (env->audio_enabled) {  play_sample(sounds[JUMP], VOLUME, PAN, PITCH, FALSE); }
  return;
}


void end_game()
{
  //int is_same_bitmap(preend_image, end_image);

  if ((bstats->health < 0) && (stats->health > 0)) {
    allegro_message("Congratulations!  You win!");
  }
  else if ((stats->health < 0) && (bstats->health > 0)) {
    allegro_message("MORE! MORE! MORE!");
  }

  main_menu();
  return;
}

void boss_battle()
{
  int n;
  battle = 1;
  remove_timer();

  temp = load_bitmap(boss_bitmap, NULL);
  for (n=0; n<8; n++)
    boss_images[n] = grabframe(temp,50,64,0,0,8,n);
  destroy_bitmap(temp);
  
  bstats = malloc(sizeof(STATS));
  bstats->health=100;
  bstats->lives=1;
  
  while((bstats->health > 0) && (stats->health > 0)) {
    player->collision=0;
    checkinput();
    updateplayer();
    updatebullets();
    update_enemies();
    updateitems();
    //draw_crosshair();
    updatestats();
    updatebossstats();
    updatescore();
    
    vsync();
    acquire_screen();
    blit(buffer, screen, 0, 0, 0, 0, WIDTH-1, HEIGHT-1);
    release_screen();
  }
  end_game();
}

void init_win32()
{
  set_window_title(title_string);
  /* loadsounds(); */
  return;
}
void init_linux()
{
  allegro_message("GNU/Linux has not yet been tested; some options will be disabled");
  env->audio_enabled = FALSE;
  set_window_title(title_string);
  return;
}
void init_unix()
{
  env->audio_enabled = FALSE;
  set_window_title(title_string);
  return;
}



char *OSinit(int number)
{
  switch (number)
    {
    case OSTYPE_WIN3:    /* fallthrough */
    case OSTYPE_WIN95:   /*      |      */
    case OSTYPE_WIN98:   /*      |      */
    case OSTYPE_WINME:   /*      |      */
    case OSTYPE_WINNT:   /*     \|/     */
    case OSTYPE_WIN2000: /*      '      */
    case OSTYPE_WINXP:
      init_win32(); 
      break;
    case OSTYPE_LINUX:
      init_linux();
      break;
    case OSTYPE_UNIX:
      init_unix();
      break;
    }
  return "";
}
END_OF_MAIN();

---