home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / new / game / think / chaos / src / players.c < prev    next >
C/C++ Source or Header  |  1994-10-14  |  14KB  |  593 lines
  1. /*  Chaos:            The Chess HAppening Organisation System    V5.3
  2.     Copyright (C)   1993    Jochen Wiedmann
  3.  
  4.     This program is free software; you can redistribute it and/or modify
  5.     it under the terms of the GNU General Public License as published by
  6.     the Free Software Foundation; either version 2 of the License, or
  7.     (at your option) any later version.
  8.  
  9.     This program is distributed in the hope that it will be useful,
  10.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.     GNU General Public License for more details.
  13.  
  14.     You should have received a copy of the GNU General Public License
  15.     along with this program; if not, write to the Free Software
  16.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18.  
  19.     $RCSfile: Players.c,v $
  20.     $Revision: 3.2 $
  21.     $Date: 1994/10/14 09:44:02 $
  22.  
  23.     This file contains the functions of the Players-menu.
  24.  
  25.     Computer:    Amiga 1200            Compiler:    Dice 2.07.54 (3.0)
  26.  
  27.     Author:    Jochen Wiedmann
  28.         Am Eisteich 9
  29.       72555 Metzingen
  30.         Phone: 07123 / 14881
  31.         Internet: wiedmann@mailserv.zdv.uni-tuebingen.de
  32. */
  33.  
  34.  
  35. #ifndef CHAOS_H
  36. #include "chaos.h"
  37. #endif
  38. #include <time.h>
  39.  
  40.  
  41.  
  42.  
  43. /*
  44.     InsertPlayer inserts a player into the alphabetically sorted list of
  45.     players.
  46.  
  47.     Inputs: plrlist - pointer to the list, where the player should be
  48.               inserted
  49.         tn        - pointer to the Player structure of the new player
  50. */
  51. static void InsertPlayer (struct List *plrlist, struct Player *tn)
  52.  
  53. { struct Player *node;
  54.  
  55.   for (node = (struct Player *) PlayerList.lh_Head;
  56.        node->Tn_Node.ln_Succ != NULL;
  57.        node = (struct Player *) node->Tn_Node.ln_Succ)
  58.   { if (Stricmp((STRPTR) tn->Name, (STRPTR) node->Name) < 0)
  59.     { break;
  60.     }
  61.   }
  62.   Insert(&PlayerList, (struct Node *) tn, node->Tn_Node.ln_Pred);
  63. }
  64.  
  65.  
  66.  
  67.  
  68. /*
  69.     This function removes preceding blanks from a string.
  70.  
  71.     Inputs: str     - a pointer to the string, where the blanks should
  72.               be removed
  73.  
  74.     Result: a pointer to the first nonblank character in str (may be \0!)
  75. */
  76. static char *WithoutBlanks(char *str)
  77.  
  78. { if (str != NULL)
  79.   { while (*str == ' ')
  80.     { ++str;
  81.     }
  82.   }
  83.   return(str);
  84. }
  85.  
  86.  
  87.  
  88.  
  89. /*
  90.     CheckPlayerValid() checks, if a players data is valid.
  91.  
  92.     Inputs: plr     - a pointer to the player structure
  93.         user    - TRUE, if an error message may be shown to the user
  94.  
  95.     Result: TRUE, if the player is valid, FALSE otherwise
  96.  
  97.     Note: This functions assumes, that plr is not included in PlayerList!
  98. */
  99. int CheckPlayerValid(struct Player *plr, int user)
  100.  
  101. { struct Player *cmpplr;
  102.   char *birthday = WithoutBlanks(plr->BirthDay);
  103.   char *name = WithoutBlanks(plr->Name);
  104.   struct tm tm;
  105.  
  106.  
  107.   /*
  108.       Check if the players name and birthday are valid
  109.   */
  110.   if (*WithoutBlanks(name) == '\0')
  111.   { if (user)
  112.     { ShowError((char *) GetChaosString(MSG_MISSING_PLAYER_NAME));
  113.     }
  114.     return(FALSE);
  115.   }
  116.   if (*birthday != '\0'  &&  !atotm(birthday, &tm))
  117.   { if (user)
  118.     { ShowError((char *) GetChaosString(MSG_BIRTHDAY_ERROR));
  119.     }
  120.     return(FALSE);
  121.   }
  122.  
  123.  
  124.   /*
  125.       Check, if the players name is unique.
  126.   */
  127.   for (cmpplr = (struct Player *) PlayerList.lh_Head;
  128.        cmpplr->Tn_Node.ln_Succ != NULL;
  129.        cmpplr = (struct Player *) cmpplr->Tn_Node.ln_Succ)
  130.   { if (Stricmp((STRPTR) cmpplr->Name, (STRPTR) name) == 0)
  131.     { if (user)
  132.       { ShowError((char *) GetChaosString(MSG_PlayerExists), plr->Name);
  133.       }
  134.       return(FALSE);
  135.     }
  136.   }
  137.   return(TRUE);
  138. }
  139.  
  140.  
  141.  
  142.  
  143.  
  144. /*
  145.     The AddPlayer() function adds a new player to the list of players.
  146.     It is assumed, that CheckPlayer() and CheckPlayerNameUnique() are
  147.     already called.
  148.  
  149.     Inputs: plr     a pointer to a player structure
  150.  
  151.     Results:    TRUE, if successfull, FALSE otherwise
  152. */
  153. int AddPlayer(struct Player *plr)
  154.  
  155. { struct Player *newplr, **plrptr;
  156.   struct Game *game;
  157.  
  158.   /*
  159.       Allocate memory for the new player
  160.   */
  161.   if ((newplr = GetMem(&TrnMem, sizeof(*newplr)))  ==  NULL)
  162.   { return(FALSE);
  163.   }
  164.  
  165.   /*
  166.       Initialize data
  167.   */
  168.   strcpy(newplr->Name, WithoutBlanks(plr->Name));
  169.   strcpy(newplr->Street, WithoutBlanks(plr->Street));
  170.   strcpy(newplr->Village, WithoutBlanks(plr->Village));
  171.   strcpy(newplr->PhoneNr, WithoutBlanks(plr->PhoneNr));
  172.   strcpy(newplr->ChessClub, WithoutBlanks(plr->ChessClub));
  173.   strcpy(newplr->BirthDay, WithoutBlanks(plr->BirthDay));
  174.   strcpy(newplr->DWZ, WithoutBlanks(plr->DWZ));
  175.   newplr->ELO = plr->ELO;
  176.   newplr->Flags = plr->Flags & (TNFLAGSF_SENIOR|TNFLAGSF_JUNIOR|
  177.                 TNFLAGSF_WOMAN|TNFLAGSF_JUNIORA|
  178.                 TNFLAGSF_JUNIORB|TNFLAGSF_JUNIORC|
  179.                 TNFLAGSF_JUNIORD|TNFLAGSF_JUNIORE);
  180.   newplr->Tn_Node.ln_Name = newplr->Name;
  181.   newplr->Tn_Node.ln_Type = (UBYTE) -1;
  182.   newplr->Tn_Node.ln_Pri = 0;
  183.  
  184.   /*
  185.       The Swiss Pairing allows adding players, until round 1 is finished.
  186.       Possibly we have to select an opponent.
  187.   */
  188.   if(NumRounds > 0)
  189.   { /*
  190.     Allocate a Game structure
  191.     */
  192.     if    ((game = newplr->First_Game = GetMem(&TrnMem, sizeof(*game)))
  193.            ==  NULL)
  194.     { PutMem(newplr);
  195.       return(FALSE);
  196.     }
  197.     game->BoardNr = NumPlayers / 2;
  198.  
  199.     /*
  200.     Add the new player to the bottom of the internal rankings.
  201.     */
  202.     for (plrptr = &RankingFirst; *plrptr != NULL;
  203.      plrptr = &((*plrptr)->RankNext))
  204.     {
  205.     }
  206.     *plrptr = newplr;
  207.  
  208.     /*
  209.     If the number of players was odd, the new players opponent will
  210.     be the player, who had a point for free.
  211.     */
  212.     if ((NumPlayers % 2) != 0)
  213.     { struct Player *opponent;
  214.  
  215.       for (opponent = RankingFirst;
  216.        (opponent->Flags & TNFLAGSF_HADFREE) == 0;
  217.        opponent = opponent->RankNext)
  218.       {
  219.       }
  220.  
  221.       opponent->Flags &= ~TNFLAGSF_HADFREE;
  222.       game->Opponent = opponent;
  223.       game->Result = -1;
  224.       game->Flags = (RangeRand(2) == 0)  ?  GMFLAGSF_WHITE : 0;
  225.       newplr->HowMuchWhite = newplr->HowMuchWhiteLast =
  226.                  game->Flags  ?  1 : -1;
  227.  
  228.       game = opponent->First_Game;
  229.       game->Opponent = newplr;
  230.       game->Result = -1;
  231.       game->BoardNr = newplr->First_Game->BoardNr;
  232.       game->Flags = GMFLAGSF_WHITE-newplr->First_Game->Flags;
  233.       opponent->HowMuchWhite = opponent->HowMuchWhiteLast =
  234.                    game->Flags  ? 1 : -1;
  235.       opponent->Points = 0;
  236.       NumGamesMissing++;
  237.     }
  238.     /*
  239.     The new player gets a point for free, if the number of players
  240.     was even.
  241.     */
  242.     else
  243.     { newplr->Flags |= TNFLAGSF_HADFREE;
  244.       newplr->Points = WinnerPoints;
  245.       game->Result = 2;
  246.       game->Flags = GMFLAGSF_POINTFORFREE|GMFLAGSF_NOFIGHT;
  247.     }
  248.   }
  249.  
  250.   InsertPlayer(&PlayerList, newplr);
  251.   NumPlayers++;
  252.  
  253.   IsSaved = FALSE;
  254.   return(TRUE);
  255. }
  256.  
  257.  
  258.  
  259.  
  260. /*
  261.     The AddPlayers() function allows the user to enter new players.
  262. */
  263. void AddPlayers(void)
  264.  
  265. { struct Player plr;
  266.   int new = TRUE;
  267.  
  268.   /*
  269.       Check, if we may enter new players.
  270.   */
  271.   if (NumRounds >= 1 &&  RoundRobinTournament)
  272.   { ShowError((char *) GetChaosString(MSG_NO_NEW_PLAYERS_ROUND_ROBIN));
  273.     return;
  274.   }
  275.   if (NumRounds > 1  &&  SwissPairingTournament)
  276.   { ShowError((char *) GetChaosString(MSG_NO_NEW_PLAYERS_SWISS_PAIR));
  277.     return;
  278.   }
  279.   if (NumRounds > 0)
  280.   { if (!AskContinue((char *) GetChaosString(MSG_NEW_PLAYER_REQUEST)))
  281.     { return;
  282.     }
  283.   }
  284.  
  285.   if (!InitPlrWnd((char *) GetChaosString(WND_PLAYER_ADD_TITLE)))
  286.   { return;
  287.   }
  288.  
  289.   memset(&plr, 0, sizeof(plr));
  290.   for (;;)
  291.   { if (!ProcessPlrWnd(&plr, new))
  292.     { break;
  293.     }
  294.     new = FALSE;
  295.  
  296.     if (CheckPlayerValid(&plr, TRUE))
  297.     { if (!AddPlayer(&plr))
  298.       { break;
  299.       }
  300.  
  301.       memset(&plr, 0, sizeof(plr));
  302.       new = TRUE;
  303.     }
  304.   }
  305.   TerminatePlrWnd();
  306. }
  307.  
  308.  
  309.  
  310.  
  311.  
  312. /*
  313.     The InportPlayers() function allows to add players from a previous
  314.     tournament.
  315. */
  316. void ImportPlayers(void)
  317.  
  318. { void *PlrMem = NULL;
  319.   struct List ImportPlayerList;
  320.  
  321.   /*
  322.       Check, if we may enter new players.
  323.   */
  324.   if (NumRounds >= 1 &&  RoundRobinTournament)
  325.   { ShowError((char *) GetChaosString(MSG_NO_NEW_PLAYERS_ROUND_ROBIN));
  326.     return;
  327.   }
  328.   if (NumRounds > 1  &&  SwissPairingTournament)
  329.   { ShowError((char *) GetChaosString(MSG_NO_NEW_PLAYERS_SWISS_PAIR));
  330.     return;
  331.   }
  332.   if (NumRounds > 0)
  333.   { if (!AskContinue((char *) GetChaosString(MSG_NEW_PLAYER_REQUEST)))
  334.     { return;
  335.     }
  336.   }
  337.  
  338.   if (LoadTournament(NUL