cvs.zerfleddert.de Git - micropolis/blob

1 /* s_power.c

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 */

62 #include "sim.h"

65 /* Power Scan */

68 int PowerStackNum;

 char PowerStackX[PWRSTKSIZE], PowerStackY[PWRSTKSIZE];

70 QUAD MaxPower, NumPower;

 void PullPowerStack(void);

75 /* comefrom: TestForCond DoPowerScan TryGo */

76 int

77 MoveMapSim (short MDir)

78 {

79 switch (MDir) {

80 case 0:

     if (SMapY > 0) {

82 SMapY--;

83 return (TRUE);

84 }

     if (SMapY < 0)

86 SMapY = 0;

87 return (FALSE);

88 case 1:

     if (SMapX < (WORLD_X - 1)) {

90 SMapX++;

91 return (TRUE);

92 }

     if (SMapX > (WORLD_X - 1))

94 SMapX = WORLD_X - 1;

95 return (FALSE);

96 case 2:

     if (SMapY < (WORLD_Y - 1)) {

98 SMapY++;

99 return (TRUE);

100 }

     if (SMapY > (WORLD_Y - 1))

102 SMapY = WORLD_Y - 1;

103 return (FALSE);

104 case 3:

     if (SMapX > 0) {

106 SMapX--;

107 return (TRUE);

108 }

     if (SMapX < 0)

110 SMapX = 0;

111 return (FALSE);

112 case 4:

113 return (TRUE);

114 }

115 return (FALSE);

116 }

117

118

119 /* inlined -Don */

120 #if 0

121 /* comefrom: DoPowerScan */

122 SetPowerBit(void)

123 {

124 register int PowerWrd;

125

126 /* XXX: assumes 120x100 */

   PowerWrd = (SMapX >>4) + (SMapY <<3);

   PowerMap[PowerWrd] |= 1 << (SMapX & 15);

129 }

130 #endif

131

132

133 /* inlined */

134 #if 0

135 /* comefrom: TestForCond */

 int TestPowerBit(void)

137 {

138 register int PowerWrd;

139

   if ((CChr9 == NUCLEAR) || (CChr9 == POWERPLANT))

141 return(1);

142 /* XXX: assumes 120x100 */

   PowerWrd = (SMapX >>4) + (SMapY <<3);

144 if (PowerWrd >= PWRMAPSIZE)

145 return(0);

   return ((PowerMap[PowerWrd] & (1 << (SMapX & 15))) ? 1 : 0);

147 }

148 #endif

149

150

151 /* comefrom: DoPowerScan */

 short TestForCond(short TFDir)

153 {

   register int xsave, ysave, PowerWrd;

155

156 xsave = SMapX;

157 ysave = SMapY;

   if (MoveMapSim(TFDir)) {

159 /* TestPowerBit was taking a lot of time so I swapped the & order -Don */

160 #if 0

     if ((Map[SMapX][SMapY] & CONDBIT) &&

162 (!TestPowerBit()))

163 #else

     if ((Map[SMapX][SMapY] & CONDBIT) &&

165 (CChr9 != NUCLEAR) &&

166 (CChr9 != POWERPLANT) &&

167 (

168 #if 0

          (PowerWrd = (SMapX >>4) + (SMapY <<3)),

170 #else

          (PowerWrd = POWERWORD(SMapX, SMapY)),

172 #endif

173 ((PowerWrd > PWRMAPSIZE) ||

           ((PowerMap[PowerWrd] & (1 << (SMapX & 15))) == 0))))

175 #endif

176 {

177 SMapX = xsave;

178 SMapY = ysave;

179 return (TRUE);

180 }

181 }

182 SMapX = xsave;

183 SMapY = ysave;

184 return (FALSE);

185 }

186

187

188 /* comefrom: Simulate SpecialInit InitSimMemory */

189 void

190 DoPowerScan(void)

191 {

192 short ADir;

   register int ConNum, Dir, x;

194

   for (x = 0; x < PWRMAPSIZE; x++)

     PowerMap[x] = 0;    /* ClearPowerMem */

197

   MaxPower = (CoalPop * 700L) + (NuclearPop * 2000L); /* post release */

199 NumPower = 0;

200

201 while (PowerStackNum) {

202 PullPowerStack();

203 ADir = 4;

204 do {

205 if (++NumPower > MaxPower) {

206 SendMes(40);

207 return;

208 }

209 MoveMapSim(ADir);

210 /* inlined -Don */

211 #if 0

212 SetPowerBit();

213 #else

214 #if 1

215 SETPOWERBIT(SMapX, SMapY);

216 #else

       PowerMap[(SMapX >>4) + (SMapY <<3)] |= 1 << (SMapX & 15);

218 #endif

219 #endif

220 ConNum = 0;

221 Dir = 0;

       while ((Dir < 4) && (ConNum < 2)) {

         if (TestForCond(Dir)) {

224 ConNum++;

225 ADir = Dir;

226 }

227 Dir++;

228 }

       if (ConNum > 1)

230 PushPowerStack();

231 } while (ConNum);

232 }

233 }

234

235

236 /* comefrom: DoPowerScan DoSPZone */

237 void

238 PushPowerStack(void)

239 {

   if (PowerStackNum < (PWRSTKSIZE - 2)) {

241 PowerStackNum++;

242 PowerStackX[PowerStackNum] = SMapX;

243 PowerStackY[PowerStackNum] = SMapY;

244 }

245 }

246

247

248 /* comefrom: DoPowerScan */

249 void

250 PullPowerStack(void)

251 {

   if (PowerStackNum > 0)  {

253 SMapX = PowerStackX[PowerStackNum];

254 SMapY = PowerStackY[PowerStackNum];

255 PowerStackNum--;

256 }

257 }

258

259