home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #3 / amigamamagazinepolishissue1998.iso / szachy / chaos / src / rounds.c < prev    next >
C/C++ Source or Header  |  1995-06-05  |  8KB  |  335 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: Rounds.c,v $
  20.     $Revision: 3.2 $
  21.     $Date: 1994/10/14 09:44:02 $
  22.  
  23.     This file contains the functions to enter results.
  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.                 Tel. 07123 / 14881
  31.                 Internet: jochen.wiedmann@zdv.uni-tuebingen.de
  32. */
  33.  
  34.  
  35. #ifndef CHAOS_H
  36. #include "chaos.h"
  37. #endif
  38.  
  39.  
  40.  
  41.  
  42. /*
  43.     The function FormatGame() initializes the Text field of a GameNode
  44.     structure due to the contents of the other fields.
  45.  
  46.     Inputs: gn           -  the GameNode structure, which's Text fiels
  47.             format       -  0 = full game, short notion
  48.                             1 = full game, long notion
  49.                             2 = result only
  50. */
  51. static char *ResultLongPoints(int result)
  52.  
  53. { static char buffer[20];
  54.  
  55.   if ((result%2) == 0)
  56.   { sprintf(buffer, " %-2d", result/2);
  57.   }
  58.   else if (result == 1)
  59.   { sprintf(buffer, "1/2");
  60.   }
  61.   else
  62.   { sprintf(buffer, "%d.5", result/2);
  63.   }
  64.   return(buffer);
  65. }
  66. static char *ResultLong(int result)
  67.  
  68. { static char buffer[40];
  69.  
  70.   switch(result)
  71.   { case -1:
  72.       return(" _ : _ ");
  73.     case 0:
  74.       sprintf(buffer, " 0 :%s", ResultLongPoints(WinnerPoints));
  75.       break;
  76.     case 1:
  77.       strcpy(buffer, ResultLongPoints(DrawPoints));
  78.       sprintf(buffer+strlen(buffer), ":%s", ResultLongPoints(DrawPoints));
  79.       break;
  80.     case 2:
  81.       sprintf(buffer, "%s: 0 ", ResultLongPoints(WinnerPoints));
  82.       break;
  83.   }
  84.   return(buffer);
  85. }
  86.  
  87. void FormatGame(struct GameNode *gn, int format)
  88.  
  89. { static char *ResultShort[4] =
  90.   { "_:_", "0:1", "½:½", "1:0"
  91.   };
  92.  
  93.   if (gn->Flags & GMFLAGSF_POINTFORFREE)
  94.   { sprintf(gn->Text, "     %s: %s",
  95.             (TrnMode & TNMODEF_SWISS_PAIRING) ?
  96.                         MSG_FREE_POINT_OUTPUT :
  97.                         MSG_FREE_GAME_OUTPUT2,
  98.             gn->White->Name);
  99.   }
  100.   else
  101.   { if (format != 2)
  102.     { sprintf(gn->Text, "%4d %-30s:%-30s %s %s", gn->BoardNr+1,
  103.               gn->White->Name, gn->Black->Name,
  104.               format  ?  ResultLong(gn->Result) :
  105.                          ResultShort[gn->Result+1],
  106.               (gn->Flags & GMFLAGSF_NOFIGHT) ?
  107.                       (char *) MSG_NO_FIGHT_OUTPUT : "    ");
  108.     }
  109.     else
  110.     { sprintf(gn->Text, "%d", gn->BoardNr+1);
  111.       sprintf(gn->Text+strlen(gn->Text)+1, "%s %s",
  112.               ResultShort[gn->Result+1],
  113.               (gn->Flags & GMFLAGSF_NOFIGHT) ?
  114.                 (char *) MSG_NO_FIGHT_OUTPUT : "");
  115.     }
  116.   }
  117. }
  118.  
  119.  
  120.  
  121.  
  122. /*
  123.     GetRound builds a list of the games of one round.
  124.  
  125.     Inputs: memlist   - argument for GetMem
  126.             Round     - number of the round
  127.             freegames - TRUE, if free games should be included
  128.             format    - argument for FormatGame()
  129.  
  130.     Result: pointer to a list of games if successfull or NULL otherwise.
  131.             Note, that the calling function should execute PutMemList()
  132.             in either case.
  133. */
  134. struct MinList *GetRound(void **memlist, int Round, int freegames, int format)
  135.  
  136. { struct MinList *rlist;
  137.   struct GameNode *gn, *gnhelp;
  138.   struct Player *t;
  139.   struct Game *g;
  140.  
  141.   *memlist = NULL;
  142.   if ((rlist = GetMem(memlist, sizeof(*rlist)))  ==  NULL)
  143.   { return(NULL);
  144.   }
  145.   NewList((struct List *) rlist);
  146.  
  147.   for (t = (struct Player *) PlayerList.lh_Head;
  148.        t->Tn_Node.ln_Succ != NULL;
  149.        t = (struct Player *) t->Tn_Node.ln_Succ)
  150.   { t->Helpptr = NULL;
  151.   }
  152.   for (t = (struct Player *) PlayerList.lh_Head;
  153.        t->Tn_Node.ln_Succ != NULL;
  154.        t = (struct Player *) t->Tn_Node.ln_Succ)
  155.   { if (t->Helpptr == NULL)
  156.     { g = GameAddress(t, Round);
  157.       if ((g->Flags & GMFLAGSF_POINTFORFREE) != 0)
  158.       { if (!freegames  ||
  159.             ((TrnMode & TNMODEF_SWISS_PAIRING)  &&  g->Result == 0))
  160.         { continue;
  161.         }
  162.       }
  163.       else if ((g->Flags & GMFLAGSF_WHITE)  ==  0)
  164.       { continue;
  165.       }
  166.  
  167.       if ((gn = GetMem(memlist,sizeof(*gn)))  ==  NULL)
  168.       { return(NULL);
  169.       }
  170.       g = GameAddress(t, Round);
  171.       gn->White = t;
  172.       gn->Black = g->Opponent;
  173.       gn->Result = g->Result;
  174.       gn->BoardNr = (g->Flags & GMFLAGSF_POINTFORFREE) ? 0x7fff : g->BoardNr;
  175.       gn->Flags = g->Flags;
  176.  
  177.       t->Helpptr = t;
  178.       if (g->Opponent != NULL)
  179.       { g->Opponent->Helpptr = t;
  180.       }
  181.  
  182.       for (gnhelp = (struct GameNode *) rlist->mlh_Head;
  183.            gnhelp->gn_Node.mln_Succ != NULL;
  184.            gnhelp = (struct GameNode *) gnhelp->gn_Node.mln_Succ)
  185.       { if (gn->BoardNr < gnhelp->BoardNr)
  186.         { break;
  187.         }
  188.       }
  189.     Insert((struct List *) rlist, (struct Node *) gn,
  190.            (struct Node *) gnhelp->gn_Node.mln_Pred);
  191.     FormatGame(gn, format);
  192.     }
  193.   }
  194.   return (rlist);
  195. }
  196.  
  197.  
  198.  
  199.  
  200. /*
  201.     EnterResult modifies one game's result
  202.  
  203.     Inputs: gn    - pointer to a struct GameNode
  204.             Round - number of the round, in which the game was played
  205. */
  206. void EnterResult(struct GameNode *gn, int Round)
  207.  
  208. { struct Player *t;
  209.   struct Game *g;
  210.  
  211.   t = gn->White;
  212.   g = GameAddress(t, Round);
  213.   if (g->Result != gn->Result  ||  g->Flags != gn->Flags)
  214.   { IsSaved = FALSE;
  215.   }
  216.   if (gn->Result == -1  &&  g->Result != -1)
  217.   { NumGamesMissing++;
  218.   }
  219.   else if (gn->Result != -1  &&  g->Result == -1)
  220.   { NumGamesMissing--;
  221.   }
  222.  
  223.   switch(g->Result)
  224.   { case -1:
  225.     case 0:
  226.       break;
  227.     case 1:
  228.       t->Points -= DrawPoints;
  229.       break;
  230.     case 2:
  231.       t->Points -= WinnerPoints;
  232.       break;
  233.   }
  234.   switch(gn->Result)
  235.   { case -1:
  236.     case 0:
  237.       break;
  238.     case 1:
  239.       t->Points += DrawPoints;
  240.       break;
  241.     case 2:
  242.       t->Points += WinnerPoints;
  243.       break;
  244.   }
  245.   g->Result = gn->Result;
  246.   g->Flags = gn->Flags;
  247.  
  248.   if((t = gn->Black) != NULL)
  249.   { g = GameAddress(t, Round);
  250.     switch(g->Result)
  251.     { case -1:
  252.       case 0:
  253.         break;
  254.       case 1:
  255.         t->Points -= DrawPoints;
  256.         break;
  257.       case 2:
  258.         t->Points -= WinnerPoints;
  259.         break;
  260.     }
  261.     switch(gn->Result)
  262.     { case -1:
  263.         g->Result = -1;
  264.         break;
  265.       case 2:
  266.         g->Result = 0;
  267.         break;
  268.       case 1:
  269.         g->Result = 1;
  270.         t->Points += DrawPoints;
  271.         break;
  272.       case 0:
  273.         g->Result = 2;
  274.         t->Points += WinnerPoints;
  275.         break;
  276.     }
  277.     g->Flags = gn->Flags & ~GMFLAGSF_WHITE;
  278.   }
  279. }
  280.  
  281.  
  282.  
  283.  
  284. /*
  285.     EnterResults() is called, if the user wants to enter results. (Surprise!)
  286.  
  287.     Inputs: Round - number of the round
  288. */
  289. void EnterResults(int Round)
  290.  
  291. { struct MinList *rlist;
  292.   struct GameNode *gn;
  293.   void *memlist = NULL;
  294.   char title[80];
  295.  
  296.   /*
  297.       Get the list of games
  298.   */
  299. #ifdef AMIGA
  300.   if ((rlist = GetRound(&memlist, Round, FALSE, 2))  ==  NULL)
  301. #else   /*  !AMIGA  */
  302.   if ((rlist = GetRound(&memlist, Round, FALSE, 0))  ==  NULL)
  303. #endif  /*  !AMIGA  */
  304.   { return;
  305.   }
  306.  
  307.   /*
  308.       Initialize the window
  309.   */
  310.   sprintf(title, (char *) MSG_ROUND_INPUT_TITLE, Round);
  311.   InitRsltWnd(title, rlist);
  312.  
  313.   for (;;)
  314.   { switch(ProcessRsltWnd(rlist))
  315.     { case 0:
  316.         PutMemList(&memlist);
  317.         TerminateRsltWnd();
  318.         return;
  319.       case -1:
  320.         TerminateRsltWnd();
  321.         /*
  322.             Process the changes
  323.         */
  324.         for(gn = (struct GameNode *) rlist->mlh_Head;
  325.             gn->gn_Node.mln_Succ != NULL;
  326.             gn = (struct GameNode *) gn->gn_Node.mln_Succ)
  327.         { EnterResult(gn, Round);
  328.         }
  329.         PutMemList(&memlist);
  330.  
  331.         return;
  332.     }
  333.   }
  334. }
  335.