cvs.zerfleddert.de Git - micropolis/blob - src/sim/w_sound.c

   1 /*
   2  * Portions Copyright (c) 2008 Deanna Phillips <deanna@sdf.lonestar.org>
   3  */
   4
   5 /* w_sound.c
   6  *
   7  * Micropolis, Unix Version.  This game was released for the Unix platform
   8  * in or about 1990 and has been modified for inclusion in the One Laptop
   9  * Per Child program.  Copyright (C) 1989 - 2007 Electronic Arts Inc.  If
  10  * you need assistance with this program, you may contact:
  11  *   http://wiki.laptop.org/go/Micropolis  or email  micropolis@laptop.org.
  12  *
  13  * This program is free software: you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation, either version 3 of the License, or (at
  16  * your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License for more details.  You should have received a
  22  * copy of the GNU General Public License along with this program.  If
  23  * not, see <http://www.gnu.org/licenses/>.
  24  *
  25  *             ADDITIONAL TERMS per GNU GPL Section 7
  26  *
  27  * No trademark or publicity rights are granted.  This license does NOT
  28  * give you any right, title or interest in the trademark SimCity or any
  29  * other Electronic Arts trademark.  You may not distribute any
  30  * modification of this program using the trademark SimCity or claim any
  31  * affliation or association with Electronic Arts Inc. or its employees.
  32  *
  33  * Any propagation or conveyance of this program must include this
  34  * copyright notice and these terms.
  35  *
  36  * If you convey this program (or any modifications of it) and assume
  37  * contractual liability for the program to recipients of it, you agree
  38  * to indemnify Electronic Arts for any liability that those contractual
  39  * assumptions impose on Electronic Arts.
  40  *
  41  * You may not misrepresent the origins of this program; modified
  42  * versions of the program must be marked as such and not identified as
  43  * the original program.
  44  *
  45  * This disclaimer supplements the one included in the General Public
  46  * License.  TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
  47  * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
  48  * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK.  THE ENTIRE RISK OF
  49  * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU.  ELECTRONIC ARTS
  50  * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
  51  * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
  52  * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
  53  * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
  54  * USAGE, OR TRADE PRACTICE.  ELECTRONIC ARTS DOES NOT WARRANT AGAINST
  55  * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
  56  * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
  57  * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
  58  * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
  59  * CORRECTED.  NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
  60  * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY.  SOME
  61  * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
  62  * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
  63  * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
  64  * NOT APPLY TO YOU.
  65  */
  66 #ifdef WITH_SDL_MIXER
  67 #include "SDL.h"
  68 #include "SDL_mixer.h"
  69 #endif
  70
  71 #include "sim.h"
  72
  73
  74 #define SIM_NSOUNDS     47
  75 #define SIM_NCHANNELS   32
  76 #define DOZER_CHANNEL   0
  77 #define DOZER_SOUND     "rumble.wav"
  78
  79 struct sound {
  80   char *id;
  81   char *file;
  82 #ifdef WITH_SDL_MIXER
  83   Mix_Chunk *wave;
  84 #else
  85   void *wave;
  86 #endif
  87 };
  88
  89 struct sound sounds[SIM_NSOUNDS] = {
  90   { "A",                "a.wav",                NULL },
  91   { "Aaah",             "aaah.wav",             NULL },
  92   { "Airport",          "airport.wav",          NULL },
  93   { "Beep",             "beep.wav",             NULL },
  94   { "Boing",            "boing.wav",            NULL },
  95   { "Bop",              "bop.wav",              NULL },
  96   { "Build",            "build.wav",            NULL },
  97   { "Bulldozer",        "bulldozer.wav",        NULL },
  98   { "Chalk",            "chalk.wav",            NULL },
  99   { "Coal",             "coal.wav",             NULL },
 100   { "Com",              "com.wav",              NULL },
 101   { "Computer",         "computer.wav",         NULL },
 102   { "Cuckoo",           "cuckoo.wav",           NULL },
 103   { "E",                "e.wav",                NULL },
 104   { "Eraser",           "eraser.wav",           NULL },
 105   { "Explosion-High",   "explosion-high.wav",   NULL },
 106   { "Explosion-Low",    "explosion-low.wav",    NULL },
 107   { "Fire",             "fire.wav",             NULL },
 108   { "HeavyTraffic",     "heavytraffic.wav",     NULL },
 109   { "HonkHonk-High",    "honkhonk-high.wav",    NULL },
 110   { "HonkHonk-Low",     "honkhonk-low.wav",     NULL },
 111   { "HonkHonk-Med",     "honkhonk-med.wav",     NULL },
 112   { "Ignition",         "ignition.wav",         NULL },
 113   { "Ind",              "ind.wav",              NULL },
 114   { "Monster",          "monster.wav",          NULL },
 115   { "Nuclear",          "nuclear.wav",          NULL },
 116   { "O",                "o.wav",                NULL },
 117   { "Oop",              "oop.wav",              NULL },
 118   { "Park",             "park.wav",             NULL },
 119   { "Player",           "player.wav",           NULL },
 120   { "Police",           "police.wav",           NULL },
 121   { "QuackQuack",       "quackquack.wav",       NULL },
 122   { "Query",            "query.wav",            NULL },
 123   { "Rail",             "rail.wav",             NULL },
 124   { "Res",              "res.wav",              NULL },
 125   { "Road",             "road.wav",             NULL },
 126   { "Rumble",           "rumble.wav",           NULL },
 127   { "Seaport",          "seaport.wav",          NULL },
 128   { "Siren",            "siren.wav",            NULL },
 129   { "Skid",             "skid.wav",             NULL },
 130   { "Sorry",            "sorry.wav",            NULL },
 131   { "Stadium",          "stadium.wav",          NULL },
 132   { "UhUh",             "uhuh.wav",             NULL },
 133   { "Whip",             "whip.wav",             NULL },
 134   { "Wire",             "wire.wav",             NULL },
 135   { "Woosh",            "woosh.wav",            NULL },
 136   { "Zone",             "zone.wav",             NULL }
 137 };
 138
 139 static int SoundInitialized = 0;
 140
 141 #ifdef WITH_SDL_MIXER
 142 /* Sound routines */
 143
 144
 145 Mix_Chunk *rumble;
 146
 147
 148 InitializeSound()
 149 {
 150   int reserved_chans;
 151   char buf[256];
 152
 153   if (SDL_Init(SDL_INIT_AUDIO) == -1) {
 154     fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
 155     return;
 156   }
 157
 158   if (Mix_OpenAudio(22050, MIX_DEFAULT_FORMAT, 1, 1024) == -1) {
 159     fprintf(stderr, "Mix_OpenAudio: %s\n", Mix_GetError());
 160     return;
 161   }
 162
 163   reserved_chans = Mix_ReserveChannels(1);
 164
 165   if (reserved_chans != 1) {
 166     fprintf(stderr, "Mix_ReserveChannels: %s\n", Mix_GetError());
 167     return;
 168   }
 169
 170   if (Mix_AllocateChannels(SIM_NCHANNELS) == -1) {
 171     fprintf(stderr, "Mix_AllocateChannels: %s\n", Mix_GetError());
 172     return;
 173   }
 174
 175   snprintf(buf, sizeof(buf), "%s/sounds/%s", ResourceDir, DOZER_SOUND);
 176   rumble = Mix_LoadWAV(buf);
 177
 178   if (rumble == NULL) {
 179     printf("Mix_LoadWAV: %s\n", Mix_GetError());
 180     return;
 181   }
 182
 183   SoundInitialized = 1;
 184 }
 185
 186
 187 ShutDownSound()
 188 {
 189   int i;
 190   SoundInitialized = 0;
 191
 192   for (i = 0; i < SIM_NSOUNDS; i++) {
 193     if (sounds[i].wave) {
 194       Mix_FreeChunk(sounds[i].wave);
 195       sounds[i].wave = NULL;
 196     }
 197   }
 198   if (rumble) {
 199     Mix_FreeChunk(rumble);
 200     rumble = NULL;
 201   }
 202   Mix_CloseAudio();
 203   SDL_Quit();
 204 }
 205
 206
 207 MakeSound(char *channel, char *id)
 208 {
 209   char buf[256];
 210   int i;
 211
 212   if (!UserSoundOn) return;
 213   if (!SoundInitialized) return;
 214
 215   for (i = 0; i < SIM_NSOUNDS; i++) {
 216     if (!strcmp(sounds[i].id, id))
 217       break;
 218   }
 219
 220   if (sounds[i].wave) {
 221     if (Mix_PlayChannel(-1, sounds[i].wave, 0) == -1)
 222       fprintf(stderr, "Mix_PlayChannel: %s\n", Mix_GetError());
 223     return;
 224   }
 225
 226   snprintf(buf, sizeof(buf), "%s/sounds/%s", ResourceDir,
 227            sounds[i].file);
 228
 229   sounds[i].wave = Mix_LoadWAV(buf);
 230
 231   if (sounds[i].wave == NULL) {
 232     fprintf(stderr, "Mix_LoadWAV: %s\n", Mix_GetError());
 233     return;
 234   }
 235
 236   if (Mix_PlayChannel(-1, sounds[i].wave, 0) == -1)
 237     fprintf(stderr, "Mix_PlayChannel: %s\n", Mix_GetError());
 238 }
 239
 240 StartBulldozer(void)
 241 {
 242   if (!UserSoundOn) return;
 243   if (!SoundInitialized) return;
 244
 245   if (Mix_PlayChannel(DOZER_CHANNEL, rumble, 4) == -1) {
 246     printf("Mix_PlayChannel: %s\n", Mix_GetError());
 247     return;
 248   }
 249 }
 250
 251
 252 StopBulldozer(void)
 253 {
 254   if (!UserSoundOn) return;
 255   if (!SoundInitialized) return;
 256
 257   Mix_HaltChannel(DOZER_CHANNEL);
 258 }
 259
 260 #else /* WITH_SDL_MIXER */
 261 InitializeSound()
 262 {
 263   SoundInitialized = 1;
 264 }
 265
 266 ShutDownSound()
 267 {
 268   SoundInitialized = 0;
 269 }
 270
 271 MakeSound(char *channel, char *id)
 272 {
 273   char filename[256], player[256];
 274   int i;
 275   pid_t pid;
 276
 277   if (!UserSoundOn) return;
 278   if (!SoundInitialized) return;
 279
 280   for (i = 0; i < SIM_NSOUNDS; i++) {
 281     if (!strcmp(sounds[i].id, id))
 282       break;
 283   }
 284
 285   snprintf(filename, sizeof(filename), "%s/sounds/%s", ResourceDir,
 286            sounds[i].file);
 287
 288   snprintf(player, sizeof(player), "%s/sounds/player", ResourceDir);
 289
 290   pid = fork();
 291
 292   switch(pid) {
 293     case 0:
 294       execl(player, player, filename, NULL);
 295       break;
 296     case -1:
 297       perror("fork failed");
 298       break;
 299     default:
 300       break;
 301   }
 302 }
 303
 304 StartBulldozer(void)
 305 {
 306   MakeSound(0, "Rumble");
 307 }
 308
 309 StopBulldozer(void)
 310 {
 311 }
 312 #endif
 313
 314
 315 MakeSoundOn(SimView *view, char *channel, char *id)
 316 {
 317   if (!UserSoundOn) return;
 318   if (!SoundInitialized) return;
 319
 320   MakeSound(channel, id);
 321 }
 322
 323
 324 /* XXX comefrom: doKeyEvent */
 325 SoundOff(void)
 326 {
 327   ShutDownSound();
 328 }
 329
 330
 331 DoStartSound(char *channel, char *id)
 332 {
 333   MakeSound(channel, id);
 334 }
 335
 336 DoStopSound(char *id)
 337 {
 338   StopBulldozer();
 339 }
 340
 341 SoundCmd(CLIENT_ARGS)
 342 {
 343   if (!strcmp(argv[2], "Rumble"))
 344     StartBulldozer();
 345   else
 346     MakeSound(NULL, argv[2]);
 347   return 0;
 348 }
 349
 350 DozerCmd(CLIENT_ARGS)
 351 {
 352   StopBulldozer();
 353   return 0;
 354 }
 355
 356 sound_command_init()
 357 {
 358   Tcl_CreateCommand(tk_mainInterp, "playsound", SoundCmd,
 359                     (ClientData)NULL, (void (*)()) NULL);
 360   Tcl_CreateCommand(tk_mainInterp, "stopdozer", DozerCmd,
 361                     (ClientData)NULL, (void (*)()) NULL);
 362 }