]> git.zerfleddert.de Git - micropolis/blob - src/sim/w_sound.c
projects / micropolis / blob
? search:


a903ae764ed5f75821cac2b03ec71571c4a7d473
[micropolis] / 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 void
149 InitializeSound(void)
150 {
151 int reserved_chans;
152 char buf[256];
153
154 if (SDL_Init(SDL_INIT_AUDIO) == -1) {
155 fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
156 return;
157 }
158
159 if (Mix_OpenAudio(22050, MIX_DEFAULT_FORMAT, 1, 1024) == -1) {
160 fprintf(stderr, "Mix_OpenAudio: %s\n", Mix_GetError());
161 return;
162 }
163
164 reserved_chans = Mix_ReserveChannels(1);
165
166 if (reserved_chans != 1) {
167 fprintf(stderr, "Mix_ReserveChannels: %s\n", Mix_GetError());
168 return;
169 }
170
171 if (Mix_AllocateChannels(SIM_NCHANNELS) == -1) {
172 fprintf(stderr, "Mix_AllocateChannels: %s\n", Mix_GetError());
173 return;
174 }
175
176 snprintf(buf, sizeof(buf), "%s/sounds/%s", ResourceDir, DOZER_SOUND);
177 rumble = Mix_LoadWAV(buf);
178
179 if (rumble == NULL) {
180 printf("Mix_LoadWAV: %s\n", Mix_GetError());
181 return;
182 }
183
184 SoundInitialized = 1;
185 }
186
187
188 void
189 ShutDownSound()
190 {
191 int i;
192 SoundInitialized = 0;
193
194 for (i = 0; i < SIM_NSOUNDS; i++) {
195 if (sounds[i].wave) {
196 Mix_FreeChunk(sounds[i].wave);
197 sounds[i].wave = NULL;
198 }
199 }
200 if (rumble) {
201 Mix_FreeChunk(rumble);
202 rumble = NULL;
203 }
204 Mix_CloseAudio();
205 SDL_Quit();
206 }
207
208
209 void
210 MakeSound(char *channel, char *id)
211 {
212 char buf[256];
213 int i;
214
215 if (!UserSoundOn) return;
216 if (!SoundInitialized) return;
217
218 for (i = 0; i < SIM_NSOUNDS; i++) {
219 if (!strcmp(sounds[i].id, id))
220 break;
221 }
222
223 if (sounds[i].wave) {
224 if (Mix_PlayChannel(-1, sounds[i].wave, 0) == -1)
225 fprintf(stderr, "Mix_PlayChannel: %s\n", Mix_GetError());
226 return;
227 }
228
229 snprintf(buf, sizeof(buf), "%s/sounds/%s", ResourceDir,
230 sounds[i].file);
231
232 sounds[i].wave = Mix_LoadWAV(buf);
233
234 if (sounds[i].wave == NULL) {
235 fprintf(stderr, "Mix_LoadWAV: %s\n", Mix_GetError());
236 return;
237 }
238
239 if (Mix_PlayChannel(-1, sounds[i].wave, 0) == -1)
240 fprintf(stderr, "Mix_PlayChannel: %s\n", Mix_GetError());
241 }
242
243 void
244 StartBulldozer(void)
245 {
246 if (!UserSoundOn) return;
247 if (!SoundInitialized) return;
248
249 if (Mix_PlayChannel(DOZER_CHANNEL, rumble, 4) == -1) {
250 printf("Mix_PlayChannel: %s\n", Mix_GetError());
251 return;
252 }
253 }
254
255
256 void
257 StopBulldozer(void)
258 {
259 if (!UserSoundOn) return;
260 if (!SoundInitialized) return;
261
262 Mix_HaltChannel(DOZER_CHANNEL);
263 }
264
265 #else /* WITH_SDL_MIXER */
266 void
267 InitializeSound()
268 {
269 SoundInitialized = 1;
270 }
271
272 void
273 ShutDownSound()
274 {
275 SoundInitialized = 0;
276 }
277
278 void
279 MakeSound(char *channel, char *id)
280 {
281 char filename[256], player[256];
282 static struct timeval last = {0, 0};
283 struct timeval now;
284 unsigned int diff;
285 int i;
286 pid_t pid;
287
288 gettimeofday(&now, NULL);
289
290 diff = ((now.tv_sec - last.tv_sec) * 1000000) +
291 (now.tv_usec - last.tv_usec);
292
293 if (diff < 100000)
294 return;
295
296 last = now;
297
298 if (!UserSoundOn) return;
299 if (!SoundInitialized) return;
300
301 for (i = 0; i < SIM_NSOUNDS; i++) {
302 if (!strcmp(sounds[i].id, id))
303 break;
304 }
305
306 snprintf(filename, sizeof(filename), "%s/sounds/%s", ResourceDir,
307 sounds[i].file);
308
309 snprintf(player, sizeof(player), "%s/sounds/player", ResourceDir);
310
311 pid = fork();
312
313 switch(pid) {
314 case 0:
315 execl(player, player, filename, NULL);
316 exit(1);
317 break;
318 case -1:
319 perror("fork failed");
320 break;
321 default:
322 break;
323 }
324 }
325
326 void
327 StartBulldozer(void)
328 {
329 MakeSound(0, "Rumble");
330 }
331
332 void
333 StopBulldozer(void)
334 {
335 }
336 #endif
337
338
339 void
340 MakeSoundOn(SimView *view, char *channel, char *id)
341 {
342 if (!UserSoundOn) return;
343 if (!SoundInitialized) return;
344
345 MakeSound(channel, id);
346 }
347
348
349 /* XXX comefrom: doKeyEvent */
350 void
351 SoundOff(void)
352 {
353 ShutDownSound();
354 }
355
356
357 void
358 DoStartSound(char *channel, char *id)
359 {
360 MakeSound(channel, id);
361 }
362
363 void
364 DoStopSound(char *id)
365 {
366 StopBulldozer();
367 }
368
369 int
370 SoundCmd(CLIENT_ARGS)
371 {
372 if (!strcmp(argv[2], "Rumble"))
373 StartBulldozer();
374 else
375 MakeSound(NULL, argv[2]);
376 return 0;
377 }
378
379 int
380 DozerCmd(CLIENT_ARGS)
381 {
382 StopBulldozer();
383 return 0;
384 }
385
386 void
387 sound_command_init(void)
388 {
389 Tcl_CreateCommand(tk_mainInterp, "playsound", SoundCmd,
390 (ClientData)NULL, (void (*)()) NULL);
391 Tcl_CreateCommand(tk_mainInterp, "stopdozer", DozerCmd,
392 (ClientData)NULL, (void (*)()) NULL);
393 }
Micropolis
Impressum, Datenschutz