Subversion Repositories Games.Chess Giants

// scene.cpp

#include "common.h"

// prototypes of local functions

static void Scene_AddPart (scene_t *scene, int part_type, int part_color, float pos_x, float pos_y, float pos_z, float turn_yaw, float pitch);

static void Scene_AddTile (scene_t *scene, int tile_type, float scale, float pos_x, float pos_y, float pos_z, float turn_yaw);

// global variables used in this module only

static wchar_t connected_comment[4096];

static wchar_t filename[MAX_PATH];

static float simpleshadow_sizes[] =

{

   0, // #define PART_NONE 0

   2.5f, // #define PART_KING 1

   2.45f, // #define PART_QUEEN 2

   2.35f, // #define PART_BISHOP 3

   2.25f, // #define PART_KNIGHT 4

   2.15f, // #define PART_ROOK 5

   2.0f, // #define PART_PAWN 6

};

void Scene_Init (scene_t *scene, board_t *board)

{

   // this function initializes the scene objects array and inserts the chess table in it

   wchar_t format_string[4096];

   // allocate array for the board (3 objects) and zero it out

   scene->objects = (sceneobject_t *) SAFE_malloc (3, sizeof (sceneobject_t), true);

   // insert the table edges, the table and the board

   scene->objects[0].mesh_index = theme->trim_meshindex;

   scene->objects[0].texture_index = theme->trim_texture;

   scene->objects[0].scale = 1.0f;

   scene->objects[1].mesh_index = theme->table_meshindex;

   scene->objects[1].texture_index = theme->table_texture;

   scene->objects[1].scale = 1.0f;

   scene->objects[2].mesh_index = theme->board_meshindex;

   scene->objects[2].texture_index = theme->board_texture;

   scene->objects[2].scale = 1.0f;

   scene->object_count = 3;

   // reset the camera position for a cool slide-in effect, but only if autorotate is enabled

   if (options.want_autorotateon1vs1)

   {

      current_pitch = 6.0f; // autorotate is enabled, prepare for slide-in effect

      current_yaw = (Board_ColorToMove (board) == COLOR_WHITE ? 90.0f : -90.0f);

      current_distance = 40.0f;

   }

   else

   {

      current_pitch = 55.0f; // no autorotate, reset to standard view position directly

      current_yaw = (Board_ColorToMove (board) == COLOR_BLACK ? 90.0f : -90.0f);

      current_distance = 70.0f;

   }

   // HACK to prevent the player to click and block the view angles while the slide-in is not finished

   command_ignoretime = current_time + 2.0f; // allow 2 seconds

   // build the connected comment string (we use it as a global variable)

   wcscpy_s (format_string, WCHAR_SIZEOF (format_string), LOCALIZE (L"YouAreConnectedToX"));

   wcscat_s (format_string, WCHAR_SIZEOF (format_string), L"\n");

   wcscat_s (format_string, WCHAR_SIZEOF (format_string), LOCALIZE (L"YouMayEitherDisplayThePlayersListOrTheSoughtGamesList"));

   wcscat_s (format_string, WCHAR_SIZEOF (format_string), L"\n");

   wcscat_s (format_string, WCHAR_SIZEOF (format_string), LOCALIZE (L"PleaseReferToTheInternetMenu"));

   swprintf_s (connected_comment, WCHAR_SIZEOF (connected_comment), format_string, options.network.server_address);

   // completely reset the whole GUI structure so as to NULL out all pointers

   memset (&scene->gui, 0, sizeof (scene->gui));

   // set the buttons locations

   Scene_SetButton (&scene->gui.larrow, 0.3f, 0.5f, 3.0f, 4.0f, larrow_spriteindex);

   Scene_SetButton (&scene->gui.rarrow, 3.3f, 0.5f, 3.0f, 4.0f, rarrow_spriteindex);

   Scene_SetButton (&scene->gui.chatbutton, 1.0f, 10.0f, 10.0f, 13.0f, chatbutton_spriteindex);

   Scene_SetButton (&scene->gui.gamesbutton, 1.0f, 35.0f, 10.0f, 13.0f, gamesbutton_spriteindex);

   Scene_SetButton (&scene->gui.peoplebutton, 1.0f, 60.0f, 10.0f, 13.0f, peoplebutton_spriteindex);

   // remember to update the scene

   scene->update = true;

   return; // finished

}

void Scene_Shutdown (scene_t *scene)

{

   // this function frees the memory space allocated for the 3D scene and clears its pointers

   int cchistory_index;

   // free GUI mallocated buffers

   SAFE_free ((void **) &scene->gui.arrow_text.buffer);

   scene->gui.arrow_text.is_displayed = false;

   SAFE_free ((void **) &scene->gui.comment_text.buffer);

   scene->gui.comment_text.is_displayed = false;

   SAFE_free ((void **) &scene->gui.history_text.buffer);

   scene->gui.history_text.is_displayed = false;

   SAFE_free ((void **) &scene->gui.clock_text.buffer);

   scene->gui.clock_text.is_displayed = false;

   SAFE_free ((void **) &scene->gui.turn_text.buffer);

   scene->gui.turn_text.is_displayed = false;

   SAFE_free ((void **) &scene->gui.central_text.buffer);

   scene->gui.central_text.is_displayed = false;

   // for each entry in the CC history...

   for (cchistory_index = 0; cchistory_index < scene->gui.cchistory_count; cchistory_index++)

      SAFE_free ((void **) &scene->gui.cchistory[cchistory_index].text); // free its text buffer

   SAFE_free ((void **) &scene->gui.cchistory); // free the GUI's CC history

   scene->gui.cchistory_count = 0;

   SAFE_free ((void **) &scene->objects); // free the scene objects array

   scene->object_count = 0;

   return; // finished

}

void Scene_Update (scene_t *scene, board_t *board)

{

   // this function updates the scene objects to display with what's currently on the board

   static bool rooksound_played = false; // hack to have two sounds when a king castles

   boardslot_t *boardslot;

   boardmove_t *currentmove;

   player_t *local_player;

   player_t *network_player;

   player_t *current_player;

   wchar_t *history_text; // mallocated

   int historytext_size;

   unsigned char takenpart_type;

   int movement_direction;

   int line;

   int column;

   int pos_index;

   int part_index;

   int move_index;

   int start_index;

   int length;

   int threat_line;

   int threat_column;

   int minutes;

   int seconds;

   float yaw;

   float source_x;

   float source_y;

   float target_x;

   float target_y;

   float current_x;

   float current_y;

   float current_z;

   int movement_diffco;

   int movement_diffli;

   float movement_maxheight;

   float movement_ratio;

   // get the current player (we'll need it) and see if we're online

   current_player = Player_GetCurrent ();

   network_player = Player_FindByType (PLAYER_INTERNET);

   // fetch the background sprite from the theme

   if (want_custombackground)

      scene->background_spriteindex = custombg.sprite_index; // use the custom background if specified

   else

      scene->background_spriteindex = theme->bg.sprite_index; // else use the theme's supplied background

   // shrink the scene objects array to leave just the board (3 objects)

   scene->objects = (sceneobject_t *) SAFE_realloc (scene->objects, scene->object_count, 3, sizeof (sceneobject_t), false);

   scene->object_count = 3;

   // update the board theme

   scene->objects[0].mesh_index = theme->trim_meshindex;

   scene->objects[0].texture_index = theme->trim_texture;

   scene->objects[0].material_index = theme->trim_material;

   scene->objects[0].scale = 1.0f;

   scene->objects[1].mesh_index = theme->table_meshindex;

   scene->objects[1].texture_index = theme->table_texture;

   scene->objects[1].material_index = theme->table_material;

   scene->objects[1].scale = 1.0f;

   scene->objects[2].mesh_index = theme->board_meshindex;

   scene->objects[2].texture_index = theme->board_texture;

   scene->objects[2].material_index = theme->board_material;

   scene->objects[2].scale = 1.0f;

   // draw the grid numbers if we want them

   if (want_grid)

      Scene_AddTile (scene, theme->grid_texture, 30.0f, 0.0f, 0.0f, 0.01f, 0.0f);

   ////////////////////////////////////////////////////////////////////////////////////////////////

   // draw the 3D parts that are still in play

   currentmove = &board->moves[board->viewed_move]; // quick access to current move

   // if we want the 3D parts, cycle through all the grid and place them

   if (!want_flaticons || (current_player->view_pitch < MAX_PITCH_FOR_FLAT_ICONS))

      for (line = 0; line < 8; line++)

         for (column = 0; column < 8; column++)

         {

            boardslot = &currentmove->slots[line][column]; // quick access to grid slot

            // is there nothing on this grid slot ?

            if (boardslot->part == PART_NONE)

               continue; // then don't draw anything on it

            // has a movement happened yet AND does it land on this slot ?

            if ((board->viewed_move > 0)

                && (line == currentmove->target[0]) && (column == currentmove->target[1]))

            {

               // do we want animations AND is it still time to play the animation ?

               if (options.want_animations && (animation_endtime > current_time))

               {

                  // get the source and target X and Y positions

                  source_x = 17.5f - (7 - currentmove->source[1]) * 5.0f;

                  source_y = 17.5f - currentmove->source[0] * 5.0f;

                  target_x = 17.5f - (7 - currentmove->target[1]) * 5.0f;

                  target_y = 17.5f - currentmove->target[0] * 5.0f;

                  // compute the movement completion ratio between 0 and 1

                  movement_ratio = 1.0f - (animation_endtime - current_time) / ANIMATION_DURATION;

                  // compute the current X an Y based on movement timing

                  current_x = source_x + (target_x - source_x) * movement_ratio;

                  current_y = source_y + (target_y - source_y) * movement_ratio;

                  // height is a sine positive, max height is proportional to travelled distance

                  movement_diffco = abs (currentmove->target[1] - currentmove->source[1]);

                  movement_diffli = abs (currentmove->target[0] - currentmove->source[0]);

                  movement_maxheight = 0.5f + (float) movement_diffco + (float) movement_diffli;

                  if (currentmove->part == PART_KNIGHT)

                     movement_maxheight *= 2.0f; // knights jump high

                  else if ((currentmove->part == PART_KING) && (movement_diffco == 2))

                     movement_maxheight *= 5.0f; // kings jump VERY high when castling too

                  else if (movement_maxheight > 5.0f)

                     movement_maxheight = 5.0f; // all other parts just hover above the ground

                  current_z = 0.04f + sin (MATH_PI * movement_ratio) * movement_maxheight;

                  // make this part move realistically

                  Scene_AddPart (scene, boardslot->part, boardslot->color, current_x, current_y, current_z, 0.0f, (boardslot->color == COLOR_BLACK ? -1 : 1) * min (current_z * 3.0f, 10.0f));

               }

               else

                  Scene_AddPart (scene, boardslot->part, boardslot->color, 17.5f - (7 - column) * 5.0f, 17.5f - line * 5.0f, 0.04f, 0.0f, 0.0f);

               // is it time to play a move sound ?

               if ((sound_playtime != 0) && (sound_playtime < current_time))

               {

                  // is the current player in check ? (to play the right sound)

                  // read as: was the last move an opponent's move AND did it put us to check ?

                  if (currentmove->is_check)

                  {

                     // is it a checkmate or a normal check ? (checkmate == check + stalemate)

                     if (currentmove->is_stalemate)

                        Audio_PlaySound (board->players[currentmove->color].type == PLAYER_HUMAN ? SOUNDTYPE_VICTORY : SOUNDTYPE_DEFEAT); // if so, play endgame sound

                     else

                        Audio_PlaySound (SOUNDTYPE_CHECK); // else play the check sound

                  }

                  else

                  {

                     // is it a stalemate, a capture or a normal move ?

                     if (currentmove->is_stalemate)

                        Audio_PlaySound (SOUNDTYPE_DEFEAT); // on stalemate, play defeat sound

                     else if (currentmove->has_captured)

                        Audio_PlaySound (SOUNDTYPE_PIECETAKEN); // on capture, play the capture sound

                     else

                        Audio_PlaySound (SOUNDTYPE_MOVE); // else play the normal move sound

                  }

                  sound_playtime = 0; // mark this animation as completed and sound played

               }

            }

            // else has a movement happened yet AND is this movement a castle AND is this the concerned tower ?

            else if ((board->viewed_move > 0)

                     && (towupper (currentmove->pgntext[0]) == L'O') // either O-O-O or O-O

                     && (line == (currentmove->color == COLOR_WHITE ? 0 : 7)) && (column == (currentmove->target[1] == 2 ? 3 : 5)))

            {

               // do we want animations AND is it still time to play the animation ? (castling rooks move faster)

               if (options.want_animations && (animation_endtime - (0.5f * ANIMATION_DURATION) > current_time))

               {

                  // get the source and target X and Y positions

                  source_x = 17.5f - (7 - (currentmove->target[1] == 2 ? 0 : 7)) * 5.0f; // if king moves left, then rook starts on column a, else it starts on column h

                  source_y = 17.5f - line * 5.0f;

                  target_x = 17.5f - (7 - column) * 5.0f;

                  target_y = 17.5f - line * 5.0f;

                  // compute the movement completion ratio between 0 and 1 (castling rooks move faster)

                  movement_ratio = min (1.0f, 1.0f - (animation_endtime - (0.5f * ANIMATION_DURATION) - current_time) / (0.5f * ANIMATION_DURATION));

                  // compute the current X an Y based on movement timing

                  current_x = source_x + (target_x - source_x) * movement_ratio;

                  current_y = source_y + (target_y - source_y) * movement_ratio;

                  // height is a sine positive, max height is proportional to travelled distance

                  movement_maxheight = 1.0f; // castling rook will barely hover above the ground

                  current_z = 0.04f + sin (MATH_PI * movement_ratio) * movement_maxheight;

                  // make this part move realistically

                  Scene_AddPart (scene, boardslot->part, boardslot->color, current_x, current_y, current_z, 0.0f, (boardslot->color == COLOR_BLACK ? -1 : 1) * min (current_z * 3.0f, 10.0f));

                  if (movement_ratio < 0.9f)

                     rooksound_played = false; // if the rook is still moving, reset the "sound played" flag

                  else if (!rooksound_played)

                  {

                     Audio_PlaySound (SOUNDTYPE_MOVE); // when the rook has landed, play a move sound

                     rooksound_played = true; // remember this is no longer to be done

                  }

               }

               else

                  Scene_AddPart (scene, boardslot->part, boardslot->color, 17.5f - (7 - column) * 5.0f, 17.5f - line * 5.0f, 0.04f, 0.0f, 0.0f);

            }

            // else this part is static, so draw a static object

            else

               Scene_AddPart (scene, boardslot->part, boardslot->color, 17.5f - (7 - column) * 5.0f, 17.5f - line * 5.0f, 0.04f, 0.0f, 0.0f);

         }

   ////////////////////////////////////////////////////////////////////////////////////////////////

   // now recompute the slot textures (only in play mode when we render the real board)

   // erase all the slot flags

   for (line = 0; line < 8; line++)

      for (column = 0; column < 8; column++)

         currentmove->slots[line][column].flags = FLAG_NONE; // because we will recompute them

   // cycle through all the grid again and see if either king is in check

   for (line = 0; line < 8; line++)

      for (column = 0; column < 8; column++)

      {

         boardslot = &currentmove->slots[line][column]; // quick access to grid slot

         if (boardslot->part != PART_KING)

            continue; // if this slot is not a king, skip it

         // is this king currently threatened ?

         if (Move_IsKingThreatenedAtLocation (currentmove, boardslot->color, line, column, &threat_line, &threat_column))

         {

            currentmove->slots[line][column].flags |= FLAG_CHECK; // mark it as threatened

            currentmove->slots[threat_line][threat_column].flags |= FLAG_THREAT; // and who threatens it

         }

      }

   // are we in play mode ? i.e, are we rendering the last move ?

   if (board->viewed_move == board->move_count - 1)

   {

      // mark the selected position as selected

      if (IS_VALID_POSITION (board->selected_position))

         currentmove->slots[board->selected_position[0]][board->selected_position[1]].flags |= FLAG_SELECTED;

      // now cycle through all the grid again and see if some slots need to be coloured

      for (line = 0; line < 8; line++)

         for (column = 0; column < 8; column++)

         {

            boardslot = &currentmove->slots[line][column]; // quick access to grid slot

            if (!(boardslot->flags & FLAG_SELECTED))

               continue; // if this slot is not selected, skip it

            //////////////////////////////////////////////////////////////////////////////////////////

            ////////////////////////////////////////// PAWN //////////////////////////////////////////

            //////////////////////////////////////////////////////////////////////////////////////////

            // is it a pawn ?

            if (boardslot->part == PART_PAWN)

            {

               // figure out movement direction

               if (boardslot->color == COLOR_WHITE)

                  movement_direction = 1;

               else

                  movement_direction = -1;

               // if pawn has still room to move forward, it can

               if ((((line < 7) && (movement_direction == 1)) || ((line > 0) && (movement_direction == -1)))

                   && (currentmove->slots[line + movement_direction][column].part == PART_NONE))

               {

                  currentmove->slots[line + movement_direction][column].flags |= FLAG_POSSIBLEMOVE;

                  // if pawn is still in its initial slot, it can move twice forward

                  if ((((line == 1) && (movement_direction == 1)) || ((line == 6) && (movement_direction == -1)))

                      && (currentmove->slots[line + movement_direction * 2][column].part == PART_NONE))

                     currentmove->slots[line + movement_direction * 2][column].flags |= FLAG_POSSIBLEMOVE;

               }

               // see if pawn can take a piece on its left

               if ((column > 0) && (currentmove->slots[line + movement_direction][column - 1].part != PART_NONE)

                   && (currentmove->slots[line + movement_direction][column - 1].color != currentmove->slots[line][column].color))

                  currentmove->slots[line + movement_direction][column - 1].flags |= FLAG_TAKEABLE;

               // see if pawn can take a piece on its right

               if ((column < 7) && (currentmove->slots[line + movement_direction][column + 1].part != PART_NONE)

                   && (currentmove->slots[line + movement_direction][column + 1].color != currentmove->slots[line][column].color))

                  currentmove->slots[line + movement_direction][column + 1].flags |= FLAG_TAKEABLE;

               // if previous move was a pawn rush, see if pawn can take "en passant"

               if ((currentmove->part == PART_PAWN)

                     && (currentmove->target[1] == currentmove->source[1]) // pawn moved in column

                     && (abs (currentmove->target[0] - currentmove->source[0]) == 2) // pawn rushed

                     && (currentmove->target[0] == line) // pawn is in line with us

                     && (abs (currentmove->target[1] - column) == 1)) // pawn is next to us

                  currentmove->slots[line + movement_direction][currentmove->target[1]].flags |= FLAG_TAKEABLE;

            }

            //////////////////////////////////////////////////////////////////////////////////////////

            ////////////////////////////////////////// ROOK //////////////////////////////////////////

            //////////////////////////////////////////////////////////////////////////////////////////

            // else is it a rook ?

            else if (boardslot->part == PART_ROOK)

            {

               // see how far rook can move upwards

               for (pos_index = line + 1; pos_index < 8; pos_index++)

               {

                  if (currentmove->slots[pos_index][column].part != PART_NONE)

                  {

                     if (currentmove->slots[pos_index][column].color != currentmove->slots[line][column].color)

                        currentmove->slots[pos_index][column].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[pos_index][column].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far rook can move downwards

               for (pos_index = line - 1; pos_index >= 0; pos_index--)

               {

                  if (currentmove->slots[pos_index][column].part != PART_NONE)

                  {

                     if (currentmove->slots[pos_index][column].color != currentmove->slots[line][column].color)

                        currentmove->slots[pos_index][column].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[pos_index][column].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far rook can move left

               for (pos_index = column - 1; pos_index >= 0; pos_index--)

               {

                  if (currentmove->slots[line][pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line][pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line][pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line][pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far rook can move right

               for (pos_index = column + 1; pos_index < 8; pos_index++)

               {

                  if (currentmove->slots[line][pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line][pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line][pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line][pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

            }

            //////////////////////////////////////////////////////////////////////////////////////////

            ///////////////////////////////////////// KNIGHT /////////////////////////////////////////

            //////////////////////////////////////////////////////////////////////////////////////////

            // else is it a knight ?

            else if (boardslot->part == PART_KNIGHT)

            {

               // peek knight's NNW move

               if ((column > 0) && (line < 6))

                  if (currentmove->slots[line + 2][column - 1].part == PART_NONE)

                     currentmove->slots[line + 2][column - 1].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line + 2][column - 1].color != currentmove->slots[line][column].color)

                     currentmove->slots[line + 2][column - 1].flags |= FLAG_TAKEABLE;

               // peek knight's NNE move

               if ((column < 7) && (line < 6))

                  if (currentmove->slots[line + 2][column + 1].part == PART_NONE)

                     currentmove->slots[line + 2][column + 1].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line + 2][column + 1].color != currentmove->slots[line][column].color)

                     currentmove->slots[line + 2][column + 1].flags |= FLAG_TAKEABLE;

               // peek knight's ENE move

               if ((column < 6) && (line < 7))

                  if (currentmove->slots[line + 1][column + 2].part == PART_NONE)

                     currentmove->slots[line + 1][column + 2].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line + 1][column + 2].color != currentmove->slots[line][column].color)

                     currentmove->slots[line + 1][column + 2].flags |= FLAG_TAKEABLE;

               // peek knight's ESE move

               if ((column < 6) && (line > 0))

                  if (currentmove->slots[line - 1][column + 2].part == PART_NONE)

                     currentmove->slots[line - 1][column + 2].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line - 1][column + 2].color != currentmove->slots[line][column].color)

                     currentmove->slots[line - 1][column + 2].flags |= FLAG_TAKEABLE;

               // peek knight's SSW move

               if ((column > 0) && (line > 1))

                  if (currentmove->slots[line - 2][column - 1].part == PART_NONE)

                     currentmove->slots[line - 2][column - 1].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line - 2][column - 1].color != currentmove->slots[line][column].color)

                     currentmove->slots[line - 2][column - 1].flags |= FLAG_TAKEABLE;

               // peek knight's SSE move

               if ((column < 7) && (line > 1))

                  if (currentmove->slots[line - 2][column + 1].part == PART_NONE)

                     currentmove->slots[line - 2][column + 1].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line - 2][column + 1].color != currentmove->slots[line][column].color)

                     currentmove->slots[line - 2][column + 1].flags |= FLAG_TAKEABLE;

               // peek knight's WNW move

               if ((column > 1) && (line < 7))

                  if (currentmove->slots[line + 1][column - 2].part == PART_NONE)

                     currentmove->slots[line + 1][column - 2].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line + 1][column - 2].color != currentmove->slots[line][column].color)

                     currentmove->slots[line + 1][column - 2].flags |= FLAG_TAKEABLE;

               // peek knight's WSW move

               if ((column > 1) && (line > 0))

                  if (currentmove->slots[line - 1][column - 2].part == PART_NONE)

                     currentmove->slots[line - 1][column - 2].flags |= FLAG_POSSIBLEMOVE;

                  else if (currentmove->slots[line - 1][column - 2].color != currentmove->slots[line][column].color)

                     currentmove->slots[line - 1][column - 2].flags |= FLAG_TAKEABLE;

            }

            //////////////////////////////////////////////////////////////////////////////////////////

            ///////////////////////////////////////// BISHOP /////////////////////////////////////////

            //////////////////////////////////////////////////////////////////////////////////////////

            // else is it a bishop ?

            else if (boardslot->part == PART_BISHOP)

            {

               // see how far bishop can move NE

               for (pos_index = 1; pos_index < 8; pos_index++)

               {

                  if ((line + pos_index > 7) || (column + pos_index > 7))

                     break;

                  if (currentmove->slots[line + pos_index][column + pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line + pos_index][column + pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line + pos_index][column + pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line + pos_index][column + pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far bishop can move SE

               for (pos_index = 1; pos_index < 8; pos_index++)

               {

                  if ((line - pos_index < 0) || (column + pos_index > 7))

                     break;

                  if (currentmove->slots[line - pos_index][column + pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line - pos_index][column + pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line - pos_index][column + pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line - pos_index][column + pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far bishop can move NW

               for (pos_index = 1; pos_index < 8; pos_index++)

               {

                  if ((line + pos_index > 7) || (column - pos_index < 0))

                     break;

                  if (currentmove->slots[line + pos_index][column - pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line + pos_index][column - pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line + pos_index][column - pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line + pos_index][column - pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far bishop can move SW

               for (pos_index = 1; pos_index < 8; pos_index++)

               {

                  if ((line - pos_index < 0) || (column - pos_index < 0))

                     break;

                  if (currentmove->slots[line - pos_index][column - pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line - pos_index][column - pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line - pos_index][column - pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line - pos_index][column - pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

            }

            //////////////////////////////////////////////////////////////////////////////////////////

            ///////////////////////////////////////// QUEEN //////////////////////////////////////////

            //////////////////////////////////////////////////////////////////////////////////////////

            // else is it a queen ?

            else if (boardslot->part == PART_QUEEN)

            {

               // see how far queen can move NE

               for (pos_index = 1; pos_index < 8; pos_index++)

               {

                  if ((line + pos_index > 7) || (column + pos_index > 7))

                     break;

                  if (currentmove->slots[line + pos_index][column + pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line + pos_index][column + pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line + pos_index][column + pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line + pos_index][column + pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far queen can move SE

               for (pos_index = 1; pos_index < 8; pos_index++)

               {

                  if ((line - pos_index < 0) || (column + pos_index > 7))

                     break;

                  if (currentmove->slots[line - pos_index][column + pos_index].part != PART_NONE)

                  {

                     if (currentmove->slots[line - pos_index][column + pos_index].color != currentmove->slots[line][column].color)

                        currentmove->slots[line - pos_index][column + pos_index].flags |= FLAG_TAKEABLE;

                     break;

                  }

                  currentmove->slots[line - pos_index][column + pos_index].flags |= FLAG_POSSIBLEMOVE;

               }

               // see how far queen can move NW

               for (pos_index = 1; pos_index < 8; pos_index++)

               {