Annotation of micropolis/src/sim/w_update.c, revision 1.1.1.1

1.1       root        1: /* w_update.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
                      5:  * Per Child program.  Copyright (C) 1989 - 2007 Electronic Arts Inc.  If
                      6:  * you need assistance with this program, you may contact:
                      7:  *   http://wiki.laptop.org/go/Micropolis  or email  [email protected].
                      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"
                     63: 
                     64: 
                     65: short MustUpdateFunds;
                     66: short MustUpdateOptions;
                     67: QUAD LastCityTime;
                     68: QUAD LastCityYear;
                     69: QUAD LastCityMonth;
                     70: QUAD LastFunds;
                     71: QUAD LastR, LastC, LastI;
                     72: 
                     73: char *dateStr[12] = {
                     74:   "Jan", "Feb", "Mar", "Apr", "May", "Jun", 
                     75:   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
                     76: };
                     77: 
                     78: 
                     79: void DoUpdateHeads()
                     80: {
                     81:   showValves();
                     82:   doTimeStuff();
                     83:   ReallyUpdateFunds();
                     84:   updateOptions();
                     85: }
                     86: 
                     87: 
                     88: void UpdateEditors()
                     89: {
                     90:   InvalidateEditors();
                     91:   DoUpdateHeads();
                     92: }
                     93: 
                     94: 
                     95: void UpdateMaps()
                     96: {
                     97:   InvalidateMaps();
                     98: }
                     99: 
                    100: 
                    101: void UpdateGraphs()
                    102: {
                    103:   ChangeCensus();
                    104: }
                    105: 
                    106: 
                    107: void UpdateEvaluation()
                    108: {
                    109:   ChangeEval();
                    110: }
                    111: 
                    112: 
                    113: void UpdateHeads()
                    114: {
                    115:   MustUpdateFunds = ValveFlag = 1;
                    116:   LastCityTime = LastCityYear = LastCityMonth = LastFunds = LastR = -999999;
                    117:   DoUpdateHeads();
                    118: }
                    119: 
                    120: UpdateFunds(void)
                    121: {
                    122:   MustUpdateFunds = 1;
                    123: //  Kick();
                    124: }
                    125: 
                    126: 
                    127: ReallyUpdateFunds(void)
                    128: {
                    129:   char localStr[256], dollarStr[256], buf[256];
                    130: 
                    131:   if (!MustUpdateFunds) return;
                    132: 
                    133:   MustUpdateFunds = 0;
                    134: 
                    135:   if (TotalFunds < 0) TotalFunds = 0;
                    136: 
                    137:   if (TotalFunds != LastFunds) {
                    138:     LastFunds = TotalFunds;
                    139:     sprintf(localStr, "%d", TotalFunds);
                    140:     makeDollarDecimalStr(localStr, dollarStr);
                    141: 
                    142:     sprintf(localStr, "Funds: %s", dollarStr);
                    143: 
                    144:     sprintf(buf, "UISetFunds {%s}", localStr);
                    145:     Eval(buf);
                    146:   }
                    147: }
                    148: 
                    149: 
                    150: doTimeStuff(void) 
                    151: {
                    152: //  if ((CityTime >> 2) != LastCityTime) {
                    153:     updateDate();
                    154: //  }
                    155: }
                    156: 
                    157: 
                    158: updateDate(void)
                    159: {      
                    160:   int y;
                    161:   int m;
                    162:   char str[256], buf[256];
                    163:   int megalinium = 1000000;
                    164: 
                    165:   LastCityTime = CityTime >> 2;
                    166: 
                    167:   y = ((int)CityTime / 48) + (int)StartingYear;
                    168:   m = ((int)CityTime % 48) >> 2;
                    169: 
                    170:   if (y >= megalinium) {
                    171:     SetYear(StartingYear);
                    172:     y = StartingYear;
                    173:     SendMes(-40);
                    174:   }
                    175: 
                    176:   doMessage();
                    177: 
                    178:   if ((LastCityYear != y) ||
                    179:       (LastCityMonth != m)) {
                    180: 
                    181:     LastCityYear = y;
                    182:     LastCityMonth = m;
                    183: 
                    184:     sprintf(str, "%s %d", dateStr[m], y);
                    185: 
                    186:     sprintf(buf,
                    187:            "UISetDate {%s} %d %d",
                    188:            str, m, y);
                    189:     Eval(buf);
                    190:   }
                    191: }
                    192: 
                    193: 
                    194: showValves(void)
                    195: {
                    196:   if (ValveFlag) {
                    197:     drawValve();
                    198:     ValveFlag = 0;
                    199:   }
                    200: }
                    201: 
                    202: 
                    203: drawValve(void)
                    204: {
                    205:   double r, c, i;
                    206: 
                    207:   r = RValve;
                    208:   if (r < -1500) r = -1500;
                    209:   if (r > 1500) r = 1500;
                    210: 
                    211:   c = CValve;
                    212:   if (c < -1500) c = -1500;
                    213:   if (c > 1500) c = 1500;
                    214: 
                    215:   i = IValve;
                    216:   if (i < -1500) i = -1500;
                    217:   if (i > 1500) i = 1500;
                    218: 
                    219:   if ((r != LastR) ||
                    220:       (c != LastC) ||
                    221:       (i != LastI)) {
                    222:     LastR = r;
                    223:     LastC = c;
                    224:     LastI = i;
                    225:     SetDemand(r, c, i);
                    226:   }
                    227: }
                    228: 
                    229: 
                    230: SetDemand(double r, double c, double i)
                    231: {
                    232:   char buf[256];
                    233: 
                    234:   sprintf(buf, "UISetDemand %d %d %d",
                    235:          (int)(r / 100), (int)(c / 100), (int)(i / 100));
                    236:   Eval(buf);
                    237: }
                    238: 
                    239: 
                    240: updateOptions()
                    241: {
                    242:   int options;
                    243: 
                    244:   if (MustUpdateOptions) {
                    245:     options = 0;
                    246:     if (autoBudget)    options |= 1;
                    247:     if (autoGo)                options |= 2;
                    248:     if (autoBulldoze)  options |= 4;
                    249:     if (!NoDisasters)  options |= 8;
                    250:     if (UserSoundOn)   options |= 16;
                    251:     if (DoAnimation)   options |= 32;
                    252:     if (DoMessages)    options |= 64;
                    253:     if (DoNotices)     options |= 128;
                    254: 
                    255:     MustUpdateOptions = 0;
                    256:     UpdateOptionsMenu(options);
                    257:   }
                    258: }
                    259: 
                    260: 
                    261: UpdateOptionsMenu(int options)
                    262: {
                    263:   char buf[256];
                    264:   sprintf(buf, "UISetOptions %d %d %d %d %d %d %d %d",
                    265:          (options&1)?1:0, (options&2)?1:0,
                    266:          (options&4)?1:0, (options&8)?1:0,
                    267:          (options&16)?1:0, (options&32)?1:0,
                    268:          (options&64)?1:0, (options&128)?1:0);
                    269:   Eval(buf);
                    270: }
                    271: 
                    272: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.