home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / pocketbk / games / yam11src / GAME.OPL < prev    next >
Text File  |  1995-07-27  |  6KB  |  282 lines
  1. REM MODULE Game
  2. REM Copyright (c) 1995 Bermuda Software Publishing
  3. REM Written by Bruno Essmann (bessmann@iiic.ethz.ch)
  4.  
  5. PROC Game_PreInit
  6.     REM Initialize minefield
  7.     LOCAL x%, y%
  8.  
  9.     LOCK ON
  10.     REM Initialize global variables
  11.     NoFlags = 0
  12.     NoFalseFlags = 0
  13.     NoFree = GameW*GameH-GameMines
  14.  
  15.     REM Initialize minefield, set all fields to 'Free'
  16.     y% = 0
  17.     WHILE y% < MaxH
  18.         x% = 0
  19.         WHILE x% < MaxW
  20.             SetFieldtype(x%, y%, FieldFree)
  21.             INC(x%)
  22.         ENDWH
  23.         INC(y%)
  24.     ENDWH
  25.     LOCK OFF
  26. ENDP REM Game_PreInit
  27.  
  28. PROC Game_Init
  29.     REM Initialize minefield and distribute mines
  30.     LOCAL x%, y%, i%, k%, mines%
  31.     LOCAL mxm%, mym%, mxp%, myp%
  32.  
  33.     LOCK ON
  34.     REM Indicate, we're initializing
  35.     GameStatus = GameInit
  36.     Disp_DrawSmiley
  37.  
  38.     BUSY GameInitDistrib, 1, 2
  39.     REM Distribute mines randomly
  40.     mxm% = MarkX-1 : mxp% = MarkX+1
  41.     mym% = MarkY-1 : myp% = MarkY+1
  42.     i% = 0
  43.     WHILE i% < GameMines
  44.         DO
  45.             DO
  46.                 x% = Util_Rand(GameW) : y% = Util_Rand(GameH)
  47.             UNTIL (x% < mxm%) OR (x% > mxp%) OR (y% < mym%) OR (y% > myp%)
  48.         UNTIL Fieldtype(x%, y%) = FieldFree
  49.         SetFieldtype(x%, y%, FieldMined)
  50.         INC(i%)
  51.     ENDWH
  52.  
  53.     BUSY GameInitCalc, 1, 2
  54.     REM Calculate number of mines in adjacent fields
  55.     REM (I know that this could be done faster but I don't
  56.     REM think that the gain is worth the trouble...)
  57.     x% = 0
  58.     WHILE x% < GameW
  59.         y% = 0
  60.         WHILE y% < GameH
  61.             IF Fieldtype(x%, y%) <> FieldMined
  62.                 mines% = 0
  63.                 i% = x%-1
  64.                 WHILE i% <= x%+1
  65.                     k% = y%-1
  66.                     WHILE k% <= y%+1
  67.                         IF (i% >= 0) AND (i% < GameW) AND (k% >= 0) AND (k% < GameH)
  68.                             IF Fieldtype(i%, k%) = FieldMined : INC(mines%) : ENDIF
  69.                         ENDIF
  70.                         INC(k%)
  71.                     ENDWH
  72.                     INC(i%)
  73.                 ENDWH
  74.                 SetNoMines(x%, y%, mines%)
  75.             ENDIF
  76.             INC(y%)
  77.         ENDWH
  78.         INC(x%)
  79.     ENDWH
  80.  
  81.     BUSY OFF
  82.     LOCK OFF
  83.     REM Game is running...
  84.     GameStatus = GamePlay : Disp_DrawSmiley
  85.     TimerStart
  86. ENDP REM Game_Init
  87.  
  88. PROC Game_Lost
  89.     LOCAL x%, y%, i%
  90.  
  91.     TimerStop
  92.     Util_Play(SoundLost)
  93.     GameStatus = GameOver
  94.     Disp_DrawFlags
  95.     Disp_DrawSmiley
  96.     x% = 0
  97.     WHILE x% < GameW
  98.         y% = 0
  99.         WHILE y% < GameH
  100.             i% = Fieldtype(x%, y%)
  101.             IF (i% = FieldFalseFlagged) OR (i% = FieldMined)
  102.                 Disp_DrawField(x%, y%)
  103.             ENDIF
  104.             INC(y%)
  105.         ENDWH
  106.         INC(x%)
  107.     ENDWH
  108. ENDP REM Game_Lost
  109.  
  110. PROC Game_Won
  111.     TimerStop
  112.     Util_Play(SoundWon)
  113.     GameStatus = GameOver
  114.     Disp_DrawSmiley
  115.     CheckHiscore    
  116. ENDP REM Game_Won
  117.  
  118. PROC Game_Cheat
  119.     REM Check one single field
  120.     LOCAL t%, w%
  121.  
  122.     t% = Fieldtype(MarkX, MarkY)
  123.     IF (t% = FieldMined) OR (t% = FieldFalseFlagged)
  124.         GameStatus = GamePeekNada
  125.     ELSE
  126.         GameStatus = GamePeekGood
  127.     ENDIF
  128.     Disp_DrawSmiley
  129.     t% = GameCheatDelay : w% = 10 / t%
  130.     WHILE t% > 0 : TimerUpdate : PAUSE w% : DEC(t%) : ENDWH
  131.     GameStatus = GamePlay
  132.     Disp_DrawSmiley
  133. ENDP REM Game_Cheat
  134.  
  135. #ifdef CHECK_RECURSIVE
  136.  
  137. REM Recursive version
  138. PROC Game_CheckField(x%, y%, t%)
  139.     LOCAL i%, k%
  140.     
  141.     IF t% = FieldMined
  142.         Game_Lost
  143.     ELSE
  144.         SetFieldtype(x%, y%, FieldNumbered)
  145.         IF Fieldnumber(x%, y%) = 0
  146.             i% = x%-1
  147.             WHILE i% <= x%+1
  148.                 k% = y%-1
  149.                 WHILE k% <= y%+1
  150.                     IF (i% >= 0) AND (i% < GameW) AND (k% >= 0) AND (k% < GameH)
  151.                         IF Fieldtype(i%, k%) = FieldFree
  152.                             Game_CheckField(i%, k%, FieldFree)
  153.                         ENDIF
  154.                     ENDIF
  155.                     INC(k%)
  156.                 ENDWH
  157.                 INC(i%)
  158.             ENDWH
  159.         ENDIF
  160.         Disp_DrawField(x%, y%)
  161.         DEC(NoFree)
  162.         IF CheckWon() : Game_Won : ENDIF
  163.     ENDIF
  164. ENDP REM Game_CheckField
  165.  
  166. #else
  167.  
  168. REM Nonrecursive version
  169. PROC Game_CheckField(x%, y%, t%)
  170.     LOCAL StackX%(MaxWH), StackY%(MaxWH), Top%, Bot%, i%, k%, c%
  171.     
  172.     IF t% = FieldMined
  173.         Game_Lost : RETURN
  174.     ENDIF
  175.     Bot% = 1 : Top% = 2
  176.     StackX%(1) = x% : StackY%(1) = y%
  177.     WHILE Bot% < Top%
  178.         SetFieldtype(StackX%(Bot%), StackY%(Bot%), FieldNumbered)
  179.         IF Fieldnumber(StackX%(Bot%), StackY%(Bot%)) = 0
  180.             i% = StackX%(Bot%)-1
  181.             WHILE i% <= StackX%(Bot%)+1
  182.                 k% = StackY%(Bot%)-1
  183.                 WHILE k% <= StackY%(Bot%)+1
  184.                     IF (i% >= 0) AND (i% < GameW) AND (k% >= 0) AND (k% < GameH)
  185.                         IF Fieldtype(i%, k%) = FieldFree
  186.                             c% = Bot%+1
  187.                             WHILE c% < Top%
  188.                                 IF (StackX%(c%) = i%) AND (StackY%(c%) = k%)
  189.                                     BREAK
  190.                                 ENDIF
  191.                                 INC(c%)
  192.                             ENDWH
  193.                             IF c% = Top%
  194.                                 StackX%(Top%) = i% : StackY%(Top%) = k%
  195.                                 INC(Top%)
  196.                             ENDIF
  197.                         ENDIF
  198.                     ENDIF
  199.                     INC(k%)
  200.                 ENDWH
  201.                 INC(i%)
  202.             ENDWH
  203.         ENDIF
  204.         Disp_DrawField(StackX%(Bot%), StackY%(Bot%))
  205.         DEC(NoFree)
  206.         IF CheckWon() : Game_Won : RETURN : ENDIF
  207.         INC(Bot%)
  208.     ENDWH
  209. ENDP REM Game_CheckField
  210.  
  211. #endif
  212.  
  213. PROC Game_FlagField
  214.     REM Mark field with a flag
  215.     LOCAL i%
  216.  
  217.     i% = Fieldtype(MarkX, MarkY)
  218.     IF i% = FieldNumbered
  219.         RETURN
  220.     ELSEIF i% = FieldMined
  221.         INC(NoFlags)
  222.         SetFieldtype(MarkX, MarkY, FieldFlagged)
  223.     ELSEIF i% = FieldFree
  224.         INC(NoFalseFlags)
  225.         SetFieldtype(MarkX, MarkY, FieldFalseFlagged)
  226.     ELSEIF i% = FieldFlagged
  227.         DEC(NoFlags)
  228.         SetFieldtype(MarkX, MarkY, FieldMined)
  229.     ELSEIF i% = FieldFalseFlagged
  230.         DEC(NoFalseFlags)
  231.         SetFieldtype(MarkX, MarkY, FieldFree)
  232.     ENDIF
  233.     Disp_DrawField(MarkX, MarkY)
  234.     Disp_DrawFlags
  235.     Disp_MarkShow
  236.     IF CheckWon() : Game_Won : ENDIF
  237. ENDP REM Game_FlagField
  238.  
  239. PROC Game_CheckGroup
  240.     REM This only works if current field is already uncovered
  241.     LOCAL x%,  y%, t%, n%
  242.     
  243.     n% = Fieldnumber(MarkX, MarkY)
  244.     x% = MarkX-1
  245.     WHILE x% <= MarkX+1
  246.         y% = MarkY-1
  247.         WHILE y% <= MarkY+1
  248.             IF (x% >= 0) AND (x% < GameW) AND (y% >= 0) AND (y% < GameH)
  249.                 t% = Fieldtype(x%, y%)
  250.                 IF (t% = FieldFlagged) OR (t% = FieldFalseFlagged)
  251.                     DEC(n%)
  252.                 ENDIF
  253.             ENDIF
  254.             INC(y%)
  255.         ENDWH
  256.         INC(x%)
  257.     ENDWH
  258.     IF n% <> 0
  259.         Util_Play(SoundError)
  260.         RETURN
  261.     ENDIF
  262.     
  263.     LOCK ON
  264.     x% = MarkX-1
  265.     WHILE x% <= MarkX+1
  266.         y% = MarkY-1
  267.         WHILE y% <= MarkY+1
  268.             IF (x% >= 0) AND (x% < GameW) AND (y% >= 0) AND (y% < GameH)
  269.                 t% = Fieldtype(x%, y%)
  270.                 IF (t% = FieldFree) OR (t% = FieldMined)
  271.                     Game_CheckField(x%, y%, t%)
  272.                 ENDIF
  273.             ENDIF
  274.             INC(y%)
  275.         ENDWH
  276.         INC(x%)
  277.     ENDWH
  278.     LOCK OFF
  279. ENDP REM Game_CheckGroup
  280.  
  281. REM END Game.
  282.