1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "sprite.h"

     6

#include "variables.h"

     7

     8

     9

SpriteGroup *EvalDeterministicSpriteGroup(const DeterministicSpriteGroup *dsg, int value)

    10

{

    11

	int i;

    12

    13

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

    14

	value &= dsg->and_mask;

    15

    16

	if (dsg->operation != DSG_OP_NONE)

    17

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

    18

    19

	switch (dsg->operation) {

    20

		case DSG_OP_DIV:

    21

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

    22

			break;

    23

		case DSG_OP_MOD:

    24

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

    25

			break;

    26

		case DSG_OP_NONE:

    27

			break;

    28

	}

    29

    30

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

    31

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

    32

    33

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

    34

			return &range->group;

    35

	}

    36

    37

	return dsg->default_group;

    38

}

    39

    40

int GetDeterministicSpriteValue(byte var)

    41

{

    42

	switch (var) {

    43

		case 0x00:

    44

			return _date;

    45

		case 0x01:

    46

			return _cur_year;

    47

		case 0x02:

    48

			return _cur_month;

    49

		case 0x03:

    50

			return _opt.landscape;

    51

		case 0x09:

    52

			return _date_fract;

    53

		case 0x0A:

    54

			return _tick_counter;

    55

		case 0x0C:

    56

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

    57

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

    58

			return 0;

    59

		default:

    60

			return -1;

    61

	}

    62

}

    63

    64

SpriteGroup *EvalRandomizedSpriteGroup(const RandomizedSpriteGroup *rsg, byte random_bits)

    65

{

    66

	byte mask;

    67

	byte index;

    68

    69

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

    70

	 * Sorry. --pasky */

    71

	// rsg->num_groups is always power of 2

    72

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

    73

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

    74

	assert(index < rsg->num_groups);

    75

	return &rsg->groups[index];

    76

}

    77

    78

byte RandomizedSpriteGroupTriggeredBits(const RandomizedSpriteGroup *rsg,

    79

	byte triggers, byte *waiting_triggers)

    80

{

    81

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

    82

	bool res;

    83

    84

	if (rsg->cmp_mode == RSG_CMP_ANY) {

    85

		res = (match != 0);

    86

	} else { /* RSG_CMP_ALL */

    87

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

    88

	}

    89

    90

	if (!res) {

    91

		*waiting_triggers |= triggers;

    92

		return 0;

    93

	}

    94

    95

	*waiting_triggers &= ~match;

    96

    97

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

    98

}