home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / TURBOPAS / TURBO.ZIP / SPELTEST.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1984-09-21  |  9.8 KB  |  298 lines
  1. PROGRAM SPELLTST;
  2. CONST
  3.  MAX_WORDS = 50;                               {MAX WORDS ALLOWED IN THE LIST}
  4.  MAX_CHARS = 14;                          {MAX NUMBER OF CHARACTERS IN A WORD}
  5. TYPE
  6.  WORDS = STRING[MAX_CHARS];
  7.  STR14 = STRING[MAX_CHARS];
  8. VAR
  9.  WORDFILE: FILE OF WORDS;
  10.  FILENAME: STRING[14];
  11.  WORD_LIST: ARRAY[1..MAX_WORDS] OF WORDS;      {SPELLING WORD ARRAY}
  12.  TEMP_LIST: ARRAY[1..MAX_WORDS] OF WORDS;      {TEMP SPELLING WORD ARRAY}
  13.  NUMBER_OF_TRIES,                              {HOW MANY TRIES ON THE LIST }
  14.  BOTTOM_LIST,                                  {BOTTOM OF LIST MARKER}
  15.  TOTAL_IN_LIST,                                {TOTAL NUMBER OF WORDS IN LIST}
  16.  DELAY_TIME,                                   {DELAY TIMER}
  17.  RANDOM_WORD,
  18.  DISPLAY_TIME: INTEGER;                      {HOW LONG TO DISPLAY WORD ON CRT}
  19.  CORRECT: BOOLEAN;                             {ANSWER CORRECT FLAG}
  20.  SCORE,                                        {NUMBER OF CORRECT SPELLINGS}
  21.  I : INTEGER;                                  {GENERAL PURPOSE COUNTER}
  22.  SPELLING_WORD,                                {ANSWER TO A SPELLING WORD}
  23.  NAME: STR14;                                  {STUDENTS NAME}
  24.  ANSWER: CHAR;
  25.  
  26.  FUNCTION LOWCASE(LETTER: CHAR): CHAR;
  27.   BEGIN
  28.    IF (ORD(LETTER) >= 65) AND (ORD(LETTER) <= 90)
  29.     THEN LOWCASE := CHR(ORD(LETTER) + 32)
  30.     ELSE
  31.      LOWCASE := LETTER;
  32.   END; {FUNCTION LOWCASE}
  33.  
  34.  FUNCTION FIX_NAME(NAME: STR14): STR14;
  35.   VAR
  36.    I: INTEGER;
  37.   BEGIN
  38.    NAME[1] := UPCASE(NAME[1]);
  39.    FOR I := 2 TO LENGTH(NAME) DO
  40.        NAME[I] := LOWCASE(NAME[I]);
  41.    FIX_NAME := NAME;
  42.   END;
  43.  
  44. PROCEDURE DISPLAY_OPTIONS;
  45.  VAR
  46.   I,
  47.   LINE,
  48.   COL,
  49.   NUM: INTEGER;
  50.  
  51.  PROCEDURE ADD_NEW_LIST;
  52.   BEGIN
  53.    CLRSCR;
  54.    GOTOXY(5,12);
  55.    WRITE('Enter name of file to store new list of spelling words, ');
  56.    GOTOXY(23,14);
  57.    WRITE('Ex. B:WORDS1    :? ');
  58.    READLN(FILENAME);
  59.    ASSIGN(WORDFILE,FILENAME);
  60.    REWRITE(WORDFILE);
  61.    CLRSCR;
  62.    GOTOXY(5,1);
  63.    WRITELN('Enter each word, one at a time when you see a "?".');
  64.    WRITELN('Enter "endlist" when all the spelling words are entered.');
  65.    NUM := 1;
  66.    LINE := 4;
  67.    COL := 10;
  68.    REPEAT
  69.     GOTOXY(COL,LINE);
  70.     WRITE('WORD #',NUM:2,' ?');
  71.     READ(SPELLING_WORD);
  72.     IF (FIX_NAME(SPELLING_WORD) <> 'Endlist')
  73.      THEN BEGIN
  74.       WORD_LIST[NUM] := SPELLING_WORD;
  75.       NUM := NUM + 1;
  76.       LINE := LINE + 1;
  77.       IF LINE = 25 THEN
  78.        BEGIN
  79.         LINE := 4;
  80.         COL := COL + 20
  81.        END
  82.      END;
  83.    UNTIL FIX_NAME(SPELLING_WORD) = 'Endlist';
  84.    TOTAL_IN_LIST := NUM - 1;
  85.    FOR I := 1 TO TOTAL_IN_LIST DO
  86.     WRITE(WORDFILE,WORD_LIST[I]);
  87.    CLOSE(WORDFILE);
  88.   END; {PROCEDURE ADD_NEW_LIST}
  89.  
  90.  PROCEDURE GET_OLD_LIST(FILENAME: STR14);
  91.   VAR
  92.    I: INTEGER;
  93.   BEGIN
  94.    CLRSCR;
  95.    ASSIGN(WORDFILE,FILENAME);
  96.    RESET(WORDFILE);
  97.    CLRSCR;
  98.    I := 1;
  99.    WHILE NOT(EOF(WORDFILE)) DO
  100.     BEGIN
  101.      READ(WORDFILE,SPELLING_WORD);
  102.      WORD_LIST[I] := SPELLING_WORD;
  103.      I := I + 1;
  104.     END;
  105.    TOTAL_IN_LIST := I - 1;
  106.    CLOSE(WORDFILE);
  107.   END; {PROCEDURE GET_OLD_LIST}
  108.  
  109.  BEGIN (* PROCEDURE DISPLAY_OPTIONS *)
  110.   DELAY_TIME := 3000;
  111.   CLRSCR;
  112.   GOTOXY(28,1);
  113.   WRITE('*****************');
  114.   GOTOXY(28,2);
  115.   WRITE('* SPELLING TEST *');
  116.   GOTOXY(28,3);
  117.   WRITE('*****************');
  118.   GOTOXY(10,5);
  119.   WRITELN('This program will display a word in the middle of the screen for a');
  120.   WRITELN('    short time, then will disappear. You are to then type in the correct');
  121.   WRITELN('    spelling of the word. If you get a word wrong, you will be told and ');
  122.   WRITELN('    that you were wrong and you will be asked to spell in again later.');
  123.   WRITELN('    When you have correctly spelled all the words, the amount of time the');
  124.   WRITELN('    word is to be displayed will be shortened and you will go through the');
  125.   WRITELN('    list again. This will be repeated until you have when through the list');
  126.   WRITELN('    the number of times you selected (1, 2, or 3 times).   GOOD LUCK !!');
  127.   GOTOXY(27,18);
  128.   WRITE('What is your name ? ',^G^G);
  129.   READLN(NAME);
  130.   NAME := FIX_NAME(NAME);
  131.   NUMBER_OF_TRIES := 0;
  132.   WHILE (NUMBER_OF_TRIES < 1) OR (NUMBER_OF_TRIES > 3) DO
  133.    BEGIN
  134.     GOTOXY(10,20);
  135.     WRITELN('How many times do you wish to practice the list (1, 2, or 3)?');
  136.     READ(KBD,ANSWER);
  137.     CASE ANSWER OF
  138.      '1': NUMBER_OF_TRIES := 1;
  139.      '2': NUMBER_OF_TRIES := 2;
  140.      '3': NUMBER_OF_TRIES := 3;
  141.      ELSE
  142.       BEGIN
  143.        GOTOXY(1,20);
  144.        CLREOL;
  145.        WRITE(^G^G^G,'ANSWER 1, 2, OR 3 ONLY!!!');
  146.        DELAY(DELAY_TIME - 1000);
  147.        GOTOXY(1,20);
  148.        CLREOL
  149.       END
  150.     END { CASE }
  151.    END;
  152.   GOTOXY(25,24);
  153.   WRITE('It''s nice to meet you, ',NAME,'.');
  154.   DELAY(DELAY_TIME);
  155.   CLRSCR;
  156.   GOTOXY(1,12);
  157.   WRITELN('Enter name of file containing list of spelling words.');
  158.   WRITELN;
  159.   WRITELN(' NOTE: ANSWER "ADD" FOR THE FILENAME IF YOU WANT TO CREAT A NEW');
  160.   WRITELN('       FILE OF SPELLING WORDS');
  161.   WRITELN;
  162.   WRITE('File name (Ex B:WORDS1): ');
  163.   READLN(FILENAME);
  164.   IF FIX_NAME(FILENAME) = 'Add' THEN ADD_NEW_LIST ELSE GET_OLD_LIST(FILENAME);
  165.   CLRSCR;
  166.   GOTOXY(14,12);
  167.   REPEAT
  168.    WRITE(NAME,', are you ready to begin the first round (Y/N)?');
  169.    READ(KBD,ANSWER);
  170.    IF UPCASE(ANSWER) <> 'Y' THEN
  171.     BEGIN
  172.      CLRSCR;
  173.      GOTOXY(22,12);
  174.      WRITE(^G^G)
  175.     END
  176.   UNTIL UPCASE(ANSWER) = 'Y';
  177.   GOTOXY(29,24);
  178.   WRITE('Very good, here we go!');
  179.   DELAY(DELAY_TIME - 1000);
  180. END; {PROCEDURE DISPLAY_OPTIONS}
  181.  
  182. PROCEDURE SPELLING_TEST;
  183.  VAR
  184.   CORRECT_COUNT,            { NUMBER OF CORRECT TRIES IN A ROW }
  185.   AVERAGE_LENGTH,           { AVERAGE LENGTH OF ALL WORDS IN THE LIST }
  186.   WORD_LENGTH,              { TOTAL LENGTH OF ALL WORDS }
  187.   I,
  188.   TRY: INTEGER;             { TELLS WHICH TRY OR CYCLE THE STUDENT IS IN }
  189.  
  190.  BEGIN  { PROCEDURE SPELLING_TEST }
  191.   TRY := 1;
  192.   WORD_LENGTH := 0;
  193.   REPEAT  { start spelling test }
  194.    SCORE := 0;
  195.    BOTTOM_LIST := TOTAL_IN_LIST;
  196.    FOR I := 1 TO TOTAL_IN_LIST DO
  197.     BEGIN  { copy word list into a temporary list and count number of char }
  198.      TEMP_LIST[I] := WORD_LIST[I];
  199.      WORD_LENGTH := WORD_LENGTH + LENGTH(TEMP_LIST[I])
  200.     END;
  201.    IF TRY = 1 THEN
  202.     BEGIN  { compute initial display time based on word size and # of tries}
  203.      AVERAGE_LENGTH := TRUNC(WORD_LENGTH/BOTTOM_LIST) + 1;
  204.      DISPLAY_TIME := (AVERAGE_LENGTH * 500) - (500 * (3 - NUMBER_OF_TRIES))
  205.     END;
  206.    REPEAT   {start going through the spelling list}
  207.     DELAY(DELAY_TIME);
  208.     CLRSCR;
  209.     RANDOM_WORD := RANDOM(BOTTOM_LIST) + 1; { PICK A WORD FROM THE LIST}
  210.     GOTOXY(37,12);
  211.     WRITE(TEMP_LIST[RANDOM_WORD]);          { DISPLAY ON SCREEN }
  212.     DELAY(DISPLAY_TIME);                   { LEAVE ON SCREEN FOR DISPLAY_TIME}
  213.     GOTOXY(37,12);
  214.     CLREOL;                                { ERASE THE WORD }
  215.     GOTOXY(28,24);
  216.     WRITE('What was the word? ');          { ASK STUDENT TO SPELL THE WORD }
  217.     READ(SPELLING_WORD);                   { READ STUDENTS RESPONSE }
  218.     SCORE := SCORE + 1;                    { INCREMENT THE NUMBER OF WORDS }
  219.     GOTOXY(26,24);
  220.     CLREOL;
  221.     IF SPELLING_WORD = TEMP_LIST[RANDOM_WORD]    { IS RESPONSE CORRECT ? }
  222.      THEN        { CORRECT ANSWER !! }
  223.       BEGIN
  224.        CORRECT_COUNT := CORRECT_COUNT + 1;{INCREASE CORRECT COUNT }
  225.        IF CORRECT_COUNT > 5 THEN     { IF 5 IN A ROW RESET COUNT AND }
  226.         BEGIN                        {    DECREASE DISPLAY TIME }
  227.          CORRECT_COUNT := 0;
  228.          DISPLAY_TIME := DISPLAY_TIME - 50;
  229.         END;
  230.          { DELETE CORRECT ANSWER FROM WORD LIST }
  231.        TEMP_LIST[RANDOM_WORD] := TEMP_LIST[BOTTOM_LIST];
  232.        BOTTOM_LIST := BOTTOM_LIST - 1;
  233.          { PRINT A REWARD MESSAGE }
  234.        I := RANDOM(5) + 1;
  235.        CASE I OF
  236.         1: WRITE('     Very good!');
  237.         2: WRITE('  Keep it up, ',NAME);
  238.         3: WRITE('   That''s correct!');
  239.         4: WRITE('   Easy isn''t it?');
  240.         5: WRITE('Another correct answer, ',NAME);
  241.        END;
  242.       END
  243.       ELSE     { ANSWER WAS NOT CORRECT LEAVE IN LIST FOR ANOTHER CHANCE }
  244.        BEGIN         { TELL STUDENT IT WAS WRONG }
  245.         I := RANDOM(5) + 1;
  246.         GOTOXY(23,22);
  247.         CLREOL;
  248.         CASE I OF
  249.          1: WRITE('         WRONG!!');
  250.          2: WRITE('   PAY ATTENTION, ',NAME);
  251.          3: WRITE('   NO THAT''S NOT CORRECT!!');
  252.          4: WRITE('   HAVING A HARD TIME?');
  253.          5: WRITE('THAT IS NOT THE CORRECT WORD, ',NAME);
  254.         END;
  255.         GOTOXY(24,24);
  256.         WRITE('WE WILL TRY THAT ONE AGAIN LATER!');
  257.         CORRECT_COUNT := 0;  { RESET CORRECT COUNT FLAG, INCREASE DISPLAY TIME}
  258.         DISPLAY_TIME := DISPLAY_TIME + 30;
  259.        END;
  260.     UNTIL BOTTOM_LIST = 0;
  261.     CLRSCR;
  262.     GOTOXY(14,8);
  263.     WRITE('You are finished with round ',TRY:1,'.  It took you ',SCORE:2,' tries');
  264.     GOTOXY(14,10);
  265.     WRITE('to spell the ',TOTAL_IN_LIST:2,' words in your spelling list.');
  266.     GOTOXY(18,12);
  267.     DISPLAY_TIME := (DISPLAY_TIME - 500) + 1;
  268.     TRY := TRY + 1;
  269.     IF TRY <= NUMBER_OF_TRIES THEN
  270.      BEGIN
  271.       REPEAT
  272.        WRITE(NAME,', are you ready to begin round ',TRY:1,' (Y/N)?');
  273.        READ(KBD,ANSWER);
  274.        IF UPCASE(ANSWER) <> 'Y' THEN
  275.         BEGIN
  276.          CLRSCR;
  277.          GOTOXY(22,12);
  278.          WRITE(^G^G)
  279.         END
  280.       UNTIL UPCASE(ANSWER) = 'Y';
  281.       GOTOXY(29,24);
  282.       WRITE('Very good, here we go!');
  283.       DELAY(DELAY_TIME - 1000)
  284.      END
  285.     ELSE
  286.      BEGIN
  287.       GOTOXY(1,24);
  288.       WRITE('It was nice helping you with your spelling, ',NAME,', get an "A" on your test!');
  289.       DELAY(DELAY_TIME + 2000)
  290.     END {IF}
  291.    UNTIL TRY > NUMBER_OF_TRIES;
  292. END; {PROCEDURE SPELLING_TEST}
  293.  
  294. BEGIN (* MAIN PROGRAM *)
  295.  RANDOMIZE;
  296.  DISPLAY_OPTIONS;
  297.  SPELLING_TEST;
  298. END. (* MAIN PROGRAM *)