Comment out the homepage URL
[pkg/netris.git] / board.c
1 /*
2  * Netris -- A free networked version of T*tris
3  * Copyright (C) 1994-1996,1999  Mark H. Weaver <mhw@netris.org>
4  * 
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  * 
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  * $Id: board.c,v 1.15 1999/05/16 06:56:24 mhw Exp $
20  */
21
22 #include "netris.h"
23 #include <stdlib.h>
24
25 #ifdef DEBUG_FALLING
26 # define B_OLD
27 #else
28 # define B_OLD abs
29 #endif
30
31 static BlockType board[MAX_SCREENS][MAX_BOARD_HEIGHT][MAX_BOARD_WIDTH];
32 static BlockType oldBoard[MAX_SCREENS][MAX_BOARD_HEIGHT][MAX_BOARD_WIDTH];
33 static unsigned int changed[MAX_SCREENS][MAX_BOARD_HEIGHT];
34 static int falling[MAX_SCREENS][MAX_BOARD_WIDTH];
35 static int oldFalling[MAX_SCREENS][MAX_BOARD_WIDTH];
36
37 ExtFunc void InitBoard(int scr)
38 {
39         boardHeight[scr] = MAX_BOARD_HEIGHT;
40         boardVisible[scr] = 20;
41         boardWidth[scr] = 10;
42         InitScreen(scr);
43 }
44
45 ExtFunc void CleanupBoard(int scr)
46 {
47         CleanupScreen(scr);
48 }
49
50 ExtFunc BlockType GetBlock(int scr, int y, int x)
51 {
52         if (y < 0 || x < 0 || x >= boardWidth[scr])
53                 return BT_wall;
54         else if (y >= boardHeight[scr])
55                 return BT_none;
56         else
57                 return abs(board[scr][y][x]);
58 }
59
60 ExtFunc void SetBlock(int scr, int y, int x, BlockType type)
61 {
62         if (y >= 0 && y < boardHeight[scr] && x >= 0 && x < boardWidth[scr]) {
63                 if (y < boardVisible[scr])
64                         falling[scr][x] += (type < 0) - (board[scr][y][x] < 0);
65                 board[scr][y][x] = type;
66                 changed[scr][y] |= 1 << x;
67         }
68 }
69
70 ExtFunc int RefreshBoard(int scr)
71 {
72         int y, x, any = 0;
73         unsigned int c;
74         BlockType b;
75
76         for (y = boardVisible[scr] - 1; y >= 0; --y)
77                 if ((c = changed[scr][y])) {
78                         if (robotEnable) {
79                                 RobotCmd(0, "RowUpdate %d %d", scr, y);
80                                 for (x = 0; x < boardWidth[scr]; ++x) {
81                                         b = board[scr][y][x];
82                                         if (fairRobot)
83                                                 b = abs(b);
84                                         RobotCmd(0, " %d", b);
85                                 }
86                                 RobotCmd(0, "\n");
87                         }
88                         changed[scr][y] = 0;
89                         any = 1;
90                         for (x = 0; c; (c >>= 1), (++x))
91                                 if ((c & 1) && B_OLD(board[scr][y][x])!=oldBoard[scr][y][x]) {
92                                         PlotBlock(scr, y, x, B_OLD(board[scr][y][x]));
93                                         oldBoard[scr][y][x] = B_OLD(board[scr][y][x]);
94                                 }
95                 }
96         if (robotEnable)
97                 RobotTimeStamp();
98         for (x = 0; x < boardWidth[scr]; ++x)
99                 if (oldFalling[scr][x] != !!falling[scr][x]) {
100                         oldFalling[scr][x] = !!falling[scr][x];
101                         PlotUnderline(scr, x, oldFalling[scr][x]);
102                         any = 1;
103                 }
104         return any;
105 }
106
107 ExtFunc int PlotFunc(int scr, int y, int x, BlockType type, void *data)
108 {
109         SetBlock(scr, y, x, type);
110         return 0;
111 }
112
113 ExtFunc int EraseFunc(int scr, int y, int x, BlockType type, void *data)
114 {
115         SetBlock(scr, y, x, BT_none);
116         return 0;
117 }
118
119 ExtFunc int CollisionFunc(int scr, int y, int x, BlockType type, void *data)
120 {
121         return GetBlock(scr, y, x) != BT_none;
122 }
123
124 ExtFunc int VisibleFunc(int scr, int y, int x, BlockType type, void *data)
125 {
126         return (y >= 0 && y < boardVisible[scr] && x >= 0 && x < boardWidth[scr]);
127 }
128
129 ExtFunc void PlotShape(Shape *shape, int scr, int y, int x, int falling)
130 {
131         ShapeIterate(shape, scr, y, x, falling, PlotFunc, NULL);
132 }
133
134 ExtFunc void EraseShape(Shape *shape, int scr, int y, int x)
135 {
136         ShapeIterate(shape, scr, y, x, 0, EraseFunc, NULL);
137 }
138
139 ExtFunc int ShapeFits(Shape *shape, int scr, int y, int x)
140 {
141         return !ShapeIterate(shape, scr, y, x, 0, CollisionFunc, NULL);
142 }
143
144 ExtFunc int ShapeVisible(Shape *shape, int scr, int y, int x)
145 {
146         return ShapeIterate(shape, scr, y, x, 0, VisibleFunc, NULL);
147 }
148
149 ExtFunc int MovePiece(int scr, int deltaY, int deltaX)
150 {
151         int result;
152
153         EraseShape(curShape[scr], scr, curY[scr], curX[scr]);
154         result = ShapeFits(curShape[scr], scr, curY[scr] + deltaY,
155                                 curX[scr] + deltaX);
156         if (result) {
157                 curY[scr] += deltaY;
158                 curX[scr] += deltaX;
159         }
160         PlotShape(curShape[scr], scr, curY[scr], curX[scr], 1);
161         return result;
162 }
163
164 ExtFunc int RotatePiece(int scr)
165 {
166         int result;
167
168         EraseShape(curShape[scr], scr, curY[scr], curX[scr]);
169         result = ShapeFits(curShape[scr]->rotateTo, scr, curY[scr], curX[scr]);
170         if (result)
171                 curShape[scr] = curShape[scr]->rotateTo;
172         PlotShape(curShape[scr], scr, curY[scr], curX[scr], 1);
173         return result;
174 }
175
176 ExtFunc int DropPiece(int scr)
177 {
178         int count = 0;
179
180         EraseShape(curShape[scr], scr, curY[scr], curX[scr]);
181         while (ShapeFits(curShape[scr], scr, curY[scr] - 1, curX[scr])) {
182                 --curY[scr];
183                 ++count;
184         }
185         PlotShape(curShape[scr], scr, curY[scr], curX[scr], 1);
186         return count;
187 }
188
189 ExtFunc int LineIsFull(int scr, int y)
190 {
191         int x;
192
193         for (x = 0; x < boardWidth[scr]; ++x)
194                 if (GetBlock(scr, y, x) == BT_none)
195                         return 0;
196         return 1;
197 }
198
199 ExtFunc void CopyLine(int scr, int from, int to)
200 {
201         int x;
202
203         if (from != to)
204                 for (x = 0; x < boardWidth[scr]; ++x)
205                         SetBlock(scr, to, x, GetBlock(scr, from, x));
206 }
207
208 ExtFunc int ClearFullLines(int scr)
209 {
210         int from, to;
211
212         from = to = 0;
213         while (to < boardHeight[scr]) {
214                 while (LineIsFull(scr, from))
215                         ++from;
216                 CopyLine(scr, from++, to++);
217         }
218         return from - to;
219 }
220
221 ExtFunc void FreezePiece(int scr)
222 {
223         int y, x;
224         BlockType type;
225
226         for (y = 0; y < boardHeight[scr]; ++y)
227                 for (x = 0; x < boardWidth[scr]; ++x)
228                         if ((type = board[scr][y][x]) < 0)
229                                 SetBlock(scr, y, x, -type);
230 }
231
232 ExtFunc void InsertJunk(int scr, int count, int column)
233 {
234         int y, x;
235
236         for (y = boardHeight[scr] - count - 1; y >= 0; --y)
237                 CopyLine(scr, y, y + count);
238         for (y = 0; y < count; ++y)
239                 for (x = 0; x < boardWidth[scr]; ++x)
240                         SetBlock(scr, y, x, (x == column) ? BT_none : BT_white);
241         curY[scr] += count;
242 }
243
244 /*
245  * vi: ts=4 ai
246  * vim: noai si
247  */