bowler.c

Go to the documentation of this file.

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

int main (void)
{
  int nticks;
  initialize(); /* env->diff_mod is given a default value here. */
  main_menu();  /* env->diff_mod is given a uservalue here.  it is part of the difficulty setting 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 need to keep track of last */
      player->oldpx = player->x; /*      position for collision detection                */
      nticks = env->ticks;
      env->ticks = 0;

      for (; nticks >0; nticks--) {
        --env->counter;
      }

      player->collision=0;
      checkinput();
      check_ground();
      updateplayer();
      updatebullets();
      update_enemies();
      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_ARROW);
  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));

  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);
    return;
  }
  menu_items_unselected[0] = load_bitmap("menus/start_unselected.pcx", NULL);
  menu_items_unselected[1] = load_bitmap("menus/settings_unselected.pcx", NULL);
  menu_items_unselected[2] = load_bitmap("menus/quit_unselected.pcx", NULL);
  menu_items_selected[0]  = load_bitmap("menus/start_selected.pcx", NULL);
  menu_items_selected[1]  = load_bitmap("menus/settings_selected.pcx", NULL);
  menu_items_selected[2]  = load_bitmap("menus/quit_selected.pcx", 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: 
          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()
{
  exit(0);
}

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

  BITMAP *settings_bg;
  BITMAP *difficulty_level_on[3];
  BITMAP *difficulty_level_off[3];
  BITMAP *on_unselected, *off_unselected, *done_unselected;
  BITMAP *difficulty, *audio;

  settings_bg = load_bitmap("menus/settings_bg.pcx", NULL);
  blit(settings_bg, screen, 0, 0, 0, 0, settings_bg->w, settings_bg->h);
 
  difficulty = load_bitmap("menus/difficulty.pcx", NULL);
  audio = load_bitmap("menus/audio.pcx", NULL);
  done_unselected = load_bitmap("menus/done_unselected.pcx", NULL);
  on_unselected = load_bitmap("menus/on_unselected.pcx", NULL);
  off_unselected = load_bitmap("menus/off_unselected.pcx", NULL);

  difficulty_level_off[0] = load_bitmap("menus/a_unselected.pcx", NULL);
  difficulty_level_off[1] = load_bitmap("menus/b_unselected.pcx", NULL);
  difficulty_level_off[2] = load_bitmap("menus/c_unselected.pcx", NULL);
  difficulty_level_on[0]  = load_bitmap("menus/a_selected.pcx", NULL);
  difficulty_level_on[1]  = load_bitmap("menus/b_selected.pcx", NULL);
  difficulty_level_on[2]  = load_bitmap("menus/c_selected.pcx", 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_unselected, screen, 0, 0, 270, 280, done_unselected->w, done_unselected->h);
  blit(on_unselected, screen, 0, 0, 410, 240, on_unselected->w, on_unselected->h);
  blit(off_unselected, screen, 0, 0, 470, 240, off_unselected->w, off_unselected->h);

  for (i=0; i<3; i++) {
    blit(difficulty_level_off[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(settings_bg);
  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, 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!!");}
}


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
  temp = load_bitmap("images/progress.bmp", NULL);
  progress = 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[n]->jump = JUMPIT;
    }
  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 = 9016 ;
  boss->y = 62 ;
  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;
  //  boss->jump = JUMPIT;

  bullet_image = load_bitmap("objects/ball.pcx", 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)
        {
            //find center of bullet
            x = spr->x + spr->width/2 - mapxoff;
            y = spr->y + spr->height/2 - mapyoff;

            //get enemy bounding rectangle
            x1 = enemies[n]->x - mapxoff;
            y1 = enemies[n]->y - mapyoff;
            x2 = x1 + enemies[n]->width;
            y2 = y1 + enemies[n]->height;

            //check for collisions
            if (inside(x, y, x1, y1, x2, y2))
            {
                enemies[n]->alive=0;
                spr->alive=0;
                //startexplosion(spr->x+16, spr->y);
                //score+=2;
                //break;
            }
        }
        }
}

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 loadsounds()
{
  /* we might actually want to keep these in a modifiable place, rather than DEFINEs, so we can change them in-game.... */
  /*   env->audio_enabled = 1; */
  /*   env->audio_pan = 128; */
  /*   env->audio_pitch = 1000; */
  /*   env->audio_volume = 128; */
  if (install_sound(DIGI_AUTODETECT, MIDI_NONE, " ") != 0)
    {
      allegro_message("Error initializing sound system");
      return;
    }
  
  sounds[villian_Audio] = load_sample("villian_Audio.wav");
  if (!sounds[villian_Audio])
    {
      allegro_message("error reading villian_Audio.wav");
      return;
    }
  
  sounds[JUMP] = load_sample("jump.wav");
  if (!sounds[JUMP])
    {
      allegro_message("error reading jump.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;
    }
  
  sounds[HIT] = load_sample("hit.wav");
  if (!sounds[HIT])
    {
      allegro_message("error reading hit.wav");
      return;
    }
  
  play_sample(sounds[4], VOLUME, PAN, PITCH, FALSE);
  
  //free the samples
  //for (n=0; n < NUM_SOUNDS; n ++)
  //   destroy_sample(sounds[n]);
  
  //remove_sound();  /* why are we removing the sound driver?  we have to play sound! */
}



int collided(int x, int y)
{
  BLKSTR *blockdata;
  blockdata = MapGetBlock(x/mapblockwidth, y/mapblockheight);
  return blockdata->bl;
}

void draw_crosshair()
{

  //  line (buffer, player->x+player->width/4 - mapxoff, player->y - jump/5 - mapyoff, player->x + 3 * player->width/4 - mapxoff, player->y - jump/5 - mapyoff, RED);
  // 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)
        {
          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 checkinput()
{
  if (key[KEY_1]) {
    if (env->audio_enabled)
      play_sample(music, env->audio_volume, env->audio_pan, env->audio_pitch, TRUE);
  }
  if (key[KEY_2]) {
    if (env->audio_enabled)
      stop_sample(music);
  }
  if (key[KEY_S]) {
    env->counter = 100000;
    remove_timer();
  }
  if (key[KEY_H]) {
    stats->health -= (int)(env->diff_mod * 5);
    if (stats->health < 0) {
      allegro_message("You die.  Your corpse is quickly eaten by a grue.");
      stats->lives--;
      restart_level();
    }
  }
  if (key[KEY_C]) {
    get_cd();
  }
  if (key[KEY_J]) {
    get_jumpdrive();
  }
  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 (key[KEY_SPACE]) {
    do_jump();
  }
  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 = 2;
           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 updatesprite(SPRITE *spr)
{

  if(!spr->rightfacing) { 
    if (collided(spr->x, spr->y + spr->height) || collided(spr->x, spr->y+5)) {
      spr->collision=1;
      spr->x = spr->oldpx; 
    }
  }
  else { 
    if (collided(spr->x + spr->width, spr->y + spr->height) || collided(spr->x + spr->width, spr->y+5)) {
      spr->collision=1;
      spr->x = spr->oldpx;  /* make sure to set oldpx for all sprites! */
    }
  }      


  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 updatemap()
{
  //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;
  
  MapDrawBG(buffer, mapxoff, mapyoff, 0, 0, WIDTH-1, HEIGHT-1);
  MapDrawFG(buffer, mapxoff, mapyoff, 0, 0, WIDTH-1, HEIGHT-1, 0);
  return;
}



void updateplayer()
{
  if (jump != JUMPIT) /* if jump != JUMPIT */
    {
      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 */
        }
    }

  if (player->x == 8600)
    boss_battle();
  updatesprite(player);
  updatemap();

  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 get_cd()
{
  if (env->audio_enabled) {  play_sample(sounds[ITEM], VOLUME, PAN, PITCH, FALSE); }
  stats->score += 35;
  return;
}


void get_jumpdrive()
{
  if (env->audio_enabled) {  play_sample(sounds[ITEM], VOLUME, PAN, PITCH, FALSE); }
  stats->score += 35;
  return;
}


void check_ground()
{
  if (jump==JUMPIT) {
    if (!collided(player->x + player->width/2, player->y + player->height+5)) {
      jump = 0;
      player->collision=0;
    }
  }
}

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



void boss_battle()
{
  remove_timer();
  allegro_message("The Battle Begins Now...");
  
}



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;
}


//THEN WE NEED TO DESTROY THE SOUND SAMPLES FOR MEMORY SALVAGE



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();

---