git.zerfleddert.de Git - micropolis/blob

1 /* cam.h

2 *

3 * Micropolis, Unix Version. This game was released for the Unix platform

4 * in or about 1990 and has been modified for inclusion in the One Laptop

6 * you need assistance with this program, you may contact:

7 * http://wiki.laptop.org/go/Micropolis or email micropolis@laptop.org.

8 *

9 * This program is free software: you can redistribute it and/or modify

10 * it under the terms of the GNU General Public License as published by

11 * the Free Software Foundation, either version 3 of the License, or (at

12 * your option) any later version.

13 *

14 * This program is distributed in the hope that it will be useful, but

15 * WITHOUT ANY WARRANTY; without even the implied warranty of

16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

17 * General Public License for more details. You should have received a

18 * copy of the GNU General Public License along with this program. If

19 * not, see <http://www.gnu.org/licenses/>.

20 *

21 * ADDITIONAL TERMS per GNU GPL Section 7

22 *

23 * No trademark or publicity rights are granted. This license does NOT

24 * give you any right, title or interest in the trademark SimCity or any

25 * other Electronic Arts trademark. You may not distribute any

26 * modification of this program using the trademark SimCity or claim any

27 * affliation or association with Electronic Arts Inc. or its employees.

28 *

29 * Any propagation or conveyance of this program must include this

30 * copyright notice and these terms.

31 *

32 * If you convey this program (or any modifications of it) and assume

33 * contractual liability for the program to recipients of it, you agree

34 * to indemnify Electronic Arts for any liability that those contractual

35 * assumptions impose on Electronic Arts.

36 *

37 * You may not misrepresent the origins of this program; modified

38 * versions of the program must be marked as such and not identified as

39 * the original program.

40 *

41 * This disclaimer supplements the one included in the General Public

42 * License. TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS

43 * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY

44 * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK. THE ENTIRE RISK OF

45 * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU. ELECTRONIC ARTS

46 * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,

47 * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,

48 * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY

49 * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,

50 * USAGE, OR TRADE PRACTICE. ELECTRONIC ARTS DOES NOT WARRANT AGAINST

51 * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL

52 * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE

53 * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE

54 * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE

55 * CORRECTED. NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR

56 * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY. SOME

57 * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED

58 * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A

59 * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY

60 * NOT APPLY TO YOU.

61 */

63 #include <stdio.h>

64 #include <stdlib.h>

65 #include <fcntl.h>

66 #include <signal.h>

67 #ifndef HPUX

68 #include <stropts.h>

69 #endif

70 #include <time.h>

71 #include <errno.h>

72 #ifndef IS_LINUX

73 #include <sys/conf.h>

74 #endif

75 #include <sys/types.h>

76 #include <sys/stat.h>

77 #include <sys/file.h>

78 #include <sys/mman.h>

79 #include <sys/socket.h>

80 #include <netinet/in.h>

81 #include <sys/ipc.h>

82 #include <sys/shm.h>

83 #include <X11/Xlib.h>

84 #include <X11/Xatom.h>

85 #include <X11/extensions/XShm.h>

88 #define CAM_ARGS \

89 SimCam *scam, ARGS

92 struct Can {

93 Byte *mem;

94 int line_bytes;

95 int width;

96 int height;

97 };

99 typedef struct Can Can;

100

101

102 struct Cam {

103 struct Cam *next;

104 Can *back, *front;

105 void (*neighborhood)();

106 Byte *rule;

107 int rule_size;

108 int width;

109 int height;

110 int ideal_width;

111 int ideal_height;

112 int phase;

113 int wrap;

114 int steps;

115 int frob;

116 int x;

117 int y;

118 int dx;

119 int dy;

120 int gx;

121 int gy;

122 int dragging;

123 int set_x;

124 int set_y;

125 int set_width;

126 int set_height;

127 int set_x0;

128 int set_y0;

129 int set_x1;

130 int set_y1;

131 char *name;

132 };

133

134

135 typedef struct Cam Cam;

136

137

138 struct SimCam {

139 struct SimCam *next;

   int w_x, w_y, w_width, w_height;

141 int visible;

142 int invalid;

143 int skips;

144 int skip;

145 Tk_Window tkwin;

146 Tcl_Interp *interp;

147 int flags;

148 XDisplay *x;

149 XImage *image;

150 XShmSegmentInfo *shminfo;

151 int line_bytes;

152 u_char *data;

153 int cam_count;

154 Cam *cam_list;

155 };

156

157

158 typedef struct SimCam SimCam;

159

160

161 #define NORTHWEST ((Byte)((l0>>16) & 0xff))

162 #define NORTH ((Byte)((l0>>8) & 0xff))

163 #define NORTHEAST ((Byte)(l0 & 0xff))

164 #define WEST ((Byte)((l1>>16) & 0xff))

165 #define CENTER ((Byte)((l1>>8) & 0xff))

166 #define EAST ((Byte)(l1 & 0xff))

167 #define SOUTHWEST ((Byte)((l2>>16) & 0xff))

168 #define SOUTH ((Byte)((l2>>8) & 0xff))

169 #define SOUTHEAST ((Byte)(l2 & 0xff))

170

171 #define SUM8 ((l0&1) + ((l0>>8)&1) + ((l0>>16)&1) + \

172 (l1&1) + ((l1>>16)&1) + \

173 (l2&1) + ((l2>>8)&1) + ((l2>>16)&1))

174

175 #define SUM9 (SUM8 + ((l1>>8)&1))

176

177 #define SUM8p(p) (((l0>>p)&1) + ((l0>>(p+8))&1) + ((l0>>(p+16))&1) + \

178 ((l1>>p)&1) + ((l1>>(p+16))&1) + \

179 ((l2>>p)&1) + ((l2>>(p+8))&1) + ((l2>>(p+16))&1))

180

181 #define SUM9p(p) (SUM8p(p) + ((l1>>(p+8))&1))

182

183 #define CAM_LOOP_BODY(BODY) \

184 { int y; \

185 int backline = cam->back->line_bytes, \

186 frontline = cam->front->line_bytes; \

187 Byte *back = cam->back->mem, \

188 *front = cam->front->mem; \

189 Byte *rule = cam->rule; \

190 for (y=0; y<cam->height; y++) { \

191 QUAD l0 = (back[0]<<8) + \

192 back[1], \

193 l1 = (back[backline]<<8) + \

194 back[backline+1], \

195 l2 = (back[backline+backline]<<8) + \

196 back[backline+backline+1]; \

197 int x, w = cam->width; \

198 for (x=0; x<w; x++) { \

199 l0 = (l0<<8) + back[2]; \

200 l1 = (l1<<8) + back[backline+2]; \

201 l2 = (l2<<8) + back[backline+backline+2]; \

202 BODY; \

203 back++; front++; \

204 } \

205 back += backline - w; front += frontline - w; \

206 } \

207 }

208

209 #define CAM_LOOP(RULE) \

210 CAM_LOOP_BODY(*front = (RULE) )

211

212 #define CAM_TABLE_LOOP(NEIGHBORHOOD) \

213 CAM_LOOP(rule[(NEIGHBORHOOD)])

214

215

216 typedef void (*vf)();

217