1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "sprite.h"

     6

#include "variables.h"

     7

#include "debug.h"

     8

     9

    10

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

    11

{

    12

	int i;

    13

    14

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

    15

	value &= dsg->and_mask;

    16

    17

	if (dsg->operation != DSG_OP_NONE)

    18

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

    19

    20

	switch (dsg->operation) {

    21

		case DSG_OP_DIV:

    22

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

    23

			break;

    24

		case DSG_OP_MOD:

    25

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

    26

			break;

    27

		case DSG_OP_NONE:

    28

			break;

    29

	}

    30

    31

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

    32

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

    33

    34

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

    35

			return range->group;

    36

	}

    37

    38

	return dsg->default_group;

    39

}

    40

    41

int GetDeterministicSpriteValue(byte var)

    42

{

    43

	switch (var) {

    44

		case 0x00:

    45

			return _date;

    46

		case 0x01:

    47

			return _cur_year;

    48

		case 0x02:

    49

			return _cur_month;

    50

		case 0x03:

    51

			return _opt.landscape;

    52

		case 0x09:

    53

			return _date_fract;

    54

		case 0x0A:

    55

			return _tick_counter;

    56

		case 0x0C:

    57

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

    58

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

    59

			return 0;

    60

		default:

    61

			return -1;

    62

	}

    63

}

    64

    65

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

    66

{

    67

	byte mask;

    68

	byte index;

    69

    70

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

    71

	 * Sorry. --pasky */

    72

	// rsg->num_groups is always power of 2

    73

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

    74

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

    75

	assert(index < rsg->num_groups);

    76

	return rsg->groups[index];

    77

}

    78

    79

byte RandomizedSpriteGroupTriggeredBits(const RandomizedSpriteGroup *rsg,

    80

	byte triggers, byte *waiting_triggers)

    81

{

    82

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

    83

	bool res;

    84

    85

	if (rsg->cmp_mode == RSG_CMP_ANY) {

    86

		res = (match != 0);

    87

	} else { /* RSG_CMP_ALL */

    88

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

    89

	}

    90

    91

	if (!res) {

    92

		*waiting_triggers |= triggers;

    93

		return 0;

    94

	}

    95

    96

	*waiting_triggers &= ~match;

    97

    98

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

    99

}

   100

   101

/**

   102

 * Traverse a sprite group and release its and its child's memory.

   103

 * A group is only released if its reference count is zero.

   104

 * We pass a pointer to a pointer so that the original reference can be set to NULL.

   105

 * @param group_ptr Pointer to sprite group reference.

   106

 */

   107

void UnloadSpriteGroup(SpriteGroup **group_ptr)

   108

{

   109

	SpriteGroup *group;

   110

	int i;

   111

   112

	assert(group_ptr != NULL);

   113

	assert(*group_ptr != NULL);

   114

   115

	group = *group_ptr;

   116

	*group_ptr = NULL; // Remove this reference.

   117

   118

	group->ref_count--;

   119

	if (group->ref_count > 0) {

   120

		DEBUG(grf, 6)("UnloadSpriteGroup: Group at `%p' (type %d) has %d reference(s) left.", group, group->type, group->ref_count);

   121

		return; // Still some references left, so don't clear up.

   122

	}

   123

   124

	DEBUG(grf, 6)("UnloadSpriteGroup: Releasing group at `%p'.", group);

   125

	switch (group->type) {

   126

		case SGT_REAL:

   127

		{

   128

			RealSpriteGroup *rsg = &group->g.real;

   129

			for (i = 0; i < rsg->loading_count; i++) {

   130

				if (rsg->loading[i] != NULL) UnloadSpriteGroup(&rsg->loading[i]);

   131

			}

   132

			for (i = 0; i < rsg->loaded_count; i++) {

   133

				if (rsg->loaded[i] != NULL) UnloadSpriteGroup(&rsg->loaded[i]);

   134

			}

   135

			free(group);

   136

			return;

   137

		}

   138

   139

		case SGT_DETERMINISTIC:

   140

		{

   141

			DeterministicSpriteGroup *dsg = &group->g.determ;

   142

			for (i = 0; i < group->g.determ.num_ranges; i++) {

   143

				if (dsg->ranges[i].group != NULL) UnloadSpriteGroup(&dsg->ranges[i].group);

   144

			}

   145

			if (dsg->default_group != NULL) UnloadSpriteGroup(&dsg->default_group);

   146

			free(group->g.determ.ranges);

   147

			free(group);

   148

			return;

   149

		}

   150

   151

		case SGT_RANDOMIZED:

   152

		{

   153

			for (i = 0; i < group->g.random.num_groups; i++) {

   154

				if (group->g.random.groups[i] != NULL) UnloadSpriteGroup(&group->g.random.groups[i]);

   155

			}

   156

			free(group->g.random.groups);

   157

			free(group);

   158

			return;

   159

		}

   160

   161

		case SGT_CALLBACK:

   162

		case SGT_RESULT:

   163

			free(group);

   164

			return;

   165

	}

   166

   167

	DEBUG(grf, 1)("Unable to remove unknown sprite group type `0x%x'.", group->type);

   168

}