1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

     5

#include <stdarg.h>

     6

     7

#include "openttd.h"

     8

#include "sprite.h"

     9

#include "variables.h"

    10

    11

    13

{

    14

	int i;

    15

    16

	value >>= dsg->shift_num; // This should bring us to the byte range.

    17

	value &= dsg->and_mask;

    18

    19

	if (dsg->operation != DSG_OP_NONE)

    20

		value += (signed char) dsg->add_val;

    21

    22

	switch (dsg->operation) {

    23

		case DSG_OP_DIV:

    24

			value /= (signed char) dsg->divmod_val;

    25

			break;

    26

		case DSG_OP_MOD:

    27

			value %= (signed char) dsg->divmod_val;

    28

			break;

    29

		case DSG_OP_NONE:

    30

			break;

    31

	}

    32

    33

	for (i = 0; i < dsg->num_ranges; i++) {

    34

		DeterministicSpriteGroupRange *range = &dsg->ranges[i];

    35

    36

		if (range->low <= value && value <= range->high)

    37

			return &range->group;

    38

	}

    39

    40

	return dsg->default_group;

    41

}

    42

    43

int GetDeterministicSpriteValue(byte var)

    44

{

    45

	switch (var) {

    46

		case 0x00:

    47

			return _date;

    48

		case 0x01:

    49

			return _cur_year;

    50

		case 0x02:

    51

			return _cur_month;

    52

		case 0x03:

    53

			return _opt.landscape;

    54

		case 0x09:

    55

			return _date_fract;

    56

		case 0x0A:

    57

			return _tick_counter;

    58

		case 0x0C:

    59

			/* If we got here, it means there was no callback or

    60

			 * callbacks aren't supported on our callpath. */

    61

			return 0;

    62

		default:

    63

			return -1;

    64

	}

    65

}

    66

    68

{

    69

	byte mask;

    70

	byte index;

    71

    72

	/* Noone likes mangling with bits, but you don't get around it here.

    73

	 * Sorry. --pasky */

    74

	// rsg->num_groups is always power of 2

    75

	mask = (rsg->num_groups - 1) << rsg->lowest_randbit;

    76

	index = (random_bits & mask) >> rsg->lowest_randbit;

    77

	assert(index < rsg->num_groups);

    78

	return &rsg->groups[index];

    79

}

    80

    82

	byte triggers, byte *waiting_triggers)

    83

{

    84

	byte match = rsg->triggers & (*waiting_triggers | triggers);

    85

	bool res;

    86

    87

	if (rsg->cmp_mode == RSG_CMP_ANY) {

    88

		res = (match != 0);

    89

	} else { /* RSG_CMP_ALL */

    90

		res = (match == rsg->triggers);

    91

	}

    92

    93

	if (!res) {

    94

		*waiting_triggers |= triggers;

    95

		return 0;

    96

	}

    97

    98

	*waiting_triggers &= ~match;

    99

   100

	return (rsg->num_groups - 1) << rsg->lowest_randbit;

   101

}