home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1988 / 06_07 / spiel / memory.bas next >
Encoding:
BASIC Source File  |  1988-03-15  |  9.0 KB  |  336 lines
  1. '(* ----------------------------------------------------- *)
  2. '(*                   MEMORY.BAS                          *)
  3. '(*        Ein Spielprogramm in Turbo BASIC 1.0           *)
  4. '(*    (c) 1988 by Gerd Kraus & PASCAL International      *)
  5. '(* ----------------------------------------------------- *)
  6.  
  7. GOTO Main        ' das einzige GOTO, nur fuer den Vergleich
  8.                  ' mit Turbo-Pascal
  9. '(* ----------------------------------------------------- *)
  10. SUB Invers
  11.    COLOR 0, 15
  12. END SUB
  13.  
  14. '(* ----------------------------------------------------- *)
  15. SUB Normal
  16.    COLOR 15, 0
  17. END SUB
  18.  
  19. '(* ----------------------------------------------------- *)
  20. SUB Bell
  21.    SOUND 800,5
  22. END SUB
  23.  
  24. '(* ----------------------------------------------------- *)
  25. SUB HolEingabe (Taste$)
  26.  
  27. LOCAL Dummy$
  28.  
  29. WHILE INSTAT                         ' Tastaturpuffer leeren
  30.   Dummy$ = INKEY$
  31. WEND
  32.  
  33. Taste$ = ""
  34. DO
  35.   Taste$ = INKEY$
  36. LOOP UNTIL Taste$ <> ""
  37.  
  38. IF (ASC (Taste$) = 0) THEN
  39.   IF ASC (MID$(Taste$,2,1)) <> 17 THEN Taste$ = ""
  40. END IF
  41.  
  42. END SUB
  43.  
  44. '(* ----------------------------------------------------- *)
  45. SUB Zeichen (X%, Y%, Anzahl%, Zeichen%)
  46.  
  47. LOCATE X%, Y%
  48. PRINT STRING$ (Anzahl%, CHR$ (Zeichen%));
  49. END SUB
  50.  
  51. '(* ----------------------------------------------------- *)
  52. SUB ZeigKarte (Spalte%, Zeile%, Karte$)
  53.                      ' Spielkarte auf dem Bildschirm zeigen
  54.  
  55. LOCATE 6 + 2 * Zeile%, 16 + 3 * Spalte%
  56.          ' fuer Farb-Monitore  Bildschirm-Farben auswaehlen
  57. PRINT Karte$
  58. END SUB
  59.  
  60. '(* ----------------------------------------------------- *)
  61. SUB Initialisierung
  62.                     ' Zusammenstellen und Mischen der Karten
  63. SHARED  SpielFeld$ (), Punkte% (), Spieler%, Runde%
  64. SHARED  RueckSeite$, LeereKarte$
  65.  
  66. LOCAL   SpielKarte$ (), Farbe% (), Wert$ ()
  67. LOCAL   I%, J%, K%                     ' Schleifen-Variable
  68. LOCAL   ZufallsZahl%                   ' mischen der Karten
  69. LOCAL   Max%                           ' 64 .. 1 Karte
  70.  
  71. DIM  SpielKarte$ (1:64)     ' 32-mal je 2 identische Karten
  72. DIM  Farbe% (1:4)                       ' die Karten-Farben
  73. DIM  Wert$ (1:8)                        ' die Karten-Werte
  74. DIM  SpielFeld$ (1:64)               ' 2 Spielkarten-Saetze
  75. DIM  Punkte% (1:2)
  76.                    ' OPTION BASE 1 waere hier auch moeglich
  77.  
  78. CALL Normal ' bei Farb-Monitor Bildschirm-Farben auswaehlen
  79.  
  80. Farbe% (1) = 3 : Farbe% (2) = 4
  81. Farbe% (3) = 5 : Farbe% (4) = 6
  82.                 ' die Spielkarten-Farben im IBM-Zeichensatz
  83.  
  84. Wert$ (1) = "7" : Wert$ (2) = "8" : Wert$ (3) = "9"
  85. Wert$ (4) = "Z" : Wert$ (5) = "A" : Wert$ (6) = "B"
  86. Wert$ (7) = "D" : Wert$ (8) = "K"
  87.                                           ' die Karten-Werte
  88. Max% = 64
  89.  
  90. I% = 1
  91. FOR J% = 1 TO 8              ' 2 Spielkarten-Saetze aufbauen
  92.   FOR K% =1 TO 4
  93.     SpielKarte$ (I%) = CHR$ (Farbe% (K%)) + Wert$ (J%)
  94.     SpielKarte$ (I% + 32) = SpielKarte$ (I%)
  95.     INCR I%
  96.   NEXT K%
  97. NEXT J%
  98.  
  99. FOR I% = 1 TO 64                        ' Mischen der Karten
  100.   ZufallsZahl% =  INT (RND * Max%) + 1
  101.   SpielFeld$ (I%) =  SpielKarte$ (ZufallsZahl%)
  102.   IF ZufallsZahl% < Max% THEN
  103.     SpielKarte$ (ZufallsZahl%) = SpielKarte$ (Max%)
  104.                 ' gezogene Karte durch letzte Karte ersetzen
  105.   END IF
  106.   DECR Max%                   ' Kartenstapel um 1 reduzieren
  107. NEXT I%
  108.  
  109. RueckSeite$ = CHR$ (177) + CHR$ (177)    ' Karten-Rueckseite
  110. LeereKarte$ = CHR$ (249) + CHR$ (249)    ' abgelegte Karte
  111.               ' Zeichen aus dem IBM-Grafiksatz, ev. anpassen
  112.  
  113. ' Start-Werte
  114. Punkte% (1) = 0 : Punkte% (2) = 0
  115. Spieler% = 1    : Runde% = 1
  116.  
  117. ' UP SpielBrett
  118. ' ein CALL-Aufruf wie in der PASCAL-Version waere natuerlich
  119. ' ebenso moeglich -> Aufgabe fuer den Leser
  120.  
  121. CLS
  122. LOCATE 1,36
  123. CALL Invers : PRINT " MEMORY " : CALL Normal
  124.  
  125. LOCATE 4,16
  126. CALL Invers : PRINT "A  B  C  D  E  F  G  H " : CALL Normal
  127.  
  128. FOR I% = 0 TO 7
  129.   LOCATE 6 + 2 * I%, 11 : CALL Invers : PRINT I% + 1
  130.   CALL Normal
  131.   FOR K% = 0 TO 7
  132.     CALL ZeigKarte (K%, I%, RueckSeite$)
  133.         ' CALL ZeigKarte (K%, I%, Spielfeld$ (K%+1 + I% *8))
  134.         ' die umgedrehten Karten
  135.   NEXT K%
  136. NEXT I%
  137.  
  138. CALL Invers
  139. LOCATE 5,50 : PRINT " Kartenwahl Spieler "
  140. CALL Zeichen (7, 50, 11, 32)
  141. LOCATE 8,50 : PRINT " Karte 1 : "
  142. CALL Zeichen (9, 50, 11, 32)
  143. LOCATE 10,50: PRINT " Karte 2 : "
  144. CALL Zeichen (11, 50, 11, 32)
  145. CALL  Normal
  146.  
  147. LOCATE 23,5 : PRINT "Punkte Spieler 1 : "; Punkte% (1)
  148. LOCATE 24,5 : PRINT "Punkte Spieler 2 : "; Punkte% (2);
  149.  
  150. CALL Invers : LOCATE 1,60 : PRINT "Runde : "; Runde%
  151. CALL Normal
  152.  
  153. LOCATE 23,52 : PRINT "Eingabebeispiel : A1"
  154. LOCATE 24,52 : PRINT "Ende mit '^Q'";
  155.  
  156. END SUB
  157.  
  158. '(* ----------------------------------------------------- *)
  159. SUB Kontrolle  (Karte%, Wahl1$, Wahl2$, Korrekt%, Position%)
  160.                ' ueberprueft den eingegebenen Wert und dreht
  161.                ' die Karte um
  162.  
  163. SHARED SpielFeld$ (), LeereKarte$, PositionK1%
  164.  
  165. LOCAL  Y%, X%
  166.  
  167. Korrekt% = 0   ' Turbo-Basic kennt keine BOOLE'schen Werte,
  168.                ' aber '1' und '0' tun's auch !
  169. Y% = ASC (Wahl2$) - 49 :  X% = ASC (Wahl1$) - 65
  170. Position% = Y% * 8 + X% + 1
  171.  
  172. IF SpielFeld$ (Position%) <> LeereKarte$ THEN Korrekt% = 1
  173.               ' vgl. SUB SpielEnde, Karte bereits abgelegt !
  174.  
  175. IF Karte% = 2 THEN
  176.   IF Position% = PositionK1% THEN Korrekt% = 0
  177. END IF                ' 2-mal die gleiche Karte gilt nicht !
  178.  
  179. IF Korrekt% = 1  THEN
  180.   CALL ZeigKarte (X% , Y%, SpielFeld$ (Position%))
  181. END IF
  182.  
  183. END SUB
  184.  
  185. '(* ----------------------------------------------------- *)
  186. SUB KartenWahl  (Karte%, Position%)
  187.  
  188. SHARED  SpielFeld$ (), Punkte% (), Spieler%, Korrekt%
  189.  
  190. LOCAL   OK%, Wahl1$, Wahl2$, Hilf%, Dummy$
  191.  
  192. CALL Invers : LOCATE 5,70 : PRINT Spieler%; " : "
  193. CALL Normal
  194.  
  195. DO     ' LOOP UNTIL Korrekt% = 1
  196.   IF Karte% = 1 THEN
  197.     CALL Zeichen (10, 62, 3, 32)
  198.     CALL Zeichen (8, 62, 3, 32)  : LOCATE 8,62
  199.   ELSE
  200.      CALL Zeichen (10, 62, 3, 32) : LOCATE 10,62
  201.   END IF   ' Karte% = 1
  202.  
  203.   DO    ' LOOP UNTIL OK% = 1      ' Eingabe der Spalte
  204.     OK% = 0
  205.     CALL HolEingabe (Taste$)
  206.     IF Taste$ = CHR$ (17) THEN STOP
  207.     Wahl1$ = UCASE$ (Taste$)
  208.     Hilf% = ASC (Wahl1$)
  209.     IF Hilf% >= 65 AND Hilf% <= 72 THEN
  210.       OK% = 1
  211.     ELSE
  212.       CALL Bell
  213.     END IF
  214.   LOOP UNTIL OK% = 1
  215.  
  216.   PRINT Wahl1$;
  217.   DO    ' LOOP UNTIL OK% = 1      ' Eingabe der Zeile
  218.     OK% = 0
  219.     CALL HolEingabe (Taste$)
  220.     Wahl2$ = UCASE$ (Taste$)
  221.     Hilf% = ASC (Wahl2$)
  222.     IF Hilf% >= 49 AND Hilf% <= 56 THEN
  223.       OK% = 1
  224.     ELSE
  225.       CALL Bell
  226.     END IF
  227.   LOOP UNTIL OK% = 1
  228.  
  229.   PRINT Wahl2$
  230.   CALL Kontrolle (Karte%,Wahl1$,Wahl2$,Korrekt%,Position%)
  231.   IF Korrekt% = 0 THEN CALL BELL
  232.  
  233. LOOP UNTIL Korrekt% = 1
  234.  
  235. END SUB
  236.  
  237. '(* ----------------------------------------------------- *)
  238. DEF FNZeile% (Position%)
  239.   FNZeile% = INT ((Position% - 1) / 8)
  240. END DEF
  241.  
  242. '(* ----------------------------------------------------- *)
  243. DEF FNSpalte% (Position%)
  244.   FNSpalte% = (Position% - 1) AND 7       ' entspricht MOD 8
  245. END DEF
  246.  
  247. '(* ----------------------------------------------------- *)
  248. DEF FNWelche$ (Position)
  249.  
  250. SHARED  SpielFeld$ (), LeereKarte$, RueckSeite$
  251.  
  252. IF SpielFeld$ (Position) <> LeereKarte$ THEN
  253.   FNWelche$ = RueckSeite$
  254. ELSE
  255.   FNWelche$ = LeereKarte$
  256. END IF
  257.  
  258. END DEF
  259.  
  260. '(* ----------------------------------------------------- *)
  261. SUB Weiter
  262.                       ' dreht die gezeigten Karten wieder um
  263.  
  264. SHARED  PositionK1%, PositionK2%
  265. LOCAL   Karte%
  266.  
  267. CALL Invers
  268. LOCATE 25,30 : PRINT " Weiter mit RETURN ";
  269. CALL Normal
  270.  
  271. DO
  272.   CALL HolEingabe (Taste$)
  273. LOOP UNTIL Taste$ = CHR$ (13)                 ' RETURN-Taste
  274.  
  275. CALL Zeichen (25, 1, 79, 32)
  276. CALL ZeigKarte (FNSpalte% (PositionK1%),_
  277.                 FNZeile% (PositionK1%),_
  278.                 FNWelche$ (PositionK1%))
  279. CALL ZeigKarte (FNSpalte% (PositionK2%),_
  280.                 FNZeile% (PositionK2%),_
  281.                 FNWelche$ (PositionK2%))
  282.  
  283. END SUB
  284.  
  285. '(* ----------------------------------------------------- *)
  286. DEF FNSpielEnde%
  287.  
  288. SHARED  SpielFeld$ (), Punkte% (), Spieler%, Runde%
  289. SHARED  RueckSeite$, LeereKarte$, PositionK1%, PositionK2%
  290.  
  291. FNSpielEnde% = 0
  292.  
  293. IF SpielFeld$ (PositionK1%) = SpielFeld$ (PositionK2%) THEN
  294.                                           ' 2 gleiche Karten
  295.   INCR Punkte% (Spieler%)
  296.   SpielFeld$ (PositionK1%) = LeereKarte$
  297.   SpielFeld$ (PositionK2%) = SpielFeld$ (PositionK1%)
  298.         ' gefundene Kartenfelder mit anderem Zeichen belegen
  299. END IF  ' IF SpielFeld$
  300.  
  301. LOCATE 23, 5 : PRINT "Punkte Spieler 1 : "; Punkte% (1)
  302. LOCATE 24, 5 : PRINT "Punkte Spieler 2 : "; Punkte% (2);
  303.  
  304. IF Punkte% (Spieler%) > 15 THEN
  305.   LOCATE 24, 31
  306.   CALL Invers
  307.   PRINT " Sieger : Spieler";  Spieler%;
  308.   CALL Normal
  309.   FNSpielEnde% = 1
  310. END IF
  311.  
  312. IF Spieler% = 2 THEN
  313.   INCR Runde%
  314.   CALL Invers : LOCATE 1, 60 : PRINT "Runde : ";  Runde%
  315.   CALL  Normal
  316.   Spieler% = 1
  317. ELSE
  318.   Spieler% = 2
  319. END IF
  320.  
  321. CALL Weiter
  322. END DEF
  323.  
  324. '*( ----------------------------------------------------- *)
  325. Main:
  326.  
  327. CALL Initialisierung
  328. DO
  329.   CALL KartenWahl (1, PositionK1%)    ' Karte 1
  330.   CALL KartenWahl (2, PositionK2%)    ' Karte 2
  331. LOOP UNTIL  FNSpielEnde% = 1
  332.  
  333. CALL HolEingabe (Taste$)
  334.  
  335. END
  336.