- converted Player into a class (naming still needs a bit of cleanup
authorIngo Ruhnke <grumbel@gmx.de>
Wed, 24 Mar 2004 17:41:04 +0000 (17:41 +0000)
committerIngo Ruhnke <grumbel@gmx.de>
Wed, 24 Mar 2004 17:41:04 +0000 (17:41 +0000)
SVN-Revision: 338

src/badguy.cpp
src/collision.cpp
src/gameloop.cpp
src/leveleditor.cpp
src/player.cpp
src/player.h
src/scene.cpp
src/scene.h
src/special.cpp

index f174734..06668d5 100644 (file)
@@ -165,7 +165,7 @@ void BadGuy::action_laptop()
           base.y = tux.base.y + tux.base.height/1.5 - base.height;
         }
 
-      if(tux.input.fire != DOWN) /* SHOOT! */
+      if(tux.input_.fire != DOWN) /* SHOOT! */
         {
           if(dir == LEFT)
             base.x -= 24;
@@ -377,13 +377,13 @@ BadGuy::draw_bsod()
       /* Alive: */
       if (dir == LEFT)
         {
-          texture_draw(&img_bsod_left[(frame / 5) % 4],
+          texture_draw(&img_bsod_left[(global_frame_counter / 5) % 4],
                        base.x - scroll_x,
                        base.y);
         }
       else
         {
-          texture_draw(&img_bsod_right[(frame / 5) % 4],
+          texture_draw(&img_bsod_right[(global_frame_counter / 5) % 4],
                        base.x - scroll_x,
                        base.y);
         }
@@ -436,13 +436,13 @@ void BadGuy::draw_laptop()
           /* Not flat: */
           if (dir == LEFT)
             {
-              texture_draw(&img_laptop_left[(frame / 5) % 3],
+              texture_draw(&img_laptop_left[(global_frame_counter / 5) % 3],
                            base.x - scroll_x,
                            base.y);
             }
           else
             {
-              texture_draw(&img_laptop_right[(frame / 5) % 3],
+              texture_draw(&img_laptop_right[(global_frame_counter / 5) % 3],
                            base.x - scroll_x,
                            base.y);
             }
@@ -549,7 +549,7 @@ void
 BadGuy::collision(void *p_c_object, int c_object)
 {
   BadGuy* pbad_c    = NULL;
-  player_type*  pplayer_c = NULL;
+  Player* pplayer_c = NULL;
 
   switch (c_object)
     {
@@ -600,7 +600,7 @@ BadGuy::collision(void *p_c_object, int c_object)
       break;
 
     case CO_PLAYER:
-      pplayer_c = (player_type*) p_c_object;
+      pplayer_c = static_cast<Player*>(p_c_object);
       if(kind != BAD_MONEY)
         {
           if (kind == BAD_BSOD)
index 0dc2d35..661556e 100644 (file)
@@ -261,7 +261,7 @@ void collision_handler()
             }
           else
             {
-              player_collision(&tux, &bad_guys[i], CO_BADGUY);
+              tux.collision(&bad_guys[i], CO_BADGUY);
             }
         }
     }
index ecfa31e..987e028 100644 (file)
@@ -133,7 +133,7 @@ void game_event(void)
           if(show_menu)
             menu_event(&event.key.keysym);
 
-          if(player_key_event(&tux,key,DOWN))
+          if(tux.key_event(key,DOWN))
             break;
 
           switch(key)
@@ -164,7 +164,7 @@ void game_event(void)
         case SDL_KEYUP:      /* A keyrelease! */
           key = event.key.keysym.sym;
 
-          if(player_key_event(&tux,key,UP))
+          if(tux.key_event(key, UP))
             break;
 
           switch(key)
@@ -236,32 +236,32 @@ void game_event(void)
             case JOY_X:
               if (event.jaxis.value < -JOYSTICK_DEAD_ZONE)
                 {
-                  tux.input.left  = DOWN;
-                  tux.input.right = UP;
+                  tux.input_.left  = DOWN;
+                  tux.input_.right = UP;
                 }
               else if (event.jaxis.value > JOYSTICK_DEAD_ZONE)
                 {
-                  tux.input.left  = UP;
-                  tux.input.right = DOWN;
+                  tux.input_.left  = UP;
+                  tux.input_.right = DOWN;
                 }
               else
                 {
-                  tux.input.left  = DOWN;
-                  tux.input.right = DOWN;
+                  tux.input_.left  = DOWN;
+                  tux.input_.right = DOWN;
                 }
               break;
             case JOY_Y:
               if (event.jaxis.value > JOYSTICK_DEAD_ZONE)
-                tux.input.down = DOWN;
+                tux.input_.down = DOWN;
               else if (event.jaxis.value < -JOYSTICK_DEAD_ZONE)
-                tux.input.down = UP;
+                tux.input_.down = UP;
               else
-                tux.input.down = UP;
+                tux.input_.down = UP;
 
               /* Handle joystick for the menu */
               if(show_menu)
                 {
-                  if(tux.input.down == DOWN)
+                  if(tux.input_.down == DOWN)
                     menuaction = MENU_ACTION_DOWN;
                   else
                     menuaction = MENU_ACTION_UP;
@@ -273,15 +273,15 @@ void game_event(void)
           break;
         case SDL_JOYBUTTONDOWN:
           if (event.jbutton.button == JOY_A)
-            tux.input.up = DOWN;
+            tux.input_.up = DOWN;
           else if (event.jbutton.button == JOY_B)
-            tux.input.fire = DOWN;
+            tux.input_.fire = DOWN;
           break;
         case SDL_JOYBUTTONUP:
           if (event.jbutton.button == JOY_A)
-            tux.input.up = UP;
+            tux.input_.up = UP;
           else if (event.jbutton.button == JOY_B)
-            tux.input.fire = UP;
+            tux.input_.fire = UP;
 
           if(show_menu)
             menuaction = MENU_ACTION_HIT;
@@ -327,11 +327,11 @@ int game_action(void)
               arrays_free();
               return(0);
             }
-          player_level_begin(&tux);
+          tux.level_begin();
         }
       else
         {
-          player_dying(&tux);
+          tux.is_dying();
 
           /* No more lives!? */
 
@@ -356,7 +356,7 @@ int game_action(void)
 
       /* Either way, (re-)load the (next) level... */
 
-      player_level_begin(&tux);
+      tux.level_begin();
       set_defaults();
       level_free(&current_level);
 
@@ -385,10 +385,9 @@ int game_action(void)
       play_current_music();
     }
 
-  player_action(&tux);
+  tux.action();
 
   /* Handle bouncy distros: */
-
   for (i = 0; i < bouncy_distros.size(); i++)
     {
       bouncy_distro_action(&bouncy_distros[i]);
@@ -396,7 +395,6 @@ int game_action(void)
 
 
   /* Handle broken bricks: */
-
   for (i = 0; i < broken_bricks.size(); i++)
     {
       broken_brick_action(&broken_bricks[i]);
@@ -467,7 +465,7 @@ void game_draw(void)
 
   /* Draw screen: */
 
-  if (tux.dying && (frame % 4) == 0)
+  if (tux.dying && (global_frame_counter % 4) == 0)
     clearscreen(255, 255, 255);
   else if(timer_check(&super_bkgd_timer))
     texture_draw(&img_super_bkgd, 0, 0);
@@ -507,25 +505,21 @@ void game_draw(void)
 
 
   /* (Bad guys): */
-
   for (i = 0; i < bad_guys.size(); ++i)
     {
       bad_guys[i].draw();
     }
 
   /* (Tux): */
-
-  player_draw(&tux);
+  tux.draw();
 
   /* (Bullets): */
-
   for (i = 0; i < bullets.size(); ++i)
     {
       bullet_draw(&bullets[i]);
     }
 
   /* (Floating scores): */
-
   for (i = 0; i < floating_scores.size(); ++i)
     {
       floating_score_draw(&floating_scores[i]);
@@ -533,7 +527,6 @@ void game_draw(void)
 
 
   /* (Upgrades): */
-
   for (i = 0; i < upgrades.size(); ++i)
     {
       upgrade_draw(&upgrades[i]);
@@ -541,7 +534,6 @@ void game_draw(void)
 
 
   /* (Bouncy distros): */
-
   for (i = 0; i < bouncy_distros.size(); ++i)
     {
       bouncy_distro_draw(&bouncy_distros[i]);
@@ -549,7 +541,6 @@ void game_draw(void)
 
 
   /* (Broken bricks): */
-
   for (i = 0; i < broken_bricks.size(); ++i)
     {
       broken_brick_draw(&broken_bricks[i]);
@@ -557,7 +548,6 @@ void game_draw(void)
 
   drawstatus();
 
-
   if(game_pause)
     {
       x = screen->h / 20;
@@ -614,7 +604,7 @@ int gameloop(const char * subset, int levelnb, int mode)
   activate_bad_guys();
   level_load_song(&current_level);
 
-  player_init(&tux);
+  tux.init();
 
   if(st_gl_mode != ST_GL_TEST)
     load_hs();
@@ -636,7 +626,7 @@ int gameloop(const char * subset, int levelnb, int mode)
   jump = false;
   done = 0;
   quit = 0;
-  frame = 0;
+  global_frame_counter = 0;
   game_pause = 0;
   timer_init(&fps_timer,true);
   timer_init(&frame_timer,true);
@@ -667,12 +657,12 @@ int gameloop(const char * subset, int levelnb, int mode)
       if(!timer_check(&frame_timer))
         {
           timer_start(&frame_timer,25);
-          ++frame;
+          ++global_frame_counter;
         }
 
       /* Handle events: */
 
-      tux.input.old_fire = tux.input.fire;
+      tux.input_.old_fire = tux.input_.fire;
 
       game_event();
 
@@ -783,7 +773,7 @@ int gameloop(const char * subset, int levelnb, int mode)
 
         }
       else
-        player_kill(&tux,KILL);
+        tux.kill(KILL);
 
 
       /* Calculate frames per second */
@@ -1326,7 +1316,7 @@ void drawshape(float x, float y, unsigned char c)
     texture_draw(&img_solid[3], x, y);
   else if (c == '$')
     {
-      z = (frame / 2) % 6;
+      z = (global_frame_counter / 2) % 6;
 
       if (z < 4)
         texture_draw(&img_distro[z], x, y);
@@ -1337,7 +1327,7 @@ void drawshape(float x, float y, unsigned char c)
     }
   else if (c == '^')
     {
-      z = (frame / 3) % 3;
+      z = (global_frame_counter / 3) % 3;
 
       texture_draw(&img_waves[z], x, y);
     }
@@ -1350,7 +1340,7 @@ void drawshape(float x, float y, unsigned char c)
     }
   else if (c == '\\')
     {
-      z = (frame / 3) % 2;
+      z = (global_frame_counter / 3) % 2;
 
       texture_draw(&img_flag[z], x + 16, y);
     }
@@ -1601,7 +1591,7 @@ void drawstatus(void)
       text_draw(&white_text,"Press ESC To Return",0,20,1);
     }
 
-  if (timer_get_left(&time_left) > TIME_WARNING || (frame % 10) < 5)
+  if (timer_get_left(&time_left) > TIME_WARNING || (global_frame_counter % 10) < 5)
     {
       sprintf(str, "%d", timer_get_left(&time_left) / 1000 );
       text_draw(&white_text, "TIME", 224, 0, 1);
@@ -1687,7 +1677,7 @@ void savegame(int slot)
       fwrite(&score,sizeof(int),1,fi);
       fwrite(&distros,sizeof(int),1,fi);
       fwrite(&scroll_x,sizeof(float),1,fi);
-      fwrite(&tux,sizeof(player_type),1,fi);
+      fwrite(&tux,sizeof(Player),1,fi);
       timer_fwrite(&tux.invincible_timer,fi);
       timer_fwrite(&tux.skidding_timer,fi);
       timer_fwrite(&tux.safe_timer,fi);
@@ -1740,7 +1730,7 @@ void loadgame(int slot)
       fread(&score,sizeof(int),1,fi);
       fread(&distros,sizeof(int),1,fi);
       fread(&scroll_x,sizeof(float),1,fi);
-      fread(&tux,sizeof(player_type),1,fi);
+      fread(&tux, sizeof(Player), 1, fi);
       timer_fread(&tux.invincible_timer,fi);
       timer_fread(&tux.skidding_timer,fi);
       timer_fread(&tux.safe_timer,fi);
index 562401a..08ffd47 100644 (file)
@@ -854,7 +854,7 @@ void le_drawlevel()
           case 'x':
           case 'y':
           case 'A':
-            texture_draw(&img_distro[(frame / 5) % 4], x * 32 - ((int)pos_x % 32), y*32);
+            texture_draw(&img_distro[(global_frame_counter / 5) % 4], x * 32 - ((int)pos_x % 32), y*32);
             break;
           default:
             break;
@@ -876,7 +876,7 @@ void le_drawlevel()
 
   /* Draw the player: */
   /* for now, the position is fixed at (0, 240) */
-  texture_draw(&tux_right[(frame / 5) % 3], 0 - pos_x, 240);
+  texture_draw(&tux_right[(global_frame_counter / 5) % 3], 0 - pos_x, 240);
 }
 
 void le_checkevents()
index 6e33c74..9525e70 100644 (file)
 #include "scene.h"
 #include "screen.h"
 
-texture_type tux_life,
-tux_right[3],  tux_left[3],
-bigtux_right[3],  bigtux_left[3],
-bigtux_right_jump,  bigtux_left_jump,
-ducktux_right,  ducktux_left,
-skidtux_right,  skidtux_left,
-firetux_right[3],  firetux_left[3],
-bigfiretux_right[3],  bigfiretux_left[3],
-bigfiretux_right_jump,  bigfiretux_left_jump,
-duckfiretux_right,  duckfiretux_left,
-skidfiretux_right,  skidfiretux_left,
-cape_right[2],  cape_left[2],
-bigcape_right[2],  bigcape_left[2];
+texture_type tux_life;
+texture_type tux_right[3];
+texture_type tux_left[3];
+texture_type bigtux_right[3];
+texture_type bigtux_left[3];
+texture_type bigtux_right_jump;
+texture_type bigtux_left_jump;
+texture_type ducktux_right;
+texture_type ducktux_left;
+texture_type skidtux_right;
+texture_type skidtux_left;
+texture_type firetux_right[3];
+texture_type firetux_left[3];
+texture_type bigfiretux_right[3];
+texture_type bigfiretux_left[3];
+texture_type bigfiretux_right_jump;
+texture_type bigfiretux_left_jump;
+texture_type duckfiretux_right;
+texture_type duckfiretux_left;
+texture_type skidfiretux_right;
+texture_type skidfiretux_left;
+texture_type cape_right[2];
+texture_type cape_left[2];
+texture_type bigcape_right[2];
+texture_type bigcape_left[2];
 
 void player_input_init(player_input_type* pplayer_input)
 {
@@ -41,138 +53,142 @@ void player_input_init(player_input_type* pplayer_input)
   pplayer_input->up = UP;
 }
 
-void player_init(player_type* pplayer)
+void
+Player::init()
 {
-  pplayer->base.width = 32;
-  pplayer->base.height = 32;
-
-  pplayer->size = SMALL;
-  pplayer->got_coffee = false;
-
-  pplayer->base.x = 0;
-  pplayer->base.y = 240;
-  pplayer->base.xm = 0;
-  pplayer->base.ym = 0;
-  pplayer->old_base = pplayer->base;
-  pplayer->dir = RIGHT;
-  pplayer->duck = false;
-
-  pplayer->dying   = DYING_NOT;
-  pplayer->jumping = false;
-
-  pplayer->frame_main = 0;
-  pplayer->frame = 0;
-  pplayer->lives = 3;
-  pplayer->score = 0;
-  pplayer->distros = 0;
-
-  player_input_init(&pplayer->input);
-
-  pplayer->keymap.jump  = SDLK_UP;
-  pplayer->keymap.duck  = SDLK_DOWN;
-  pplayer->keymap.left  = SDLK_LEFT;
-  pplayer->keymap.right = SDLK_RIGHT;
-  pplayer->keymap.fire  = SDLK_LCTRL;
-
-  timer_init(&pplayer->invincible_timer,true);
-  timer_init(&pplayer->skidding_timer,true);
-  timer_init(&pplayer->safe_timer,true);
-  timer_init(&pplayer->frame_timer,true);
-  physic_init(&pplayer->hphysic);
-  physic_init(&pplayer->vphysic);
+  base.width = 32;
+  base.height = 32;
+
+  size = SMALL;
+  got_coffee = false;
+
+  base.x = 0;
+  base.y = 240;
+  base.xm = 0;
+  base.ym = 0;
+  old_base = base;
+  dir = RIGHT;
+  duck = false;
+
+  dying   = DYING_NOT;
+  jumping = false;
+
+  frame_main = 0;
+  frame_ = 0;
+  lives = 3;
+  score = 0;
+  distros = 0;
+
+  player_input_init(&input_);
+
+  keymap.jump  = SDLK_UP;
+  keymap.duck  = SDLK_DOWN;
+  keymap.left  = SDLK_LEFT;
+  keymap.right = SDLK_RIGHT;
+  keymap.fire  = SDLK_LCTRL;
+
+  timer_init(&invincible_timer,true);
+  timer_init(&skidding_timer,true);
+  timer_init(&safe_timer,true);
+  timer_init(&frame_timer,true);
+  physic_init(&hphysic);
+  physic_init(&vphysic);
 }
 
-int player_key_event(player_type* pplayer, SDLKey key, int state)
+int
+Player::key_event(SDLKey key, int state)
 {
-  if(key == pplayer->keymap.right)
+  if(key == keymap.right)
     {
-      pplayer->input.right = state;
+      input_.right = state;
       return true;
     }
-  else if(key == pplayer->keymap.left)
+  else if(key == keymap.left)
     {
-      pplayer->input.left = state;
+      input_.left = state;
       return true;
     }
-  else if(key == pplayer->keymap.jump)
+  else if(key == keymap.jump)
     {
-      pplayer->input.up = state;
+      input_.up = state;
       return true;
     }
-  else if(key == pplayer->keymap.duck)
+  else if(key == keymap.duck)
     {
-      pplayer->input.down = state;
+      input_.down = state;
       return true;
     }
-  else if(key == pplayer->keymap.fire)
+  else if(key == keymap.fire)
     {
-      pplayer->input.fire = state;
+      input_.fire = state;
       return true;
     }
   else
     return false;
 }
 
-void player_level_begin(player_type* pplayer)
+void
+Player::level_begin()
 {
-  pplayer->base.x = 0;
-  pplayer->base.y = 240;
-  pplayer->base.xm = 0;
-  pplayer->base.ym = 0;
-  pplayer->old_base = pplayer->base;
-
-  player_input_init(&pplayer->input);
-
-  timer_init(&pplayer->invincible_timer,true);
-  timer_init(&pplayer->skidding_timer,true);
-  timer_init(&pplayer->safe_timer,true);
-  timer_init(&pplayer->frame_timer,true);
-  physic_init(&pplayer->hphysic);
-  physic_init(&pplayer->vphysic);
+  base.x = 0;
+  base.y = 240;
+  base.xm = 0;
+  base.ym = 0;
+  old_base = base;
+
+  player_input_init(&input_);
+
+  timer_init(&invincible_timer,true);
+  timer_init(&skidding_timer,true);
+  timer_init(&safe_timer,true);
+  timer_init(&frame_timer,true);
+  physic_init(&hphysic);
+  physic_init(&vphysic);
 }
 
-void player_action(player_type* pplayer)
+void
+Player::action()
 {
   bool jumped_in_solid = false;
 
   /* --- HANDLE TUX! --- */
 
-  player_input(pplayer);
+  input();
 
   /* Move tux: */
 
-  pplayer->previous_base = pplayer->base;
+  previous_base = base;
 
-  pplayer->base.x += pplayer->base.xm * frame_ratio;
-  pplayer->base.y += pplayer->base.ym * frame_ratio;
+  base.x += base.xm * frame_ratio;
+  base.y += base.ym * frame_ratio;
 
-  collision_swept_object_map(&pplayer->old_base,&pplayer->base);
+  collision_swept_object_map(&old_base,&base);
 
-  player_keep_in_bounds(pplayer);
+  keep_in_bounds();
 
   /* Land: */
 
-  if (!pplayer->dying)
+  if (!dying)
     {
 
 
-      if( !player_on_ground(pplayer))
+      if( !on_ground())
         {
-          if(player_under_solid(pplayer))
+          if(under_solid())
             {
-              physic_set_state(&pplayer->vphysic,PH_VT);
-              physic_set_start_vy(&pplayer->vphysic,0);
+              physic_set_state(&vphysic,PH_VT);
+              physic_set_start_vy(&vphysic,0);
               jumped_in_solid = true;
             }
           else
             {
-              if(!physic_is_set(&pplayer->vphysic))
+              if(!physic_is_set(&vphysic))
                 {
-                  physic_set_state(&pplayer->vphysic,PH_VT);
-                  physic_set_start_vy(&pplayer->vphysic,0);
+                  physic_set_state(&vphysic,PH_VT);
+                  physic_set_start_vy(&vphysic,0);
                 }
             }
-          pplayer->base.ym = physic_get_velocity(&pplayer->vphysic);
+          base.ym = physic_get_velocity(&vphysic);
 
         }
       else
@@ -180,13 +196,13 @@ void player_action(player_type* pplayer)
 
           /* Land: */
 
-          if (pplayer->base.ym > 0)
+          if (base.ym > 0)
             {
-              pplayer->base.y = (int)(((int)pplayer->base.y / 32) * 32);
-              pplayer->base.ym = 0;
+              base.y = (int)(((int)base.y / 32) * 32);
+              base.ym = 0;
             }
 
-          physic_init(&pplayer->vphysic);
+          physic_init(&vphysic);
 
           /* Reset score multiplier (for multi-hits): */
 
@@ -196,43 +212,43 @@ void player_action(player_type* pplayer)
       if(jumped_in_solid == true)
         {
 
-          if (isbrick(pplayer->base.x, pplayer->base.y) ||
-              isfullbox(pplayer->base.x, pplayer->base.y))
+          if (isbrick(base.x, base.y) ||
+              isfullbox(base.x, base.y))
             {
-              trygrabdistro(pplayer->base.x, pplayer->base.y - 32,BOUNCE);
-              trybumpbadguy(pplayer->base.x, pplayer->base.y - 64);
+              trygrabdistro(base.x, base.y - 32,BOUNCE);
+              trybumpbadguy(base.x, base.y - 64);
 
-              if(pplayer->size == BIG)
-                trybreakbrick(pplayer->base.x, pplayer->base.y);
+              if(size == BIG)
+                trybreakbrick(base.x, base.y);
 
-              bumpbrick(pplayer->base.x, pplayer->base.y);
-              tryemptybox(pplayer->base.x, pplayer->base.y, RIGHT);
+              bumpbrick(base.x, base.y);
+              tryemptybox(base.x, base.y, RIGHT);
             }
 
-          if (isbrick(pplayer->base.x+ 31, pplayer->base.y) ||
-              isfullbox(pplayer->base.x+ 31, pplayer->base.y))
+          if (isbrick(base.x+ 31, base.y) ||
+              isfullbox(base.x+ 31, base.y))
             {
-              trygrabdistro(pplayer->base.x+ 31, pplayer->base.y - 32,BOUNCE);
-              trybumpbadguy(pplayer->base.x+ 31, pplayer->base.y - 64);
+              trygrabdistro(base.x+ 31, base.y - 32,BOUNCE);
+              trybumpbadguy(base.x+ 31, base.y - 64);
 
-              if(pplayer->size == BIG)
-                trybreakbrick(pplayer->base.x+ 31, pplayer->base.y);
+              if(size == BIG)
+                trybreakbrick(base.x+ 31, base.y);
 
-              bumpbrick(pplayer->base.x+ 31, pplayer->base.y);
-              tryemptybox(pplayer->base.x+ 31, pplayer->base.y, LEFT);
+              bumpbrick(base.x+ 31, base.y);
+              tryemptybox(base.x+ 31, base.y, LEFT);
             }
 
 
-          if(pplayer->size == SMALL)
+          if(size == SMALL)
             {
               /* Get a distro from a brick? */
 
-              if (shape(pplayer->base.x, pplayer->base.y) == 'x' ||
-                  shape(pplayer->base.x, pplayer->base.y) == 'y')
+              if (shape(base.x, base.y) == 'x' ||
+                  shape(base.x, base.y) == 'y')
                 {
-                  add_bouncy_distro((((int)pplayer->base.x)
+                  add_bouncy_distro((((int)base.x)
                                      / 32) * 32,
-                                    ((int)pplayer->base.y / 32) * 32);
+                                    ((int)base.y / 32) * 32);
                   if (counting_distros == false)
                     {
                       counting_distros = true;
@@ -240,18 +256,18 @@ void player_action(player_type* pplayer)
                     }
 
                   if (distro_counter <= 0)
-                    level_change(&current_level,pplayer->base.x,pplayer->base.y - 1, 'a');
+                    level_change(&current_level,base.x,base.y - 1, 'a');
 
                   play_sound(sounds[SND_DISTRO], SOUND_CENTER_SPEAKER);
                   score = score + SCORE_DISTRO;
                   distros++;
                 }
-              else if (shape(pplayer->base.x+ 31, pplayer->base.y) == 'x' ||
-                       shape(pplayer->base.x+ 31, pplayer->base.y) == 'y')
+              else if (shape(base.x+ 31, base.y) == 'x' ||
+                       shape(base.x+ 31, base.y) == 'y')
                 {
-                  add_bouncy_distro((((int)pplayer->base.x + 31)
+                  add_bouncy_distro((((int)base.x + 31)
                                      / 32) * 32,
-                                    ((int)pplayer->base.y / 32) * 32);
+                                    ((int)base.y / 32) * 32);
                   if (counting_distros == false)
                     {
                       counting_distros = true;
@@ -259,7 +275,7 @@ void player_action(player_type* pplayer)
                     }
 
                   if (distro_counter <= 0)
-                    level_change(&current_level,pplayer->base.x+ 31, pplayer->base.y, 'a');
+                    level_change(&current_level,base.x+ 31, base.y, 'a');
 
                   play_sound(sounds[SND_DISTRO], SOUND_CENTER_SPEAKER);
                   score = score + SCORE_DISTRO;
@@ -268,21 +284,21 @@ void player_action(player_type* pplayer)
             }
         }
 
-      player_grabdistros(pplayer);
+      grabdistros();
       if(jumped_in_solid == true)
         {
-          ++pplayer->base.y;
-          ++pplayer->old_base.y;
-          if(player_on_ground(pplayer))
+          ++base.y;
+          ++old_base.y;
+          if(on_ground())
             {
               /* Make sure jumping is off. */
-              pplayer->jumping = false;
+              jumping = false;
             }
         }
 
     }
 
-  timer_check(&pplayer->safe_timer);
+  timer_check(&safe_timer);
 
 
   /* ---- DONE HANDLING TUX! --- */
@@ -290,7 +306,7 @@ void player_action(player_type* pplayer)
   /* Handle invincibility timer: */
 
 
-  if (get_current_music() == HERRING_MUSIC && !timer_check(&pplayer->invincible_timer))
+  if (get_current_music() == HERRING_MUSIC && !timer_check(&invincible_timer))
     {
       /*
          no, we are no more invincible
@@ -318,103 +334,105 @@ void player_action(player_type* pplayer)
 
   /* Handle skidding: */
 
-  timer_check(&pplayer->skidding_timer);
+  timer_check(&skidding_timer);
 
   /* End of level? */
 
-  if (pplayer->base.x >= endpos && endpos != 0)
+  if (base.x >= endpos && endpos != 0)
     {
       next_level = 1;
     }
 
 }
 
-bool player_on_ground(player_type *pplayer)
+bool
+Player::on_ground()
 {
-  return ( issolid(pplayer->base.x + pplayer->base.width / 2, pplayer->base.y + pplayer->base.height) ||
-           issolid(pplayer->base.x + 1, pplayer->base.y + pplayer->base.height) ||
-           issolid(pplayer->base.x + pplayer->base.width - 1, pplayer->base.y + pplayer->base.height)  );
+  return ( issolid(base.x + base.width / 2, base.y + base.height) ||
+           issolid(base.x + 1, base.y + base.height) ||
+           issolid(base.x + base.width - 1, base.y + base.height)  );
 }
 
-bool player_under_solid(player_type *pplayer)
+bool
+Player::under_solid()
 {
-  return ( issolid(pplayer->base.x + pplayer->base.width / 2, pplayer->base.y) ||
-           issolid(pplayer->base.x + 1, pplayer->base.y) ||
-           issolid(pplayer->base.x + pplayer->base.width - 1, pplayer->base.y)  );
+  return ( issolid(base.x + base.width / 2, base.y) ||
+           issolid(base.x + 1, base.y) ||
+           issolid(base.x + base.width - 1, base.y)  );
 }
 
-void player_handle_horizontal_input(player_type *pplayer, int dir)
+void
+Player::handle_horizontal_input(int newdir)
 {
-
-  if ((dir ? (pplayer->base.xm < -SKID_XM) : (pplayer->base.xm > SKID_XM)) && !timer_started(&pplayer->skidding_timer) &&
-      pplayer->dir == !dir && player_on_ground(pplayer))
+  if ((newdir ? (base.xm < -SKID_XM) : (base.xm > SKID_XM)) && !timer_started(&skidding_timer) &&
+      dir == !newdir && on_ground())
     {
-      timer_start(&pplayer->skidding_timer, SKID_TIME);
+      timer_start(&skidding_timer, SKID_TIME);
 
       play_sound(sounds[SND_SKID], SOUND_CENTER_SPEAKER);
 
     }
-  pplayer->dir = dir;
+  dir = newdir;
 
 
-  if ((dir ? (pplayer->base.xm < 0) : (pplayer->base.xm > 0)) && !isice(pplayer->base.x, pplayer->base.y + pplayer->base.height) &&
-      !timer_started(&pplayer->skidding_timer))
+  if ((newdir ? (base.xm < 0) : (base.xm > 0)) && !isice(base.x, base.y + base.height) &&
+      !timer_started(&skidding_timer))
     {
-      pplayer->base.xm = 0;
+      base.xm = 0;
     }
 
-  if (!pplayer->duck)
+  if (!duck)
     {
-      if (pplayer->dir == dir)
+      if (dir == newdir)
         {
           /* Facing the direction we're jumping?  Go full-speed: */
 
-          if (pplayer->input.fire == UP)
+          if (input_.fire == UP)
             {
-              pplayer->base.xm = pplayer->base.xm + ( dir ? WALK_SPEED : -WALK_SPEED) * frame_ratio;
+              base.xm = base.xm + ( newdir ? WALK_SPEED : -WALK_SPEED) * frame_ratio;
 
-              if(dir)
+              if(newdir)
                 {
-                  if (pplayer->base.xm > MAX_WALK_XM)
-                    pplayer->base.xm = MAX_WALK_XM;
+                  if (base.xm > MAX_WALK_XM)
+                    base.xm = MAX_WALK_XM;
                 }
               else
                 {
-                  if (pplayer->base.xm < -MAX_WALK_XM)
-                    pplayer->base.xm = -MAX_WALK_XM;
+                  if (base.xm < -MAX_WALK_XM)
+                    base.xm = -MAX_WALK_XM;
                 }
             }
-          else if ( pplayer->input.fire == DOWN)
+          else if ( input_.fire == DOWN)
             {
-              pplayer->base.xm = pplayer->base.xm + ( dir ? RUN_SPEED : -RUN_SPEED) * frame_ratio;
+              base.xm = base.xm + ( newdir ? RUN_SPEED : -RUN_SPEED) * frame_ratio;
 
-              if(dir)
+              if(newdir)
                 {
-                  if (pplayer->base.xm > MAX_RUN_XM)
-                    pplayer->base.xm = MAX_RUN_XM;
+                  if (base.xm > MAX_RUN_XM)
+                    base.xm = MAX_RUN_XM;
                 }
               else
                 {
-                  if (pplayer->base.xm < -MAX_RUN_XM)
-                    pplayer->base.xm = -MAX_RUN_XM;
+                  if (base.xm < -MAX_RUN_XM)
+                    base.xm = -MAX_RUN_XM;
                 }
             }
           else
             {
               /* Not facing the direction we're jumping?
-              Go half-speed: */
+                 Go half-speed: */
 
-              pplayer->base.xm = pplayer->base.xm + ( dir ? (WALK_SPEED / 2) : -(WALK_SPEED / 2)) * frame_ratio;
+              base.xm = base.xm + ( newdir ? (WALK_SPEED / 2) : -(WALK_SPEED / 2)) * frame_ratio;
 
-              if(dir)
+              if(newdir)
                 {
-                  if (pplayer->base.xm > MAX_WALK_XM / 2)
-                    pplayer->base.xm = MAX_WALK_XM / 2;
+                  if (base.xm > MAX_WALK_XM / 2)
+                    base.xm = MAX_WALK_XM / 2;
                 }
               else
                 {
-                  if (pplayer->base.xm < -MAX_WALK_XM / 2)
-                    pplayer->base.xm = -MAX_WALK_XM / 2;
+                  if (base.xm < -MAX_WALK_XM / 2)
+                    base.xm = -MAX_WALK_XM / 2;
                 }
             }
         }
@@ -422,317 +440,318 @@ void player_handle_horizontal_input(player_type *pplayer, int dir)
     }
 }
 
-void player_handle_vertical_input(player_type *pplayer)
+void
+Player::handle_vertical_input()
 {
-  if(pplayer->input.up == DOWN)
+  if(input_.up == DOWN)
     {
-      if (player_on_ground(pplayer))
+      if (on_ground())
         {
-          if(!physic_is_set(&pplayer->vphysic))
+          if(!physic_is_set(&vphysic))
             {
-              physic_set_state(&pplayer->vphysic,PH_VT);
-              physic_set_start_vy(&pplayer->vphysic,5.5);
-              --pplayer->base.y;
-              pplayer->jumping = true;
-              if (pplayer->size == SMALL)
+              physic_set_state(&vphysic,PH_VT);
+              physic_set_start_vy(&vphysic,5.5);
+              --base.y;
+              jumping = true;
+              if (size == SMALL)
                 play_sound(sounds[SND_JUMP], SOUND_CENTER_SPEAKER);
               else
                 play_sound(sounds[SND_BIGJUMP], SOUND_CENTER_SPEAKER);
             }
         }
     }
-  else if(pplayer->input.up == UP && pplayer->jumping == true)
+  else if(input_.up == UP && jumping == true)
     {
-      if (player_on_ground(pplayer))
+      if (on_ground())
         {
-          physic_init(&pplayer->vphysic);
-          pplayer->jumping = false;
+          physic_init(&vphysic);
+          jumping = false;
         }
       else
         {
-          pplayer->jumping = false;
-          if(physic_is_set(&pplayer->vphysic))
+          jumping = false;
+          if(physic_is_set(&vphysic))
             {
-              if(physic_get_velocity(&pplayer->vphysic) < 0.)
+              if(physic_get_velocity(&vphysic) < 0.)
                 {
-                  physic_set_state(&pplayer->vphysic,PH_VT);
-                  physic_set_start_vy(&pplayer->vphysic,0);
+                  physic_set_state(&vphysic,PH_VT);
+                  physic_set_start_vy(&vphysic,0);
                 }
             }
           else
             {
-              if(!physic_is_set(&pplayer->vphysic))
+              if(!physic_is_set(&vphysic))
                 {
-                  physic_set_state(&pplayer->vphysic,PH_VT);
+                  physic_set_state(&vphysic,PH_VT);
                 }
             }
         }
     }
 }
 
-void player_input(player_type *pplayer)
+void
+Player::input()
 {
   /* Handle key and joystick state: */
 
-  if(pplayer->duck == false)
+  if(duck == false)
     {
-      if (pplayer->input.right == DOWN && pplayer->input.left == UP)
+      if (input_.right == DOWN && input_.left == UP)
         {
-          player_handle_horizontal_input(pplayer,RIGHT);
+          handle_horizontal_input(RIGHT);
         }
-      else if (pplayer->input.left == DOWN && pplayer->input.right == UP)
+      else if (input_.left == DOWN && input_.right == UP)
         {
-          player_handle_horizontal_input(pplayer,LEFT);
+          handle_horizontal_input(LEFT);
         }
       else
         {
-          if(pplayer->base.xm > 0)
+          if(base.xm > 0)
             {
-              pplayer->base.xm = (int)(pplayer->base.xm - frame_ratio);
-              if(pplayer->base.xm < 0)
-                pplayer->base.xm = 0;
+              base.xm = (int)(base.xm - frame_ratio);
+              if(base.xm < 0)
+                base.xm = 0;
             }
-          else if(pplayer->base.xm < 0)
+          else if(base.xm < 0)
             {
-              pplayer->base.xm = (int)(pplayer->base.xm + frame_ratio);
-              if(pplayer->base.xm > 0)
-                pplayer->base.xm = 0;
+              base.xm = (int)(base.xm + frame_ratio);
+              if(base.xm > 0)
+                base.xm = 0;
             }
         }
     }
 
   /* Jump/jumping? */
 
-  if ( pplayer->input.up == DOWN || (pplayer->input.up == UP && pplayer->jumping == true))
+  if ( input_.up == DOWN || (input_.up == UP && jumping == true))
     {
-      player_handle_vertical_input(pplayer);
+      handle_vertical_input();
     }
 
   /* Shoot! */
 
-  if (pplayer->input.fire == DOWN && pplayer->input.old_fire == UP && pplayer->got_coffee)
+  if (input_.fire == DOWN && input_.old_fire == UP && got_coffee)
     {
-      add_bullet(pplayer->base.x, pplayer->base.y, pplayer->base.xm, pplayer->dir);
+      add_bullet(base.x, base.y, base.xm, dir);
     }
 
 
   /* Duck! */
 
-  if (pplayer->input.down == DOWN)
+  if (input_.down == DOWN)
     {
-      if (pplayer->size == BIG && pplayer->duck != true)
+      if (size == BIG && duck != true)
         {
-          pplayer->duck = true;
-          pplayer->base.height = 32;
-          pplayer->base.y += 32;
+          duck = true;
+          base.height = 32;
+          base.y += 32;
         }
     }
   else
     {
-      if (pplayer->size == BIG && pplayer->duck == true)
+      if (size == BIG && duck == true)
         {
           /* Make sure we're not standing back up into a solid! */
-          pplayer->base.height = 64;
-          pplayer->base.y -= 32;
+          base.height = 64;
+          base.y -= 32;
 
-          if (!collision_object_map(&pplayer->base) /*issolid(pplayer->base.x + 16, pplayer->base.y - 16)*/)
+          if (!collision_object_map(&base) /*issolid(base.x + 16, base.y - 16)*/)
             {
-              pplayer->duck = false;
-              pplayer->base.height = 64;
-              pplayer->old_base.y -= 32;
-              pplayer->old_base.height = 64;
+              duck = false;
+              base.height = 64;
+              old_base.y -= 32;
+              old_base.height = 64;
             }
           else
             {
-              pplayer->base.height = 32;
-              pplayer->base.y += 32;
+              base.height = 32;
+              base.y += 32;
             }
         }
       else
         {
-          pplayer->duck = false;
+          duck = false;
         }
     }
 
   /* (Tux): */
 
-  if(!timer_check(&pplayer->frame_timer))
+  if(!timer_check(&frame_timer))
     {
-      timer_start(&pplayer->frame_timer,25);
-      if (pplayer->input.right == UP && pplayer->input.left == UP)
+      timer_start(&frame_timer,25);
+      if (input_.right == UP && input_.left == UP)
         {
-          pplayer->frame_main = 1;
-          pplayer->frame = 1;
+          frame_main = 1;
+          frame_ = 1;
         }
       else
         {
-          if ((pplayer->input.fire == DOWN && (frame % 2) == 0) ||
-              (frame % 4) == 0)
-            pplayer->frame_main = (pplayer->frame_main + 1) % 4;
+          if ((input_.fire == DOWN && (global_frame_counter % 2) == 0) ||
+              (global_frame_counter % 4) == 0)
+            frame_main = (frame_main + 1) % 4;
 
-          pplayer->frame = pplayer->frame_main;
+          frame_ = frame_main;
 
-          if (pplayer->frame == 3)
-            pplayer->frame = 1;
+          if (frame_ == 3)
+            frame_ = 1;
         }
     }
 
 }
 
-void player_grabdistros(player_type *pplayer)
+void
+Player::grabdistros()
 {
   /* Grab distros: */
-  if (!pplayer->dying)
+  if (!dying)
     {
-      trygrabdistro(pplayer->base.x, pplayer->base.y, NO_BOUNCE);
-      trygrabdistro(pplayer->base.x+ 31, pplayer->base.y, NO_BOUNCE);
+      trygrabdistro(base.x, base.y, NO_BOUNCE);
+      trygrabdistro(base.x+ 31, base.y, NO_BOUNCE);
 
-      trygrabdistro(pplayer->base.x, pplayer->base.y + pplayer->base.height, NO_BOUNCE);
-      trygrabdistro(pplayer->base.x+ 31, pplayer->base.y + pplayer->base.height, NO_BOUNCE);
+      trygrabdistro(base.x, base.y + base.height, NO_BOUNCE);
+      trygrabdistro(base.x+ 31, base.y + base.height, NO_BOUNCE);
 
-      if(pplayer->size == BIG)
+      if(size == BIG)
         {
-          trygrabdistro(pplayer->base.x, pplayer->base.y + pplayer->base.height / 2, NO_BOUNCE);
-          trygrabdistro(pplayer->base.x+ 31, pplayer->base.y + pplayer->base.height / 2, NO_BOUNCE);
+          trygrabdistro(base.x, base.y + base.height / 2, NO_BOUNCE);
+          trygrabdistro(base.x+ 31, base.y + base.height / 2, NO_BOUNCE);
         }
 
     }
 
-
   /* Enough distros for a One-up? */
-
   if (distros >= DISTROS_LIFEUP)
     {
       distros = distros - DISTROS_LIFEUP;
-      if(pplayer->lives < MAX_LIVES)
-        pplayer->lives++;
+      if(lives < MAX_LIVES)
+        lives++;
       /*We want to hear the sound even, if MAX_LIVES is reached*/
       play_sound(sounds[SND_LIFEUP], SOUND_CENTER_SPEAKER);
     }
 }
 
-void player_draw(player_type* pplayer)
+void
+Player::draw()
 {
-  if (!timer_started(&pplayer->safe_timer) || (frame % 2) == 0)
+  if (!timer_started(&safe_timer) || (global_frame_counter % 2) == 0)
     {
-      if (pplayer->size == SMALL)
+      if (size == SMALL)
         {
-          if (timer_started(&pplayer->invincible_timer))
+          if (timer_started(&invincible_timer))
             {
               /* Draw cape: */
 
-              if (pplayer->dir == RIGHT)
+              if (dir == RIGHT)
                 {
-                  texture_draw(&cape_right[frame % 2],
-                               pplayer->base.x- scroll_x, pplayer->base.y);
+                  texture_draw(&cape_right[global_frame_counter % 2],
+                               base.x- scroll_x, base.y);
                 }
               else
                 {
-                  texture_draw(&cape_left[frame % 2],
-                               pplayer->base.x- scroll_x, pplayer->base.y);
+                  texture_draw(&cape_left[global_frame_counter % 2],
+                               base.x- scroll_x, base.y);
                 }
             }
 
 
-          if (!pplayer->got_coffee)
+          if (!got_coffee)
             {
-              if (pplayer->dir == RIGHT)
+              if (dir == RIGHT)
                 {
-                  texture_draw(&tux_right[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y);
+                  texture_draw(&tux_right[frame_], base.x- scroll_x, base.y);
                 }
               else
                 {
-                  texture_draw(&tux_left[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y);
+                  texture_draw(&tux_left[frame_], base.x- scroll_x, base.y);
                 }
             }
           else
             {
               /* Tux got coffee! */
 
-              if (pplayer->dir == RIGHT)
+              if (dir == RIGHT)
                 {
-                  texture_draw(&firetux_right[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y);
+                  texture_draw(&firetux_right[frame_], base.x- scroll_x, base.y);
                 }
               else
                 {
-                  texture_draw(&firetux_left[pplayer->frame], pplayer->base.x- scroll_x, pplayer->base.y);
+                  texture_draw(&firetux_left[frame_], base.x- scroll_x, base.y);
                 }
             }
         }
       else
         {
-          if (timer_started(&pplayer->invincible_timer))
+          if (timer_started(&invincible_timer))
             {
               /* Draw cape: */
-
-              if (pplayer->dir == RIGHT)
+              if (dir == RIGHT)
                 {
-                  texture_draw(&bigcape_right[frame % 2],
-                               pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                  texture_draw(&bigcape_right[global_frame_counter % 2],
+                               base.x- scroll_x - 8, base.y);
                 }
               else
                 {
-                  texture_draw(&bigcape_left[frame % 2],
-                               pplayer->base.x-scroll_x - 8, pplayer->base.y);
+                  texture_draw(&bigcape_left[global_frame_counter % 2],
+                               base.x-scroll_x - 8, base.y);
                 }
             }
 
-          if (!pplayer->got_coffee)
+          if (!got_coffee)
             {
-              if (!pplayer->duck)
+              if (!duck)
                 {
-                  if (!timer_started(&pplayer->skidding_timer))
+                  if (!timer_started(&skidding_timer))
                     {
-                      if (!pplayer->jumping || pplayer->base.ym > 0)
+                      if (!jumping || base.ym > 0)
                         {
-                          if (pplayer->dir == RIGHT)
+                          if (dir == RIGHT)
                             {
-                              texture_draw(&bigtux_right[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                              texture_draw(&bigtux_right[frame_],
+                                           base.x- scroll_x - 8, base.y);
                             }
                           else
                             {
-                              texture_draw(&bigtux_left[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                              texture_draw(&bigtux_left[frame_],
+                                           base.x- scroll_x - 8, base.y);
                             }
                         }
                       else
                         {
-                          if (pplayer->dir == RIGHT)
+                          if (dir == RIGHT)
                             {
                               texture_draw(&bigtux_right_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                           base.x- scroll_x - 8, base.y);
                             }
                           else
                             {
                               texture_draw(&bigtux_left_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                           base.x- scroll_x - 8, base.y);
                             }
                         }
                     }
                   else
                     {
-                      if (pplayer->dir == RIGHT)
+                      if (dir == RIGHT)
                         {
                           texture_draw(&skidtux_right,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                       base.x- scroll_x - 8, base.y);
                         }
                       else
                         {
                           texture_draw(&skidtux_left,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                       base.x- scroll_x - 8, base.y);
                         }
                     }
                 }
               else
                 {
-                  if (pplayer->dir == RIGHT)
+                  if (dir == RIGHT)
                     {
-                      texture_draw(&ducktux_right, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16);
+                      texture_draw(&ducktux_right, base.x- scroll_x - 8, base.y - 16);
                     }
                   else
                     {
-                      texture_draw(&ducktux_left, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16);
+                      texture_draw(&ducktux_left, base.x- scroll_x - 8, base.y - 16);
                     }
                 }
             }
@@ -740,60 +759,60 @@ void player_draw(player_type* pplayer)
             {
               /* Tux has coffee! */
 
-              if (!pplayer->duck)
+              if (!duck)
                 {
-                  if (!timer_started(&pplayer->skidding_timer))
+                  if (!timer_started(&skidding_timer))
                     {
-                      if (!pplayer->jumping || pplayer->base.ym > 0)
+                      if (!jumping || base.ym > 0)
                         {
-                          if (pplayer->dir == RIGHT)
+                          if (dir == RIGHT)
                             {
-                              texture_draw(&bigfiretux_right[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                              texture_draw(&bigfiretux_right[frame_],
+                                           base.x- scroll_x - 8, base.y);
                             }
                           else
                             {
-                              texture_draw(&bigfiretux_left[pplayer->frame],
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                              texture_draw(&bigfiretux_left[frame_],
+                                           base.x- scroll_x - 8, base.y);
                             }
                         }
                       else
                         {
-                          if (pplayer->dir == RIGHT)
+                          if (dir == RIGHT)
                             {
                               texture_draw(&bigfiretux_right_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                           base.x- scroll_x - 8, base.y);
                             }
                           else
                             {
                               texture_draw(&bigfiretux_left_jump,
-                                           pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                           base.x- scroll_x - 8, base.y);
                             }
                         }
                     }
                   else
                     {
-                      if (pplayer->dir == RIGHT)
+                      if (dir == RIGHT)
                         {
                           texture_draw(&skidfiretux_right,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                       base.x- scroll_x - 8, base.y);
                         }
                       else
                         {
                           texture_draw(&skidfiretux_left,
-                                       pplayer->base.x- scroll_x - 8, pplayer->base.y);
+                                       base.x- scroll_x - 8, base.y);
                         }
                     }
                 }
               else
                 {
-                  if (pplayer->dir == RIGHT)
+                  if (dir == RIGHT)
                     {
-                      texture_draw(&duckfiretux_right, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16);
+                      texture_draw(&duckfiretux_right, base.x- scroll_x - 8, base.y - 16);
                     }
                   else
                     {
-                      texture_draw(&duckfiretux_left, pplayer->base.x- scroll_x - 8, pplayer->base.y - 16);
+                      texture_draw(&duckfiretux_left, base.x- scroll_x - 8, base.y - 16);
                     }
                 }
             }
@@ -801,7 +820,8 @@ void player_draw(player_type* pplayer)
     }
 }
 
-void player_collision(player_type* pplayer, void* p_c_object, int c_object)
+void
+Player::collision(void* p_c_object, int c_object)
 {
   BadGuy* pbad_c = NULL;
 
@@ -811,18 +831,18 @@ void player_collision(player_type* pplayer, void* p_c_object, int c_object)
       pbad_c = (BadGuy*) p_c_object;
       /* Hurt the player if he just touched it: */
 
-      if (!pbad_c->dying && !pplayer->dying &&
-          !timer_started(&pplayer->safe_timer) &&
+      if (!pbad_c->dying && !dying &&
+          !timer_started(&safe_timer) &&
           pbad_c->mode != HELD)
         {
-          if (pbad_c->mode == FLAT  && pplayer->input.fire != DOWN)
+          if (pbad_c->mode == FLAT  && input_.fire != DOWN)
             {
               /* Kick: */
 
               pbad_c->mode = KICK;
               play_sound(sounds[SND_KICK], SOUND_CENTER_SPEAKER);
 
-              if (pplayer->base.x < pbad_c->base.x + (pbad_c->base.width/2))
+              if (base.x < pbad_c->base.x + (pbad_c->base.width/2))
                 {
                   pbad_c->dir = RIGHT;
                   pbad_c->base.x = pbad_c->base.x + 16;
@@ -835,14 +855,14 @@ void player_collision(player_type* pplayer, void* p_c_object, int c_object)
 
               timer_start(&pbad_c->timer,5000);
             }
-          else if (pbad_c->mode == FLAT && pplayer->input.fire == DOWN)
+          else if (pbad_c->mode == FLAT && input_.fire == DOWN)
             {
               pbad_c->mode = HELD;
               pbad_c->base.y-=8;
             }
           else if (pbad_c->mode == KICK)
             {
-              if (pplayer->base.y < pbad_c->base.y - 16 &&
+              if (base.y < pbad_c->base.y - 16 &&
                   timer_started(&pbad_c->timer))
                 {
                   /* Step on (stop being kicked) */
@@ -857,9 +877,9 @@ void player_collision(player_type* pplayer, void* p_c_object, int c_object)
 
                   if (timer_started(&pbad_c->timer))
                     {
-                      if (!timer_started(&pplayer->invincible_timer))
+                      if (!timer_started(&invincible_timer))
                         {
-                          player_kill(pplayer,SHRINK);
+                          kill(SHRINK);
                         }
                       else
                         {
@@ -874,9 +894,9 @@ void player_collision(player_type* pplayer, void* p_c_object, int c_object)
             }
           else
             {
-              if (!timer_started(&pplayer->invincible_timer ))
+              if (!timer_started(&invincible_timer ))
                 {
-                  player_kill(pplayer,SHRINK);
+                  kill(SHRINK);
                 }
               else
                 {
@@ -898,92 +918,96 @@ void player_collision(player_type* pplayer, void* p_c_object, int c_object)
 
 /* Kill Player! */
 
-void player_kill(player_type* pplayer, int mode)
+void
+Player::kill(int mode)
 {
-  pplayer->base.ym = -5;
+  base.ym = -5;
 
   play_sound(sounds[SND_HURT], SOUND_CENTER_SPEAKER);
 
-  if (pplayer->dir == RIGHT)
-    pplayer->base.xm = -8;
-  else if (pplayer->dir == LEFT)
-    pplayer->base.xm = 8;
+  if (dir == RIGHT)
+    base.xm = -8;
+  else if (dir == LEFT)
+    base.xm = 8;
 
-  if (mode == SHRINK && pplayer->size == BIG)
+  if (mode == SHRINK && size == BIG)
     {
-      if (pplayer->got_coffee)
-        pplayer->got_coffee = false;
+      if (got_coffee)
+        got_coffee = false;
 
-      pplayer->size = SMALL;
-      pplayer->base.height = 32;
+      size = SMALL;
+      base.height = 32;
 
-      timer_start(&pplayer->safe_timer,TUX_SAFE_TIME);
+      timer_start(&safe_timer,TUX_SAFE_TIME);
     }
   else
     {
-      pplayer->dying = DYING_SQUISHED;
+      dying = DYING_SQUISHED;
     }
 }
 
-void player_dying(player_type *pplayer)
+void
+Player::is_dying()
 {
-  pplayer->base.ym = pplayer->base.ym + gravity;
+  base.ym = base.ym + gravity;
 
   /* He died :^( */
 
-  --pplayer->lives;
-  player_remove_powerups(pplayer);
-  pplayer->dying = DYING_NOT;
-
-  player_level_begin(pplayer);
+  --lives;
+  remove_powerups();
+  dying = DYING_NOT;
+  
+  level_begin();
 
 }
 
 /* Remove Tux's power ups */
-void player_remove_powerups(player_type* pplayer)
+void
+Player::remove_powerups()
 {
-  pplayer->got_coffee = false;
-  pplayer->size = SMALL;
-  pplayer->base.height = 32;
+  got_coffee = false;
+  size = SMALL;
+  base.height = 32;
 }
 
-void player_keep_in_bounds(player_type* pplayer)
+void
+Player::keep_in_bounds()
 {
   /* Keep tux in bounds: */
-  if (pplayer->base.x< 0)
-    pplayer->base.x= 0;
-  else if(pplayer->base.x< scroll_x)
-    pplayer->base.x= scroll_x;
-  else if (pplayer->base.x< 160 + scroll_x && scroll_x > 0 && debug_mode == true)
+  if (base.x< 0)
+    base.x= 0;
+  else if(base.x< scroll_x)
+    base.x= scroll_x;
+  else if (base.x< 160 + scroll_x && scroll_x > 0 && debug_mode == true)
     {
-      scroll_x = pplayer->base.x- 160;
-      /*pplayer->base.x+= 160;*/
+      scroll_x = base.x- 160;
+      /*base.x+= 160;*/
 
       if(scroll_x < 0)
         scroll_x = 0;
 
     }
-  else if (pplayer->base.x> screen->w / 2 + scroll_x && scroll_x < ((current_level.width * 32) - screen->w))
+  else if (base.x> screen->w / 2 + scroll_x && scroll_x < ((current_level.width * 32) - screen->w))
     {
       /* Scroll the screen in past center: */
 
-      scroll_x = pplayer->base.x- screen->w / 2;
-      /*pplayer->base.x= 320 + scroll_x;*/
+      scroll_x = base.x- screen->w / 2;
+      /*base.x= 320 + scroll_x;*/
 
       if (scroll_x > ((current_level.width * 32) - screen->w))
         scroll_x = ((current_level.width * 32) - screen->w);
     }
-  else if (pplayer->base.x> 608 + scroll_x)
+  else if (base.x> 608 + scroll_x)
     {
       /* ... unless there's no more to scroll! */
 
-      /*pplayer->base.x= 608 + scroll_x;*/
+      /*base.x= 608 + scroll_x;*/
     }
 
   /* Keep in-bounds, vertically: */
 
-  if (pplayer->base.y > screen->h)
+  if (base.y > screen->h)
     {
-      player_kill(&tux,KILL);
+      kill(KILL);
     }
 }
index cdbd0cb..0b47410 100644 (file)
@@ -58,9 +58,36 @@ struct player_input_type
 
 void player_input_init(player_input_type* pplayer_input);
 
-struct player_type 
+extern texture_type tux_life;
+extern texture_type tux_right[3];
+extern texture_type tux_left[3];
+extern texture_type bigtux_right[3];
+extern texture_type bigtux_left[3];
+extern texture_type bigtux_right_jump;
+extern texture_type bigtux_left_jump;
+extern texture_type ducktux_right;
+extern texture_type ducktux_left;
+extern texture_type skidtux_right;
+extern texture_type skidtux_left;
+extern texture_type firetux_right[3];
+extern texture_type firetux_left[3];
+extern texture_type bigfiretux_right[3];
+extern texture_type bigfiretux_left[3];
+extern texture_type bigfiretux_right_jump;
+extern texture_type bigfiretux_left_jump;
+extern texture_type duckfiretux_right;
+extern texture_type duckfiretux_left;
+extern texture_type skidfiretux_right;
+extern texture_type skidfiretux_left;
+extern texture_type cape_right[2];
+extern texture_type cape_left[2];
+extern texture_type bigcape_right[2];
+extern texture_type bigcape_left[2];
+
+class Player
 {
-  player_input_type input;
+ public:
+  player_input_type  input_;
   player_keymap_type keymap;
   int score;
   int distros;
@@ -70,8 +97,8 @@ struct player_type
   DyingType dying;
   int dir;
   bool jumping;
+  int frame_;
   int frame_main;
-  int frame;
   int lives;
   base_type base;
   base_type old_base;
@@ -82,35 +109,26 @@ struct player_type
   timer_type frame_timer;
   physic_type vphysic;
   physic_type hphysic;
-};
 
-extern texture_type tux_life,
- tux_right[3],  tux_left[3],
- bigtux_right[3],  bigtux_left[3],
- bigtux_right_jump,  bigtux_left_jump,
- ducktux_right,  ducktux_left,
- skidtux_right,  skidtux_left,
- firetux_right[3],  firetux_left[3],
- bigfiretux_right[3],  bigfiretux_left[3],
- bigfiretux_right_jump,  bigfiretux_left_jump,
- duckfiretux_right,  duckfiretux_left,
- skidfiretux_right,  skidfiretux_left,
- cape_right[2],  cape_left[2],
- bigcape_right[2],  bigcape_left[2];
-
-void player_init(player_type* pplayer);
-int player_key_event(player_type* pplayer, SDLKey key, int state);
-void player_level_begin(player_type* pplayer);
-void player_action(player_type* pplayer);
-void player_input(player_type* pplayer);
-void player_grabdistros(player_type *pplayer);
-void player_draw(player_type* pplayer);
-void player_collision(player_type* pplayer,void* p_c_object, int c_object);
-void player_kill(player_type *pplayer, int mode);
-void player_dying(player_type *pplayer);
-void player_remove_powerups(player_type *pplayer);
-void player_keep_in_bounds(player_type *pplayer);
-bool player_on_ground(player_type *pplayer);
-bool player_under_solid(player_type *pplayer);
+ public:
+  void init();
+  int  key_event(SDLKey key, int state);
+  void level_begin();
+  void action();
+  void input();
+  void grabdistros();
+  void draw();
+  void collision(void* p_c_object, int c_object);
+  void kill(int mode);
+  void is_dying();
+  void player_remove_powerups();
+  void keep_in_bounds();
+  bool on_ground();
+  bool under_solid();
+ private:
+  void handle_horizontal_input(int dir);
+  void handle_vertical_input();
+  void remove_powerups();
+};
 
 #endif /*SUPERTUX_PLAYER_H*/
index f85d603..d85e9e8 100644 (file)
@@ -25,7 +25,7 @@ bool counting_distros;
 int distro_counter;
 timer_type  super_bkgd_timer;
 float scroll_x;
-int frame;
+int global_frame_counter;
 std::vector<bouncy_distro_type> bouncy_distros;
 std::vector<broken_brick_type> broken_bricks;
 std::vector<bouncy_brick_type> bouncy_bricks;
@@ -33,7 +33,7 @@ std::vector<BadGuy> bad_guys;
 std::vector<floating_score_type> floating_scores;
 std::vector<upgrade_type> upgrades;
 std::vector<bullet_type> bullets;
-player_type tux;
+Player tux;
 texture_type img_box_full, img_box_empty, img_mints, img_coffee, img_super_bkgd, img_red_glow;
 timer_type time_left;
 double frame_ratio;
index dc3e1fa..a77fb64 100644 (file)
@@ -35,7 +35,7 @@ extern int distro_counter;
 
 extern timer_type  super_bkgd_timer;
 extern float scroll_x;
-extern int frame;
+extern int global_frame_counter;
 extern std::vector<bouncy_distro_type> bouncy_distros;
 extern std::vector<broken_brick_type> broken_bricks;
 extern std::vector<bouncy_brick_type> bouncy_bricks;
@@ -43,7 +43,7 @@ extern std::vector<BadGuy> bad_guys;
 extern std::vector<floating_score_type> floating_scores;
 extern std::vector<upgrade_type> upgrades;
 extern std::vector<bullet_type> bullets;
-extern player_type tux;
+extern Player tux;
 extern texture_type img_box_full, img_box_empty, img_mints, img_coffee, img_super_bkgd, img_red_glow;
 extern timer_type time_left;
 extern double frame_ratio;
index 0291494..69fc093 100644 (file)
@@ -221,7 +221,7 @@ void upgrade_draw(upgrade_type* pupgrade)
 
 void upgrade_collision(upgrade_type* pupgrade, void* p_c_object, int c_object)
 {
-  player_type* pplayer = NULL;
+  Player* pplayer = NULL;
 
   switch (c_object)
     {
@@ -229,7 +229,7 @@ void upgrade_collision(upgrade_type* pupgrade, void* p_c_object, int c_object)
       /* Remove the upgrade: */
 
       /* p_c_object is CO_PLAYER, so assign it to pplayer */
-      pplayer = (player_type*) p_c_object;
+      pplayer = (Player*) p_c_object;
 
       upgrades.erase(static_cast<std::vector<upgrade_type>::iterator>(pupgrade));