blob: 1986e460a50da6b100a1e3e706958be1bf675012 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
* File: losparam.h
* Summary: Parameters for the LOS algorithm
*/
#ifndef LOSPARAM_H
#define LOSPARAM_H
// Note: find_ray relies on the fact that 2*OPC_HALF == OPC_OPAQUE.
// On the other hand, losight tracks this explicitly.
enum opacity_type
{
OPC_CLEAR = 0,
OPC_HALF = 1, // for opaque clouds; two or more block
OPC_OPAQUE = 2,
NUM_OPACITIES
};
struct opacity_func
{
virtual opacity_type operator()(const coord_def& p) const = 0;
virtual ~opacity_func() {}
virtual opacity_func* clone() const = 0;
};
struct bounds_func
{
virtual ~bounds_func() {}
virtual bool operator()(const coord_def& p) const = 0;
virtual bounds_func* clone() const = 0;
};
#define CLONE(typename) \
typename* clone() const \
{ \
return (new typename(*this)); \
}
// Default LOS rules.
struct opacity_default : opacity_func
{
CLONE(opacity_default)
opacity_type operator()(const coord_def& p) const;
};
static opacity_default opc_default;
// Default LOS rules, but only consider fully opaque features blocking.
// In particular, clouds don't affect the result.
struct opacity_fullyopaque : opacity_func
{
CLONE(opacity_fullyopaque)
opacity_type operator()(const coord_def& p) const;
};
static opacity_fullyopaque opc_fullyopaque;
// Make anything solid block in addition to normal LOS.
// XXX: Are trees, bushes solid?
struct opacity_solid : opacity_func
{
CLONE(opacity_solid)
opacity_type operator()(const coord_def& p) const;
};
static opacity_solid opc_solid;
// Opacity for monster movement, based on the late monster_los.
struct opacity_monmove : opacity_func
{
const monsters& mon;
opacity_monmove(const monsters& m)
: mon(m)
{
}
CLONE(opacity_monmove)
opacity_type operator()(const coord_def& p) const;
};
// LOS bounded by fixed presquared radius.
struct bounds_radius_sq : bounds_func
{
int radius_sq;
bounds_radius_sq(int r_sq)
: radius_sq(r_sq) {}
CLONE(bounds_radius_sq)
bool operator()(const coord_def& p) const;
};
// LOS bounded by fixed radius.
struct bounds_radius : bounds_radius_sq
{
bounds_radius(int r)
: bounds_radius_sq(r * r + 1)
{
}
CLONE(bounds_radius)
};
static bounds_radius bds_deflos = bounds_radius(LOS_RADIUS);
static bounds_radius bds_maxlos = bounds_radius(LOS_MAX_RADIUS);
// LOS bounded by current global LOS radius.
struct bounds_cur_los_radius : bounds_func
{
CLONE(bounds_cur_los_radius)
bool operator()(const coord_def& p) const;
};
static bounds_cur_los_radius bds_default;
// Subclasses of this are passed to losight() to modify the
// LOS calculation. Implementations will have to translate between
// relative coordinates (-8,-8)..(8,8) and real coordinates,
// specify how opaque the cells are and determine what values
// are written to the visible cells.
struct los_param
{
virtual ~los_param() {}
// Whether the translated coordinate lies within the map
// (including boundary) and within the LOS area
virtual bool los_bounds(const coord_def& p) const = 0;
// appearance(p) will be copied to show(sh_o+p) for visible p.
virtual unsigned appearance(const coord_def& p) const = 0;
virtual opacity_type opacity(const coord_def& p) const = 0;
};
#endif
|
