home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / new / game / think / chaos / src / out.c < prev    next >
C/C++ Source or Header  |  1994-12-03  |  31KB  |  1,241 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: Out.c,v $
  20.     $Revision: 3.4 $
  21.     $Date: 1994/12/03 18:02:26 $
  22.  
  23.     This file contains most of the output-functions.
  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: wiedmann@mailserv.zdv.uni-tuebingen.de
  32. */
  33.  
  34.  
  35. #ifndef CHAOS_H
  36. #include "chaos.h"
  37. #endif
  38.  
  39.  
  40.  
  41.  
  42. /*
  43.     PointsToA() creates a string holding the number of points from p.
  44.  
  45.     Inputs: s - the string where the result should be written
  46.         p - the number of points
  47. */
  48. void PointsToA(char *s, long p)
  49.  
  50. { if (WinnerPoints%2  ||  DrawPoints%2)
  51.   { sprintf(s, "%ld%s", p/2, (p%2)?".5":"  ");
  52.   }
  53.   else
  54.   { sprintf(s, "%ld", p/2);
  55.   }
  56. }
  57.  
  58.  
  59.  
  60.  
  61. /*
  62.     tdwz() returns the DW (German rating number) of a player as short.
  63. */
  64. int tdwz(struct Player *t)
  65.  
  66. { long dwz;
  67.  
  68. #ifdef AMIGA
  69.   if (StrToLong((STRPTR) t->DWZ, &dwz) < 0)
  70.   { dwz = 0;
  71.   }
  72. #else
  73.   dwz = atol(t->DWZ);
  74. #endif
  75.   return ((short) dwz);
  76. }
  77.  
  78.  
  79.  
  80.  
  81. /*
  82.     RatingToA() gets a string from a DWZ or ELO number.
  83.  
  84.     Inputs: s - the string, that should be written
  85.         w - the rating number (Note, that this must not be the
  86.         Player->DWZ field itself, because this is a string!)
  87. */
  88. static void RatingToA(char *s, int w)
  89.  
  90. { if(w == 0)
  91.   { *s = '\0';
  92.   }
  93.   else
  94.   { sprintf(s, "%d", w);
  95.   }
  96. }
  97.  
  98.  
  99.  
  100.  
  101. /*
  102.     lprint() is used to buffer the output which will be done later with
  103.     ProcessOutput(). It can work in two modes: The first is building a list
  104.     of lines, the second is collecting ALL lines in a single string.
  105.     The latter is needed on the Amiga for using a FloatText gadget while the
  106.     list is needed for output on the printer.
  107.  
  108.     Inputs: line - the string holding the line
  109.  
  110.     Result: TRUE, if successfull, FALSE otherwise
  111. */
  112. int lprint(char *line)
  113.  
  114. { extern struct MinList OutputList;
  115.   extern void *OutputMemList;
  116.   extern int OutputLineLen, OutputLineMaxLen;
  117.   extern char*OutputLine;
  118.   extern int OutputReturnCode;
  119.   struct MinNode *n;
  120.   char *ptr;
  121.   int i, len;
  122.  
  123.   /*
  124.       Get length of string, ignore trailing blanks.
  125.   */
  126.   for (i = 1, len = 0, ptr = line;  *ptr != '\0';  ptr++, i++)
  127.   { if (*ptr != ' ')
  128.     { len = i;
  129.     }
  130.   }
  131.  
  132.   if (OutputLineMaxLen == -1)
  133.   { if ((n = GetMem(&OutputMemList, sizeof(*n)+len+1))  ==  NULL)
  134.     { OutputReturnCode = RETURN_ERROR;
  135.       return(FALSE);
  136.     }
  137.  
  138.     strncpy((char *) (n+1), line, len);
  139.     ((char *) (n+1))[len] = '\0';
  140.     AddTail((struct List *) &OutputList, (struct Node *) n);
  141.   }
  142.   else
  143.   { while (OutputLineLen + len + 2  >  OutputLineMaxLen)
  144.     { if ((ptr = GetMem(&OutputMemList, OutputLineMaxLen += 16384))  ==  NULL)
  145.       { OutputReturnCode = RETURN_ERROR;
  146.     return(FALSE);
  147.       }
  148.       if (OutputLine != NULL)
  149.       { strcpy(ptr, OutputLine);
  150.     PutMem(OutputLine);
  151.       }
  152.       OutputLine = ptr;
  153.     }
  154.  
  155.     strncpy(OutputLine+OutputLineLen, line, len);
  156.     OutputLine[OutputLineLen += len] = '\n';
  157.     OutputLine[++OutputLineLen] = '\0';
  158.   }
  159.   return(TRUE);
  160. }
  161.  
  162.  
  163.  
  164.  
  165. /*
  166.     longlprint() does the same job as lprint(), but can process text with
  167.     more than one line. The lines are split and lprint is called for each
  168.     line.
  169.  
  170.     Inputs: txt - the string holding the text; note, that a single line must
  171.           not extend 512 characters!
  172.  
  173.     Result: TRUE, if successfull, FALSE otherwise
  174. */
  175. int longlprint(char *txt)
  176.  
  177. { char line[512];
  178.   char *lptr;
  179.   char c;
  180.  
  181.   while (*txt != '\0')
  182.   { lptr = line;
  183.     while ((c = *txt) != '\0'  &&  c != '\n')
  184.     { *(lptr++) = *(txt++);
  185.     }
  186.     *lptr = '\0';
  187.     if (!lprint(line))
  188.     { return(FALSE);
  189.     }
  190.     if (c == '\n')
  191.     { txt++;
  192.     }
  193.   }
  194.   return(TRUE);
  195. }
  196.  
  197.  
  198.  
  199.  
  200. /*
  201.     This function prints the list of players.
  202.  
  203.     Inputs: filename    - destination file; see InitOutput()
  204.         device    - device; see InitOutput()
  205.         longformat    - TRUE, if long format, FALSE otherwise
  206. */
  207. void OutPlayerList(char *filename, int device, int longformat)
  208.  
  209. { struct Player *t;
  210.   int i, lines;
  211.   char head[301];
  212.   char line1[121], line2[121], line3[121];
  213.   char dwz[6], elo[6];
  214.  
  215.   if (longformat == FALSE)
  216.   { lines = 1;
  217.     sprintf(head, "%-4s %-30s %6s %6s %s",
  218.         GetChaosString(MSG_NUMBER),
  219.         GetChaosString(MSG_NAME_OUTPUT),
  220.         GetChaosString(MSG_DWZ_OUTPUT),
  221.         GetChaosString(MSG_ELO_OUTPUT),
  222.         GetChaosString(MSG_CHESSCLUB_OUTPUT));
  223.   }
  224.   else
  225.   { lines = 4;
  226.     sprintf(head, "%-4s %-30s %-30s %s\n"
  227.           "     %-30s %-30s %s\n"
  228.           "     %-15s %s%s%s %s%s%s%s%s      %s\n",
  229.         GetChaosString(MSG_NUMBER),
  230.         GetChaosString(MSG_NAME_OUTPUT),
  231.         GetChaosString(MSG_STREET_OUTPUT),
  232.         GetChaosString(MSG_DWZ_OUTPUT),
  233.  
  234.         GetChaosString(MSG_CHESSCLUB_OUTPUT),
  235.         GetChaosString(MSG_VILLAGE_OUTPUT),
  236.         GetChaosString(MSG_ELO_OUTPUT),
  237.  
  238.         GetChaosString(MSG_BIRTHDAY_OUTPUT),
  239.         GetChaosString(MSG_SENIOR_SHORT),
  240.         GetChaosString(MSG_JUNIOR_SHORT),
  241.         GetChaosString(MSG_WOMAN_SHORT),
  242.         GetChaosString(MSG_JUNIORA_SHORT),
  243.         GetChaosString(MSG_JUNIORB_SHORT),
  244.         GetChaosString(MSG_JUNIORC_SHORT),
  245.         GetChaosString(MSG_JUNIORD_SHORT),
  246.         GetChaosString(MSG_JUNIORE_SHORT),
  247.         GetChaosString(MSG_PHONE_OUTPUT));
  248.   }
  249.   if (!InitOutput((char *) GetChaosString(MSG_PLAYER_LIST_TITLE),
  250.           head, head, filename, "#?.plst", device, lines, lines))
  251.   { TerminateOutput();
  252.     return;
  253.   }
  254.  
  255.   for (t = (struct Player *) PlayerList.lh_Head, i = 1;
  256.        t->Tn_Node.ln_Succ != NULL;
  257.        t = (struct Player *) t->Tn_Node.ln_Succ, i++)
  258.   { RatingToA(dwz, tdwz(t));
  259.     RatingToA(elo, (int) t->ELO);
  260.  
  261.     if (!longformat)
  262.     { sprintf(line1, "%-4d %-30s %6s %6s %-30s", i, t->Name, dwz, elo,
  263.           t->ChessClub);
  264.       if (!lprint(line1))
  265.       { TerminateOutput();
  266.     return;
  267.       }
  268.     }
  269.     else
  270.     { sprintf(line1, "%-4d %-30s %-30s %s", i, t->Name, t->Street, dwz);
  271.       sprintf(line2, "     %-30s %-30s %s", t->ChessClub, t->Village, elo);
  272.       sprintf(line3, "     %-15s %s%s%s %s%s%s%s%s      %s",
  273.           t->BirthDay,
  274.           (t->Flags & TNFLAGSF_SENIOR)   ?
  275.             (char *) GetChaosString(MSG_SENIOR_SHORT)  : " ",
  276.           (t->Flags & TNFLAGSF_JUNIOR)   ?
  277.             (char *) GetChaosString(MSG_JUNIOR_SHORT)  : " ",
  278.           (t->Flags & TNFLAGSF_WOMAN)     ?
  279.             (char *) GetChaosString(MSG_WOMAN_SHORT)   : " ",
  280.           (t->Flags & TNFLAGSF_JUNIORA)  ?
  281.             (char *) GetChaosString(MSG_JUNIORA_SHORT) : " ",
  282.           (t->Flags & TNFLAGSF_JUNIORB)  ?
  283.             (char *) GetChaosString(MSG_JUNIORB_SHORT) : " ",
  284.           (t->Flags & TNFLAGSF_JUNIORC)  ?
  285.             (char *) GetChaosString(MSG_JUNIORC_SHORT) : " ",
  286.           (t->Flags & TNFLAGSF_JUNIORD)  ?
  287.             (char *) GetChaosString(MSG_JUNIORD_SHORT) : " ",
  288.           (t->Flags & TNFLAGSF_JUNIORE)  ?
  289.             (char *) GetChaosString(MSG_JUNIORE_SHORT) : " ",
  290.           t->PhoneNr);
  291.  
  292.       if (!lprint(line1)  ||  !lprint(line2)  ||
  293.       !lprint(line3)  ||  !lprint(""))
  294.       { TerminateOutput();
  295.     return;
  296.       }
  297.     }
  298.   }
  299.  
  300.   ProcessOutput();
  301.   TerminateOutput();
  302. }
  303.  
  304.  
  305.  
  306.  
  307. /*
  308.     This function prints the results of one round.
  309.  
  310.     Inputs: filename    - destination file; see InitOutput()
  311.         device    - output device; see InitOutput()
  312.         Round    - number of the round, that should be printed
  313. */
  314. void OutRound(char *filename, int device, int Round)
  315.  
  316. { void *memlist;
  317.   struct MinList *rlist;
  318.   struct GameNode *gn;
  319.   char head[81];
  320.   char title[81];
  321.  
  322.   if ((rlist = GetRound(&memlist, Round, TRUE,
  323.             (device == DEVICE_Screen) ? 0 : 1))
  324.          ==  NULL)
  325.   { return;
  326.   }
  327.  
  328.   sprintf(head, "%4s %-30s:%-30s %s"