227 break; |
227 break; |
228 } |
228 } |
229 } |
229 } |
230 break; |
230 break; |
231 |
231 |
232 case 0x08: { /* AI passenger service */ |
232 case 0x08: /* AI passenger service */ |
233 /* TODO */ |
233 /* TODO */ |
234 FOR_EACH_OBJECT { |
234 FOR_EACH_OBJECT grf_load_byte(&buf); |
235 grf_load_byte(&buf); |
|
236 } |
|
237 ret = true; |
235 ret = true; |
238 } break; |
236 break; |
239 case 0x09: { /* Speed */ |
237 |
|
238 case 0x09: /* Speed */ |
240 FOR_EACH_OBJECT { |
239 FOR_EACH_OBJECT { |
241 uint16 speed = grf_load_word(&buf); |
240 uint16 speed = grf_load_word(&buf); |
242 if (speed == 0xFFFF) speed = 0; |
241 if (speed == 0xFFFF) speed = 0; |
243 |
242 |
244 rvi[i].max_speed = speed; |
243 rvi[i].max_speed = speed; |
245 } |
244 } |
246 } break; |
245 break; |
247 case 0x0B: { /* Power */ |
246 |
|
247 case 0x0B: /* Power */ |
248 FOR_EACH_OBJECT { |
248 FOR_EACH_OBJECT { |
249 uint16 power = grf_load_word(&buf); |
249 uint16 power = grf_load_word(&buf); |
250 |
250 |
251 if (rvi[i].flags & RVI_MULTIHEAD) power /= 2; |
251 if (rvi[i].flags & RVI_MULTIHEAD) power /= 2; |
252 |
252 |
253 rvi[i].power = power; |
253 rvi[i].power = power; |
254 dewagonize(power, engine + i); |
254 dewagonize(power, engine + i); |
255 } |
255 } |
256 } break; |
256 break; |
257 case 0x0D: { /* Running cost factor */ |
257 |
|
258 case 0x0D: /* Running cost factor */ |
258 FOR_EACH_OBJECT { |
259 FOR_EACH_OBJECT { |
259 uint8 runcostfact = grf_load_byte(&buf); |
260 uint8 runcostfact = grf_load_byte(&buf); |
260 |
261 |
261 if (rvi[i].flags & RVI_MULTIHEAD) runcostfact /= 2; |
262 if (rvi[i].flags & RVI_MULTIHEAD) runcostfact /= 2; |
262 |
263 |
263 rvi[i].running_cost_base = runcostfact; |
264 rvi[i].running_cost_base = runcostfact; |
264 } |
265 } |
265 } break; |
266 break; |
266 case 0x0E: { /* Running cost base */ |
267 |
|
268 case 0x0E: /* Running cost base */ |
267 FOR_EACH_OBJECT { |
269 FOR_EACH_OBJECT { |
268 uint32 base = grf_load_dword(&buf); |
270 uint32 base = grf_load_dword(&buf); |
269 |
271 |
270 switch (base) { |
272 switch (base) { |
271 case 0x4C30: rvi[i].running_cost_class = 0; break; |
273 case 0x4C30: rvi[i].running_cost_class = 0; break; |
272 case 0x4C36: rvi[i].running_cost_class = 1; break; |
274 case 0x4C36: rvi[i].running_cost_class = 1; break; |
273 case 0x4C3C: rvi[i].running_cost_class = 2; break; |
275 case 0x4C3C: rvi[i].running_cost_class = 2; break; |
274 } |
276 } |
275 } |
277 } |
276 } break; |
278 break; |
277 case 0x12: { /* Sprite ID */ |
279 |
|
280 case 0x12: /* Sprite ID */ |
278 FOR_EACH_OBJECT { |
281 FOR_EACH_OBJECT { |
279 uint8 spriteid = grf_load_byte(&buf); |
282 uint8 spriteid = grf_load_byte(&buf); |
280 |
283 |
281 /* TTD sprite IDs point to a location in a 16bit array, but we use it |
284 /* TTD sprite IDs point to a location in a 16bit array, but we use it |
282 * as an array index, so we need it to be half the original value. */ |
285 * as an array index, so we need it to be half the original value. */ |
283 if (spriteid < 0xFD) spriteid >>= 1; |
286 if (spriteid < 0xFD) spriteid >>= 1; |
284 |
287 |
285 rvi[i].image_index = spriteid; |
288 rvi[i].image_index = spriteid; |
286 } |
289 } |
287 } break; |
290 break; |
288 case 0x13: { /* Dual-headed */ |
291 |
|
292 case 0x13: /* Dual-headed */ |
289 FOR_EACH_OBJECT { |
293 FOR_EACH_OBJECT { |
290 uint8 dual = grf_load_byte(&buf); |
294 uint8 dual = grf_load_byte(&buf); |
291 |
295 |
292 if (dual != 0) { |
296 if (dual != 0) { |
293 if (!(rvi[i].flags & RVI_MULTIHEAD)) { |
297 if (!(rvi[i].flags & RVI_MULTIHEAD)) { |
303 rvi[i].running_cost_base *= 2; |
307 rvi[i].running_cost_base *= 2; |
304 } |
308 } |
305 rvi[i].flags &= ~RVI_MULTIHEAD; |
309 rvi[i].flags &= ~RVI_MULTIHEAD; |
306 } |
310 } |
307 } |
311 } |
308 } break; |
312 break; |
309 case 0x14: { /* Cargo capacity */ |
313 |
310 FOR_EACH_OBJECT { |
314 case 0x14: /* Cargo capacity */ |
311 uint8 capacity = grf_load_byte(&buf); |
315 FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf); |
312 |
316 break; |
313 rvi[i].capacity = capacity; |
317 |
314 } |
318 case 0x15: /* Cargo type */ |
315 } break; |
|
316 case 0x15: { /* Cargo type */ |
|
317 FOR_EACH_OBJECT { |
319 FOR_EACH_OBJECT { |
318 uint8 ctype = grf_load_byte(&buf); |
320 uint8 ctype = grf_load_byte(&buf); |
319 |
321 |
320 if (ctype < NUM_CARGO) { |
322 if (ctype < NUM_CARGO) { |
321 rvi[i].cargo_type = ctype; |
323 rvi[i].cargo_type = ctype; |
322 } else { |
324 } else { |
323 grfmsg(GMS_NOTICE, "RailVehicleChangeInfo: Invalid cargo type %d, ignoring.", ctype); |
325 grfmsg(GMS_NOTICE, "RailVehicleChangeInfo: Invalid cargo type %d, ignoring.", ctype); |
324 } |
326 } |
325 } |
327 } |
326 } break; |
328 break; |
327 case 0x16: { /* Weight */ |
329 |
328 FOR_EACH_OBJECT { |
330 case 0x16: /* Weight */ |
329 uint8 weight = grf_load_byte(&buf); |
331 FOR_EACH_OBJECT SB(rvi[i].weight, 0, 8, grf_load_byte(&buf)); |
330 |
332 break; |
331 SB(rvi[i].weight, 0, 8, weight); |
333 |
332 } |
334 case 0x17: /* Cost factor */ |
333 } break; |
335 FOR_EACH_OBJECT rvi[i].base_cost = grf_load_byte(&buf); |
334 case 0x17: { /* Cost factor */ |
336 break; |
335 FOR_EACH_OBJECT { |
337 |
336 uint8 cfactor = grf_load_byte(&buf); |
338 case 0x18: /* AI rank */ |
337 |
339 FOR_EACH_OBJECT rvi[i].ai_rank = grf_load_byte(&buf); |
338 rvi[i].base_cost = cfactor; |
340 break; |
339 } |
341 |
340 } break; |
342 case 0x19: /* Engine traction type */ |
341 |
|
342 case 0x18: // AI rank |
|
343 FOR_EACH_OBJECT { |
|
344 rvi[i].ai_rank = grf_load_byte(&buf); |
|
345 } |
|
346 break; |
|
347 |
|
348 case 0x19: { /* Engine traction type */ |
|
349 /* What do the individual numbers mean? |
343 /* What do the individual numbers mean? |
350 * 0x00 .. 0x07: Steam |
344 * 0x00 .. 0x07: Steam |
351 * 0x08 .. 0x27: Diesel |
345 * 0x08 .. 0x27: Diesel |
352 * 0x28 .. 0x31: Electric |
346 * 0x28 .. 0x31: Electric |
353 * 0x32 .. 0x37: Monorail |
347 * 0x32 .. 0x37: Monorail |
380 grfmsg(GMS_NOTICE, "RailVehicleChangeInfo: Invalid train engine ID %d, ignoring.", pos); |
375 grfmsg(GMS_NOTICE, "RailVehicleChangeInfo: Invalid train engine ID %d, ignoring.", pos); |
381 } |
376 } |
382 } |
377 } |
383 break; |
378 break; |
384 |
379 |
385 case 0x1B: { /* Powered wagons power bonus */ |
380 case 0x1B: /* Powered wagons power bonus */ |
386 FOR_EACH_OBJECT { |
381 FOR_EACH_OBJECT rvi[i].pow_wag_power = grf_load_word(&buf); |
387 uint16 wag_power = grf_load_word(&buf); |
382 break; |
388 |
383 |
389 rvi[i].pow_wag_power = wag_power; |
384 case 0x1D: /* Refit cargo */ |
390 } |
385 FOR_EACH_OBJECT _engine_info[engine + i].refit_mask = grf_load_dword(&buf); |
391 } break; |
386 break; |
392 case 0x1D: { /* Refit cargo */ |
387 |
393 FOR_EACH_OBJECT { |
388 case 0x1E: /* Callback */ |
394 uint32 refit_mask = grf_load_dword(&buf); |
389 FOR_EACH_OBJECT rvi[i].callbackmask = grf_load_byte(&buf); |
395 |
390 break; |
396 _engine_info[engine + i].refit_mask = refit_mask; |
391 |
397 } |
392 case 0x21: /* Shorter vehicle */ |
398 } break; |
393 FOR_EACH_OBJECT rvi[i].shorten_factor = grf_load_byte(&buf); |
399 case 0x1E: { /* Callback */ |
394 break; |
400 FOR_EACH_OBJECT { |
395 |
401 byte callbacks = grf_load_byte(&buf); |
396 case 0x22: /* Visual effect */ |
402 |
|
403 rvi[i].callbackmask = callbacks; |
|
404 } |
|
405 } break; |
|
406 case 0x21: { /* Shorter vehicle */ |
|
407 FOR_EACH_OBJECT { |
|
408 byte shorten_factor = grf_load_byte(&buf); |
|
409 |
|
410 rvi[i].shorten_factor = shorten_factor; |
|
411 } |
|
412 } break; |
|
413 case 0x22: { /* Visual effect */ |
|
414 // see note in engine.h about rvi->visual_effect |
397 // see note in engine.h about rvi->visual_effect |
415 FOR_EACH_OBJECT { |
398 FOR_EACH_OBJECT rvi[i].visual_effect = grf_load_byte(&buf); |
416 byte visual = grf_load_byte(&buf); |
399 break; |
417 |
400 |
418 rvi[i].visual_effect = visual; |
401 case 0x23: /* Powered wagons weight bonus */ |
419 } |
402 FOR_EACH_OBJECT rvi[i].pow_wag_weight = grf_load_byte(&buf); |
420 } break; |
403 break; |
421 case 0x23: { /* Powered wagons weight bonus */ |
404 |
422 FOR_EACH_OBJECT { |
405 case 0x24: /* High byte of vehicle weight */ |
423 byte wag_weight = grf_load_byte(&buf); |
|
424 |
|
425 rvi[i].pow_wag_weight = wag_weight; |
|
426 } |
|
427 } break; |
|
428 case 0x24: { /* High byte of vehicle weight */ |
|
429 FOR_EACH_OBJECT { |
406 FOR_EACH_OBJECT { |
430 byte weight = grf_load_byte(&buf); |
407 byte weight = grf_load_byte(&buf); |
431 |
408 |
432 if (weight > 4) { |
409 if (weight > 4) { |
433 grfmsg(GMS_NOTICE, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring.", weight << 8); |
410 grfmsg(GMS_NOTICE, "RailVehicleChangeInfo: Nonsensical weight of %d tons, ignoring.", weight << 8); |
434 } else { |
411 } else { |
435 SB(rvi[i].weight, 8, 8, weight); |
412 SB(rvi[i].weight, 8, 8, weight); |
436 } |
413 } |
437 } |
414 } |
438 } break; |
415 break; |
439 case 0x28: { /* Cargo classes allowed */ |
416 |
440 FOR_EACH_OBJECT { |
417 case 0x28: /* Cargo classes allowed */ |
441 cargo_allowed[engine + i] = grf_load_word(&buf); |
418 FOR_EACH_OBJECT cargo_allowed[engine + i] = grf_load_word(&buf); |
442 } |
419 break; |
443 } break; |
420 |
444 case 0x29: { /* Cargo classes disallowed */ |
421 case 0x29: /* Cargo classes disallowed */ |
445 FOR_EACH_OBJECT { |
422 FOR_EACH_OBJECT cargo_disallowed[engine + i] = grf_load_word(&buf); |
446 cargo_disallowed[engine + i] = grf_load_word(&buf); |
423 break; |
447 } |
424 |
448 } break; |
|
449 /* TODO */ |
425 /* TODO */ |
450 /* Fall-through for unimplemented one byte long properties. */ |
426 /* Fall-through for unimplemented one byte long properties. */ |
451 case 0x1C: /* Refit cost */ |
427 case 0x1C: /* Refit cost */ |
452 case 0x1F: /* Tractive effort */ |
428 case 0x1F: /* Tractive effort */ |
453 case 0x20: /* Air drag */ |
429 case 0x20: /* Air drag */ |
454 case 0x25: /* User-defined bit mask to set when checking veh. var. 42 */ |
430 case 0x25: /* User-defined bit mask to set when checking veh. var. 42 */ |
455 case 0x26: /* Retire vehicle early */ |
431 case 0x26: /* Retire vehicle early */ |
456 case 0x27: /* Miscellaneous flags */ |
432 case 0x27: /* Miscellaneous flags */ |
457 { |
|
458 /* TODO */ |
433 /* TODO */ |
459 FOR_EACH_OBJECT { |
434 FOR_EACH_OBJECT grf_load_byte(&buf); |
460 grf_load_byte(&buf); |
|
461 } |
|
462 ret = true; |
435 ret = true; |
463 } break; |
436 break; |
|
437 |
464 default: |
438 default: |
465 ret = true; |
439 ret = true; |
|
440 break; |
466 } |
441 } |
467 *bufp = buf; |
442 *bufp = buf; |
468 return ret; |
443 return ret; |
469 } |
444 } |
470 |
445 |
474 byte *buf = *bufp; |
449 byte *buf = *bufp; |
475 int i; |
450 int i; |
476 bool ret = false; |
451 bool ret = false; |
477 |
452 |
478 switch (prop) { |
453 switch (prop) { |
479 case 0x08: { /* Speed */ |
454 case 0x08: /* Speed */ |
480 FOR_EACH_OBJECT { |
455 FOR_EACH_OBJECT rvi[i].max_speed = grf_load_byte(&buf); // ?? units |
481 uint8 speed = grf_load_byte(&buf); |
456 break; |
482 |
457 |
483 rvi[i].max_speed = speed; // ?? units |
458 case 0x09: /* Running cost factor */ |
484 } |
459 FOR_EACH_OBJECT rvi[i].running_cost = grf_load_byte(&buf); |
485 } break; |
460 break; |
486 case 0x09: { /* Running cost factor */ |
461 |
487 FOR_EACH_OBJECT { |
462 case 0x0A: /* Running cost base */ |
488 uint8 runcost = grf_load_byte(&buf); |
|
489 |
|
490 rvi[i].running_cost = runcost; |
|
491 } |
|
492 } break; |
|
493 case 0x0A: { /* Running cost base */ |
|
494 /* TODO: I have no idea. --pasky */ |
463 /* TODO: I have no idea. --pasky */ |
495 FOR_EACH_OBJECT { |
464 FOR_EACH_OBJECT grf_load_dword(&buf); |
496 grf_load_dword(&buf); |
|
497 } |
|
498 ret = true; |
465 ret = true; |
499 } break; |
466 break; |
500 case 0x0E: { /* Sprite ID */ |
467 |
|
468 case 0x0E: /* Sprite ID */ |
501 FOR_EACH_OBJECT { |
469 FOR_EACH_OBJECT { |
502 uint8 spriteid = grf_load_byte(&buf); |
470 uint8 spriteid = grf_load_byte(&buf); |
503 |
471 |
504 // cars have different custom id in the GRF file |
472 // cars have different custom id in the GRF file |
505 if (spriteid == 0xFF) spriteid = 0xFD; |
473 if (spriteid == 0xFF) spriteid = 0xFD; |
506 |
474 |
507 if (spriteid < 0xFD) spriteid >>= 1; |
475 if (spriteid < 0xFD) spriteid >>= 1; |
508 |
476 |
509 rvi[i].image_index = spriteid; |
477 rvi[i].image_index = spriteid; |
510 } |
478 } |
511 } break; |
479 break; |
512 case 0x0F: { /* Cargo capacity */ |
480 |
513 FOR_EACH_OBJECT { |
481 case 0x0F: /* Cargo capacity */ |
514 uint16 capacity = grf_load_byte(&buf); |
482 FOR_EACH_OBJECT rvi[i].capacity = grf_load_byte(&buf); |
515 |
483 break; |
516 rvi[i].capacity = capacity; |
484 |
517 } |
485 case 0x10: /* Cargo type */ |
518 } break; |
|
519 case 0x10: { /* Cargo type */ |
|
520 FOR_EACH_OBJECT { |
486 FOR_EACH_OBJECT { |
521 uint8 cargo = grf_load_byte(&buf); |
487 uint8 cargo = grf_load_byte(&buf); |
522 |
488 |
523 if (cargo < NUM_CARGO) { |
489 if (cargo < NUM_CARGO) { |
524 rvi[i].cargo_type = cargo; |
490 rvi[i].cargo_type = cargo; |
525 } else { |
491 } else { |
526 grfmsg(GMS_NOTICE, "RoadVehicleChangeInfo: Invalid cargo type %d, ignoring.", cargo); |
492 grfmsg(GMS_NOTICE, "RoadVehicleChangeInfo: Invalid cargo type %d, ignoring.", cargo); |
527 } |
493 } |
528 } |
494 } |
529 } break; |
495 break; |
530 case 0x11: { /* Cost factor */ |
496 |
531 FOR_EACH_OBJECT { |
497 case 0x11: /* Cost factor */ |
532 uint8 cost_factor = grf_load_byte(&buf); |
498 FOR_EACH_OBJECT rvi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost? |
533 |
499 break; |
534 rvi[i].base_cost = cost_factor; // ?? is it base_cost? |
500 |
535 } |
501 case 0x12: /* SFX */ |
536 } break; |
502 FOR_EACH_OBJECT rvi[i].sfx = grf_load_byte(&buf); |
537 case 0x12: { /* SFX */ |
503 break; |
538 FOR_EACH_OBJECT { |
504 |
539 uint8 sfx = grf_load_byte(&buf); |
505 case 0x13: /* Power in 10hp */ |
540 |
506 case 0x14: /* Weight in 1/4 tons */ |
541 rvi[i].sfx = sfx; |
507 case 0x15: /* Speed in mph*0.8 */ |
542 } |
|
543 } break; |
|
544 case 0x13: /* Power in 10hp */ |
|
545 case 0x14: /* Weight in 1/4 tons */ |
|
546 case 0x15: /* Speed in mph*0.8 */ |
|
547 /* TODO: Support for road vehicles realistic power |
508 /* TODO: Support for road vehicles realistic power |
548 * computations (called rvpower in TTDPatch) is just |
509 * computations (called rvpower in TTDPatch) is just |
549 * missing in OTTD yet. --pasky */ |
510 * missing in OTTD yet. --pasky */ |
550 FOR_EACH_OBJECT { |
511 FOR_EACH_OBJECT grf_load_byte(&buf); |
551 grf_load_byte(&buf); |
|
552 } |
|
553 ret = true; |
512 ret = true; |
554 break; |
513 break; |
555 case 0x16: { /* Cargos available for refitting */ |
514 |
556 FOR_EACH_OBJECT { |
515 case 0x16: /* Cargos available for refitting */ |
557 uint32 refit_mask = grf_load_dword(&buf); |
516 FOR_EACH_OBJECT _engine_info[ROAD_ENGINES_INDEX + engine + i].refit_mask = grf_load_dword(&buf); |
558 |
517 break; |
559 _engine_info[ROAD_ENGINES_INDEX + engine + i].refit_mask = refit_mask; |
518 |
560 } |
519 case 0x17: /* Callback mask */ |
561 } break; |
520 FOR_EACH_OBJECT rvi[i].callbackmask = grf_load_byte(&buf); |
562 |
521 break; |
563 case 0x17: // Callback mask |
522 |
564 FOR_EACH_OBJECT { |
523 case 0x1D: /* Cargo classes allowed */ |
565 rvi[i].callbackmask = grf_load_byte(&buf); |
524 FOR_EACH_OBJECT cargo_allowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
566 } |
525 break; |
567 break; |
526 |
568 |
527 case 0x1E: /* Cargo classes disallowed */ |
569 case 0x1D: { /* Cargo classes allowed */ |
528 FOR_EACH_OBJECT cargo_disallowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
570 FOR_EACH_OBJECT { |
529 break; |
571 cargo_allowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
530 |
572 } |
531 case 0x18: /* Tractive effort */ |
573 } break; |
532 case 0x19: /* Air drag */ |
574 case 0x1E: { /* Cargo classes disallowed */ |
533 case 0x1A: /* Refit cost */ |
575 FOR_EACH_OBJECT { |
534 case 0x1B: /* Retire vehicle early */ |
576 cargo_disallowed[ROAD_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
535 case 0x1C: /* Miscellaneous flags */ |
577 } |
|
578 } break; |
|
579 case 0x18: /* Tractive effort */ |
|
580 case 0x19: /* Air drag */ |
|
581 case 0x1A: /* Refit cost */ |
|
582 case 0x1B: /* Retire vehicle early */ |
|
583 case 0x1C: /* Miscellaneous flags */ |
|
584 { |
|
585 /* TODO */ |
536 /* TODO */ |
586 FOR_EACH_OBJECT { |
537 FOR_EACH_OBJECT grf_load_byte(&buf); |
587 grf_load_byte(&buf); |
|
588 } |
|
589 ret = true; |
538 ret = true; |
590 break; |
539 break; |
591 } |
540 |
592 default: |
541 default: |
593 ret = true; |
542 ret = true; |
|
543 break; |
594 } |
544 } |
595 |
545 |
596 *bufp = buf; |
546 *bufp = buf; |
597 return ret; |
547 return ret; |
598 } |
548 } |
604 int i; |
554 int i; |
605 bool ret = false; |
555 bool ret = false; |
606 |
556 |
607 //printf("e %x prop %x?\n", engine, prop); |
557 //printf("e %x prop %x?\n", engine, prop); |
608 switch (prop) { |
558 switch (prop) { |
609 case 0x08: { /* Sprite ID */ |
559 case 0x08: /* Sprite ID */ |
610 FOR_EACH_OBJECT { |
560 FOR_EACH_OBJECT { |
611 uint8 spriteid = grf_load_byte(&buf); |
561 uint8 spriteid = grf_load_byte(&buf); |
612 |
562 |
613 // ships have different custom id in the GRF file |
563 // ships have different custom id in the GRF file |
614 if (spriteid == 0xFF) spriteid = 0xFD; |
564 if (spriteid == 0xFF) spriteid = 0xFD; |
615 |
565 |
616 if (spriteid < 0xFD) spriteid >>= 1; |
566 if (spriteid < 0xFD) spriteid >>= 1; |
617 |
567 |
618 svi[i].image_index = spriteid; |
568 svi[i].image_index = spriteid; |
619 } |
569 } |
620 } break; |
570 break; |
621 case 0x09: { /* Refittable */ |
571 |
622 FOR_EACH_OBJECT { |
572 case 0x09: /* Refittable */ |
623 uint8 refittable = grf_load_byte(&buf); |
573 FOR_EACH_OBJECT svi[i].refittable = grf_load_byte(&buf); |
624 |
574 break; |
625 svi[i].refittable = refittable; |
575 |
626 } |
576 case 0x0A: /* Cost factor */ |
627 } break; |
577 FOR_EACH_OBJECT svi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost? |
628 case 0x0A: { /* Cost factor */ |
578 break; |
629 FOR_EACH_OBJECT { |
579 |
630 uint8 cost_factor = grf_load_byte(&buf); |
580 case 0x0B: /* Speed */ |
631 |
581 FOR_EACH_OBJECT svi[i].max_speed = grf_load_byte(&buf); // ?? units |
632 svi[i].base_cost = cost_factor; // ?? is it base_cost? |
582 break; |
633 } |
583 |
634 } break; |
584 case 0x0C: /* Cargo type */ |
635 case 0x0B: { /* Speed */ |
|
636 FOR_EACH_OBJECT { |
|
637 uint8 speed = grf_load_byte(&buf); |
|
638 |
|
639 svi[i].max_speed = speed; // ?? units |
|
640 } |
|
641 } break; |
|
642 case 0x0C: { /* Cargo type */ |
|
643 FOR_EACH_OBJECT { |
585 FOR_EACH_OBJECT { |
644 uint8 cargo = grf_load_byte(&buf); |
586 uint8 cargo = grf_load_byte(&buf); |
645 |
587 |
646 // XXX: Need to consult this with patchman yet. |
588 // XXX: Need to consult this with patchman yet. |
647 #if 0 |
589 #if 0 |
654 svi[i].cargo_type = cargo; |
596 svi[i].cargo_type = cargo; |
655 } else { |
597 } else { |
656 grfmsg(GMS_NOTICE, "ShipVehicleChangeInfo: Invalid cargo type %d, ignoring.", cargo); |
598 grfmsg(GMS_NOTICE, "ShipVehicleChangeInfo: Invalid cargo type %d, ignoring.", cargo); |
657 } |
599 } |
658 } |
600 } |
659 } break; |
601 break; |
660 case 0x0D: { /* Cargo capacity */ |
602 |
661 FOR_EACH_OBJECT { |
603 case 0x0D: /* Cargo capacity */ |
662 uint16 capacity = grf_load_word(&buf); |
604 FOR_EACH_OBJECT svi[i].capacity = grf_load_word(&buf); |
663 |
605 break; |
664 svi[i].capacity = capacity; |
606 |
665 } |
607 case 0x0F: /* Running cost factor */ |
666 } break; |
608 FOR_EACH_OBJECT svi[i].running_cost = grf_load_byte(&buf); |
667 case 0x0F: { /* Running cost factor */ |
609 break; |
668 FOR_EACH_OBJECT { |
610 |
669 uint8 runcost = grf_load_byte(&buf); |
611 case 0x10: /* SFX */ |
670 |
612 FOR_EACH_OBJECT svi[i].sfx = grf_load_byte(&buf); |
671 svi[i].running_cost = runcost; |
613 break; |
672 } |
614 |
673 } break; |
615 case 0x11: /* Cargos available for refitting */ |
674 case 0x10: { /* SFX */ |
616 FOR_EACH_OBJECT _engine_info[SHIP_ENGINES_INDEX + engine + i].refit_mask = grf_load_dword(&buf); |
675 FOR_EACH_OBJECT { |
617 break; |
676 uint8 sfx = grf_load_byte(&buf); |
618 |
677 |
619 case 0x12: /* Callback mask */ |
678 svi[i].sfx = sfx; |
620 FOR_EACH_OBJECT svi[i].callbackmask = grf_load_byte(&buf); |
679 } |
621 break; |
680 } break; |
622 |
681 case 0x11: { /* Cargos available for refitting */ |
623 case 0x18: /* Cargo classes allowed */ |
682 FOR_EACH_OBJECT { |
624 FOR_EACH_OBJECT cargo_allowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
683 uint32 refit_mask = grf_load_dword(&buf); |
625 break; |
684 |
626 |
685 _engine_info[SHIP_ENGINES_INDEX + engine + i].refit_mask = refit_mask; |
627 case 0x19: /* Cargo classes disallowed */ |
686 } |
628 FOR_EACH_OBJECT cargo_disallowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
687 } break; |
629 break; |
688 |
630 |
689 case 0x12: // Callback mask |
|
690 FOR_EACH_OBJECT { |
|
691 svi[i].callbackmask = grf_load_byte(&buf); |
|
692 } |
|
693 break; |
|
694 |
|
695 case 0x18: { /* Cargo classes allowed */ |
|
696 FOR_EACH_OBJECT { |
|
697 cargo_allowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
|
698 } |
|
699 } break; |
|
700 case 0x19: { /* Cargo classes disallowed */ |
|
701 FOR_EACH_OBJECT { |
|
702 cargo_disallowed[SHIP_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
|
703 } |
|
704 } break; |
|
705 case 0x13: /* Refit cost */ |
631 case 0x13: /* Refit cost */ |
706 case 0x14: /* Ocean speed fraction */ |
632 case 0x14: /* Ocean speed fraction */ |
707 case 0x15: /* Canal speed fraction */ |
633 case 0x15: /* Canal speed fraction */ |
708 case 0x16: /* Retire vehicle early */ |
634 case 0x16: /* Retire vehicle early */ |
709 case 0x17: /* Miscellaneous flags */ |
635 case 0x17: /* Miscellaneous flags */ |
710 { |
|
711 /* TODO */ |
636 /* TODO */ |
712 FOR_EACH_OBJECT { |
637 FOR_EACH_OBJECT grf_load_byte(&buf); |
713 grf_load_byte(&buf); |
|
714 } |
|
715 ret = true; |
638 ret = true; |
716 } break; |
639 break; |
|
640 |
717 default: |
641 default: |
718 ret = true; |
642 ret = true; |
|
643 break; |
719 } |
644 } |
720 |
645 |
721 *bufp = buf; |
646 *bufp = buf; |
722 return ret; |
647 return ret; |
723 } |
648 } |
729 int i; |
654 int i; |
730 bool ret = false; |
655 bool ret = false; |
731 |
656 |
732 //printf("e %x prop %x?\n", engine, prop); |
657 //printf("e %x prop %x?\n", engine, prop); |
733 switch (prop) { |
658 switch (prop) { |
734 case 0x08: { /* Sprite ID */ |
659 case 0x08: /* Sprite ID */ |
735 FOR_EACH_OBJECT { |
660 FOR_EACH_OBJECT { |
736 uint8 spriteid = grf_load_byte(&buf); |
661 uint8 spriteid = grf_load_byte(&buf); |
737 |
662 |
738 // aircraft have different custom id in the GRF file |
663 // aircraft have different custom id in the GRF file |
739 if (spriteid == 0xFF) spriteid = 0xFD; |
664 if (spriteid == 0xFF) spriteid = 0xFD; |
740 |
665 |
741 if (spriteid < 0xFD) spriteid >>= 1; |
666 if (spriteid < 0xFD) spriteid >>= 1; |
742 |
667 |
743 avi[i].image_index = spriteid; |
668 avi[i].image_index = spriteid; |
744 } |
669 } |
745 } break; |
670 break; |
746 case 0x09: { /* Helicopter */ |
671 |
747 FOR_EACH_OBJECT { |
672 case 0x09: /* Helicopter */ |
748 uint8 heli = grf_load_byte(&buf); |
673 FOR_EACH_OBJECT SB(avi[i].subtype, 0, 1, (grf_load_byte(&buf) != 0 ? 1 : 0)); |
749 avi[i].subtype &= ~0x01; // remove old property |
674 break; |
750 avi[i].subtype |= (heli == 0) ? 0 : 1; |
675 |
751 } |
676 case 0x0A: /* Large */ |
752 } break; |
677 FOR_EACH_OBJECT SB(avi[i].subtype, 1, 1, (grf_load_byte(&buf) != 0 ? 1 : 0)); |
753 case 0x0A: { /* Large */ |
678 break; |
754 FOR_EACH_OBJECT { |
679 |
755 uint8 large = grf_load_byte(&buf); |
680 case 0x0B: /* Cost factor */ |
756 avi[i].subtype &= ~0x02; // remove old property |
681 FOR_EACH_OBJECT avi[i].base_cost = grf_load_byte(&buf); // ?? is it base_cost? |
757 avi[i].subtype |= (large == 1) ? 2 : 0; |
682 break; |
758 } |
683 |
759 } break; |
684 case 0x0C: /* Speed */ |
760 case 0x0B: { /* Cost factor */ |
685 FOR_EACH_OBJECT avi[i].max_speed = grf_load_byte(&buf); // ?? units |
761 FOR_EACH_OBJECT { |
686 break; |
762 uint8 cost_factor = grf_load_byte(&buf); |
687 |
763 |
688 case 0x0D: /* Acceleration */ |
764 avi[i].base_cost = cost_factor; // ?? is it base_cost? |
689 FOR_EACH_OBJECT avi[i].acceleration = grf_load_byte(&buf); |
765 } |
690 break; |
766 } break; |
691 |
767 case 0x0C: { /* Speed */ |
692 case 0x0E: /* Running cost factor */ |
768 FOR_EACH_OBJECT { |
693 FOR_EACH_OBJECT avi[i].running_cost = grf_load_byte(&buf); |
769 uint8 speed = grf_load_byte(&buf); |
694 break; |
770 |
695 |
771 avi[i].max_speed = speed; // ?? units |
696 case 0x0F: /* Passenger capacity */ |
772 } |
697 FOR_EACH_OBJECT avi[i].passenger_capacity = grf_load_word(&buf); |
773 } break; |
698 break; |
774 case 0x0D: { /* Acceleration */ |
699 |
775 FOR_EACH_OBJECT { |
700 case 0x11: /* Mail capacity */ |
776 uint8 accel = grf_load_byte(&buf); |
701 FOR_EACH_OBJECT avi[i].mail_capacity = grf_load_byte(&buf); |
777 |
702 break; |
778 avi[i].acceleration = accel; |
703 |
779 } |
704 case 0x12: /* SFX */ |
780 } break; |
705 FOR_EACH_OBJECT avi[i].sfx = grf_load_byte(&buf); |
781 case 0x0E: { /* Running cost factor */ |
706 break; |
782 FOR_EACH_OBJECT { |
707 |
783 uint8 runcost = grf_load_byte(&buf); |
708 case 0x13: /* Cargos available for refitting */ |
784 |
709 FOR_EACH_OBJECT _engine_info[AIRCRAFT_ENGINES_INDEX + engine + i].refit_mask = grf_load_dword(&buf); |
785 avi[i].running_cost = runcost; |
710 break; |
786 } |
711 |
787 } break; |
712 case 0x14: /* Callback mask */ |
788 case 0x0F: { /* Passenger capacity */ |
713 FOR_EACH_OBJECT avi[i].callbackmask = grf_load_byte(&buf); |
789 FOR_EACH_OBJECT { |
714 break; |
790 uint16 capacity = grf_load_word(&buf); |
715 |
791 |
716 case 0x18: /* Cargo classes allowed */ |
792 avi[i].passenger_capacity = capacity; |
717 FOR_EACH_OBJECT cargo_allowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
793 } |
718 break; |
794 } break; |
719 |
795 case 0x11: { /* Mail capacity */ |
720 case 0x19: /* Cargo classes disallowed */ |
796 FOR_EACH_OBJECT { |
721 FOR_EACH_OBJECT cargo_disallowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
797 uint8 capacity = grf_load_byte(&buf); |
722 break; |
798 |
723 |
799 avi[i].mail_capacity = capacity; |
|
800 } |
|
801 } break; |
|
802 case 0x12: { /* SFX */ |
|
803 FOR_EACH_OBJECT { |
|
804 uint8 sfx = grf_load_byte(&buf); |
|
805 |
|
806 avi[i].sfx = sfx; |
|
807 } |
|
808 } break; |
|
809 case 0x13: { /* Cargos available for refitting */ |
|
810 FOR_EACH_OBJECT { |
|
811 uint32 refit_mask = grf_load_dword(&buf); |
|
812 |
|
813 _engine_info[AIRCRAFT_ENGINES_INDEX + engine + i].refit_mask = refit_mask; |
|
814 } |
|
815 } break; |
|
816 |
|
817 case 0x14: // Callback mask |
|
818 FOR_EACH_OBJECT { |
|
819 avi[i].callbackmask = grf_load_byte(&buf); |
|
820 } |
|
821 break; |
|
822 |
|
823 case 0x18: { /* Cargo classes allowed */ |
|
824 FOR_EACH_OBJECT { |
|
825 cargo_allowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
|
826 } |
|
827 } break; |
|
828 case 0x19: { /* Cargo classes disallowed */ |
|
829 FOR_EACH_OBJECT { |
|
830 cargo_disallowed[AIRCRAFT_ENGINES_INDEX + engine + i] = grf_load_word(&buf); |
|
831 } |
|
832 } break; |
|
833 case 0x15: /* Refit cost */ |
724 case 0x15: /* Refit cost */ |
834 case 0x16: /* Retire vehicle early */ |
725 case 0x16: /* Retire vehicle early */ |
835 case 0x17: /* Miscellaneous flags */ |
726 case 0x17: /* Miscellaneous flags */ |
836 { |
|
837 /* TODO */ |
727 /* TODO */ |
838 FOR_EACH_OBJECT { |
728 FOR_EACH_OBJECT grf_load_byte(&buf); |
839 grf_load_byte(&buf); |
|
840 } |
|
841 ret = true; |
729 ret = true; |
842 } break; |
730 break; |
|
731 |
843 default: |
732 default: |
844 ret = true; |
733 ret = true; |
|
734 break; |
845 } |
735 } |
846 |
736 |
847 *bufp = buf; |
737 *bufp = buf; |
848 return ret; |
738 return ret; |
849 } |
739 } |
1094 int i; |
984 int i; |
1095 int ret = 0; |
985 int ret = 0; |
1096 |
986 |
1097 switch (prop) { |
987 switch (prop) { |
1098 case 0x08: /* Year of availability */ |
988 case 0x08: /* Year of availability */ |
1099 FOR_EACH_OBJECT { |
989 FOR_EACH_OBJECT _bridge[brid + i].avail_year = grf_load_byte(&buf); |
1100 _bridge[brid + i].avail_year = grf_load_byte(&buf); |
|
1101 } |
|
1102 break; |
990 break; |
1103 |
991 |
1104 case 0x09: /* Minimum length */ |
992 case 0x09: /* Minimum length */ |
1105 FOR_EACH_OBJECT { |
993 FOR_EACH_OBJECT _bridge[brid + i].min_length = grf_load_byte(&buf); |
1106 _bridge[brid + i].min_length = grf_load_byte(&buf); |
|
1107 } |
|
1108 break; |
994 break; |
1109 |
995 |
1110 case 0x0A: /* Maximum length */ |
996 case 0x0A: /* Maximum length */ |
1111 FOR_EACH_OBJECT { |
997 FOR_EACH_OBJECT _bridge[brid + i].max_length = grf_load_byte(&buf); |
1112 _bridge[brid + i].max_length = grf_load_byte(&buf); |
|
1113 } |
|
1114 break; |
998 break; |
1115 |
999 |
1116 case 0x0B: /* Cost factor */ |
1000 case 0x0B: /* Cost factor */ |
1117 FOR_EACH_OBJECT { |
1001 FOR_EACH_OBJECT _bridge[brid + i].price = grf_load_byte(&buf); |
1118 _bridge[brid + i].price = grf_load_byte(&buf); |
|
1119 } |
|
1120 break; |
1002 break; |
1121 |
1003 |
1122 case 0x0C: /* Maximum speed */ |
1004 case 0x0C: /* Maximum speed */ |
1123 FOR_EACH_OBJECT { |
1005 FOR_EACH_OBJECT _bridge[brid + i].speed = grf_load_word(&buf); |
1124 _bridge[brid + i].speed = grf_load_word(&buf); |
|
1125 } |
|
1126 break; |
1006 break; |
1127 |
1007 |
1128 case 0x0D: /* Bridge sprite tables */ |
1008 case 0x0D: /* Bridge sprite tables */ |
1129 FOR_EACH_OBJECT { |
1009 FOR_EACH_OBJECT { |
1130 Bridge *bridge = &_bridge[brid + i]; |
1010 Bridge *bridge = &_bridge[brid + i]; |
1272 case GSF_ROAD: |
1150 case GSF_ROAD: |
1273 case GSF_SHIP: |
1151 case GSF_SHIP: |
1274 case GSF_AIRCRAFT: |
1152 case GSF_AIRCRAFT: |
1275 /* Common properties for vehicles */ |
1153 /* Common properties for vehicles */ |
1276 switch (prop) { |
1154 switch (prop) { |
1277 case 0x00: { /* Introduction date */ |
1155 case 0x00: /* Introduction date */ |
1278 FOR_EACH_OBJECT { |
1156 FOR_EACH_OBJECT ei[i].base_intro = grf_load_word(&buf); |
1279 uint16 date = grf_load_word(&buf); |
1157 break; |
1280 |
1158 |
1281 ei[i].base_intro = date; |
1159 case 0x02: /* Decay speed */ |
1282 } |
1160 FOR_EACH_OBJECT SB(ei[i].unk2, 0, 7, grf_load_byte(&buf) & 0x7F); |
1283 } break; |
1161 break; |
1284 case 0x02: { /* Decay speed */ |
1162 |
1285 FOR_EACH_OBJECT { |
1163 case 0x03: /* Vehicle life */ |
1286 uint8 decay = grf_load_byte(&buf); |
1164 FOR_EACH_OBJECT ei[i].lifelength = grf_load_byte(&buf); |
1287 |
1165 break; |
1288 ei[i].unk2 &= 0x80; |
1166 |
1289 ei[i].unk2 |= decay & 0x7f; |
1167 case 0x04: /* Model life */ |
1290 } |
1168 FOR_EACH_OBJECT ei[i].base_life = grf_load_byte(&buf); |
1291 } break; |
1169 break; |
1292 case 0x03: { /* Vehicle life */ |
1170 |
1293 FOR_EACH_OBJECT { |
1171 case 0x06: /* Climates available */ |
1294 uint8 life = grf_load_byte(&buf); |
1172 FOR_EACH_OBJECT ei[i].climates = grf_load_byte(&buf); |
1295 |
1173 break; |
1296 ei[i].lifelength = life; |
1174 |
1297 } |
1175 case 0x07: /* Loading speed */ |
1298 } break; |
|
1299 case 0x04: { /* Model life */ |
|
1300 FOR_EACH_OBJECT { |
|
1301 uint8 life = grf_load_byte(&buf); |
|
1302 |
|
1303 ei[i].base_life = life; |
|
1304 } |
|
1305 } break; |
|
1306 case 0x06: { /* Climates available */ |
|
1307 FOR_EACH_OBJECT { |
|
1308 uint8 climates = grf_load_byte(&buf); |
|
1309 |
|
1310 ei[i].climates = climates; |
|
1311 } |
|
1312 } break; |
|
1313 case 0x07: { /* Loading speed */ |
|
1314 /* TODO */ |
1176 /* TODO */ |
1315 /* Hyronymus explained me what does |
1177 /* Hyronymus explained me what does |
1316 * this mean and insists on having a |
1178 * this mean and insists on having a |
1317 * credit ;-). --pasky */ |
1179 * credit ;-). --pasky */ |
1318 /* TODO: This needs to be supported by |
1180 /* TODO: This needs to be supported by |
1319 * LoadUnloadVehicle() first. */ |
1181 * LoadUnloadVehicle() first. */ |
1320 FOR_EACH_OBJECT { |
1182 FOR_EACH_OBJECT grf_load_byte(&buf); |
1321 grf_load_byte(&buf); |
|
1322 } |
|
1323 ignoring = true; |
1183 ignoring = true; |
1324 break; |
1184 break; |
1325 } |
|
1326 |
1185 |
1327 default: |
1186 default: |
1328 if (handler[feature](engine, numinfo, prop, &buf, bufend - buf)) |
1187 if (handler[feature](engine, numinfo, prop, &buf, bufend - buf)) |
1329 ignoring = true; |
1188 ignoring = true; |
1330 break; |
1189 break; |