ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/ext/map-world.ext
(Generate patch)

Comparing deliantra/server/ext/map-world.ext (file contents):
Revision 1.38 by root, Thu Apr 29 07:32:34 2010 UTC vs.
Revision 1.42 by root, Fri Apr 22 06:19:07 2011 UTC

1#! perl # optional 1#! perl # optional
2 2
3# optional plug-in to speed up worldmap rendering by dynamically 3# manages the worldmap by directing to other handlers
4# generating it out of an image
5# - saves loading time (less data to read)
6# - saves temporary space (only overlay stuff needs to be saved)
7# - might get reused as a generic tiled map
8 4
9cf::map->register (qr{^/world/world_(\d\d\d)_(\d\d\d)$}, 100); 5cf::map->register (qr{^/world/world_(-?\d+)_(-?\d+)(?:_(-?\d+))?$}, 100);
10 6
11use Coro::Handle; 7# universal
12use Coro::AIO; 8our $TILE_W = 50;
9our $TILE_H = 50;
13 10
14our $WORLD; 11# registry
12our @AREAS;
15 13
16sub load_indexed($$) { 14sub register($$$$$$$@) {
17 my ($path, $size) = @_; 15 my $meta = {
16 pkg => shift,
17 x0 => shift, y0 => shift, z0 => shift,
18 x1 => shift, y1 => shift, z1 => shift,
19 @_
20 };
18 21
19 use bytes; 22 my $pkg = $meta->{pkg};
20 23
21 0 < aio_load "$path.plt", my $plt 24 @AREAS = sort { $b->{pri} <=> $a->{pri} }
22 or cf::cleanup "$path.plt: $!"; 25 $meta,
26 grep $pkg ne $_->{pkg},
27 @AREAS;
23 28
24 my %plt; 29 my $isa = \@{"$pkg\::ISA"};
25 my @plt;
26 30
27 for (split /\n/, $plt) { 31 @$isa = (
28 my ($name, $rgb) = split /\s+/; 32 __PACKAGE__,
29 if (/^(\S+)\s+(\S+)$/) { 33 grep __PACKAGE__ ne $_, @$isa
30 my ($name, $rgb) = ($1, $2); 34 );
31 $rgb = join "", map chr, map $_ * 17, map hex, split //, $rgb; 35}
32 $plt{$rgb} = chr @plt; 36
33 push @plt, $name; 37sub format_xyz($$;$) {
38 sprintf "/world/world_%03d_%03d%s",
39 $_[0], $_[1],
40 $_[2] ? sprintf "_%03d", $_[2] : "";
41}
42
43#############################################################################
44
45sub init {
46 my ($self) = @_;
47
48 my ($x, $y, $z) = @$self{qw(x y z)} = ($1, $2, $3+0);
49
50 # find handler for this area
51 for my $meta (@AREAS) {
52 if ( $meta->{x0} <= $x && $x <= $meta->{x1}
53 && $meta->{y0} <= $y && $y <= $meta->{y1}
54 && $meta->{z0} <= $z && $z <= $meta->{z1}
55 ) {
56 $self->{ox} = $x - $meta->{x0};
57 $self->{oy} = $y - $meta->{y0};
58 $self->{oz} = $z - $meta->{z0};
59
60 bless $self, $meta->{pkg};
61
62 $self->init_worldmap ($meta);
63
64 last;
34 } 65 }
66
35 } 67 }
36 68
37 my $data = cf::fork_call { 69 $self->SUPER::init;
38 open my $fh, "convert \Q$path.png\E -depth 8 rgb:- |"
39 or die "convert: $!";
40 binmode $fh;
41
42 $size * 3 == read $fh, my $data, $size * 3
43 or die "$path.png, expected $size rgb triplets: $!";
44
45 cf::_quantise $data, [map "$_$plt{$_}", keys %plt];
46
47 $data
48 };
49
50 $size == length $data
51 or cf::cleanup "$path.png, expected $size index octets ($!)";
52
53 ($data, \@plt)
54} 70}
55 71
56sub load_gridmap($) { 72sub init_worldmap {
57 my ($path) = @_; 73 # only for handlers
58
59 my $map = cf::cache "ext::map-world/gridmap" =>
60 [
61 "$path/gridmap.meta",
62 "$path/gridmap.arch.plt",
63 "$path/gridmap.arch.png",
64 "$path/gridmap.regn.plt",
65 "$path/gridmap.regn.png",
66 ],
67 1 => sub {
68 my ($src) = @_;
69
70 my $map = cf::decode_json $src->[0];
71
72 my $size = $map->{tile_w} * $map->{tile_h} * $map->{grid_w} * $map->{grid_h}
73 or cf::cleanup "$path/gridmap.meta: empty gridmap?";
74
75 ($map->{arc_data}, $map->{arc_plt}) = load_indexed "$path/gridmap.arch", $size;
76 ($map->{reg_data}, $map->{reg_plt}) = load_indexed "$path/gridmap.regn", $size;
77
78 Coro::Storable::freeze $map
79 };
80
81 Coro::Storable::thaw $map
82}
83
84sub reload() {
85 $WORLD = load_gridmap "$MAPDIR/world";
86 cf::trace "worldmap gridmap loaded.\n";
87}
88
89{
90 my $guard = cf::lock_acquire "ext::world_gridmap";
91
92 cf::post_init {
93 cf::async_ext {
94 $Coro::current->{desc} = "worldmap loader";
95 reload;
96 undef $guard;
97 };
98 };
99}
100
101sub wxwy {
102 $_[0]->path =~ m{/world/world_(\d\d\d)_(\d\d\d)$}
103 ? ($1, $2)
104 : (0, 0)
105} 74}
106 75
107sub load_header_orig { 76sub load_header_orig {
108 my ($self) = @_; 77 my ($self) = @_;
109 78
110 my ($x, $y) = $self->wxwy; 79 my ($x, $y, $z) = @$self{qw(x y z)};
111 80
112 my $guard = cf::lock_acquire "ext::world_gridmap"; 81 $self->width ($TILE_W);
82 $self->height ($TILE_H);
113 83
114 $self->width ($WORLD->{tile_w}); 84 $self->name (sprintf "'The World' at %+d%+d%+d", $x, $y, $z);
115 $self->height ($WORLD->{tile_h});
116
117 $self->name ("'The World' at +$x+$y");
118 $self->msg ("worldmap dynamically created by map-world extension"); 85 $self->msg ("worldmap dynamically created by map-world extension");
119 $self->outdoor (1); 86 $self->outdoor ($self->{z} >= 0);
120 $self->default_region (cf::region::find "wilderness"); 87 $self->default_region (cf::region::find "wilderness");
121 88
122 $self->tile_path (0, sprintf "/world/world_%03d_%03d", $x, $y - 1) if $y > 0; 89 # all possible worldmap tiles also exist
123 $self->tile_path (1, sprintf "/world/world_%03d_%03d", $x + 1, $y) if $x < 999; 90 $self->tile_path (0, format_xyz $x, $y - 1, $z);
124 $self->tile_path (2, sprintf "/world/world_%03d_%03d", $x, $y + 1) if $y < 999; 91 $self->tile_path (1, format_xyz $x + 1, $y, $z);
125 $self->tile_path (3, sprintf "/world/world_%03d_%03d", $x - 1, $y) if $x > 0; 92 $self->tile_path (2, format_xyz $x, $y + 1, $z);
93 $self->tile_path (3, format_xyz $x - 1, $y, $z);
94 $self->tile_path (4, format_xyz $x, $y, $z + 1);
95 $self->tile_path (5, format_xyz $x, $y, $z - 1);
126 96
97 # an overlay always wins
127 my $overlay = sprintf "%s/world/world_%03d_%03d.map", $cf::MAPDIR, $x, $y; 98 my $overlay = sprintf "%s/%s.map", $cf::MAPDIR, format_xyz $x, $y, $z;
128 99
129 $self->{load_path} = $overlay 100 $self->{load_path} = $overlay
130 unless Coro::AIO::aio_stat $overlay; 101 unless Coro::AIO::aio_stat $overlay;
131 102
132 $self->{need_create_treasure} = 1; 103 $self->{need_create_treasure} = 1;
133 104
134 1 105 1
135} 106}
136 107
108# fill map with "default" data - first region and first archetype from palette
109# used when we have no map data from elsewhere
137sub fill { 110sub fill {
138 my ($self) = @_; 111 my ($self) = @_;
139 112
140 $self->add_underlay ("\x00" x ($WORLD->{tile_w} * $WORLD->{tile_h}), 0, $WORLD->{tile_w}, $WORLD->{arc_plt});#d# 113 if ($self->{z} > 0) {
141 $self->default_region (cf::region::find $WORLD->{reg_plt}[0]); 114 # hmmm... air? :)
115 $self->add_underlay ("\x00" x ($TILE_W * $TILE_H), 0, $TILE_W, ["blocked"]);
116 } elsif ($self->{z} < 0) {
117 $self->add_underlay ("\x00" x ($TILE_W * $TILE_H), 0, $TILE_W, ["blocked"]);
118 } else {
119 $self->add_underlay ("\x00" x ($TILE_W * $TILE_H), 0, $TILE_W, ["deep_sea"]);
120 }
142} 121}
143 122
144sub load { 123sub load {
145 my ($self) = @_; 124 my ($self) = @_;
146 125
… …
152 $self->in_memory (cf::MAP_ACTIVE); 131 $self->in_memory (cf::MAP_ACTIVE);
153 $self->activate; 132 $self->activate;
154 } 133 }
155} 134}
156 135
136# MUST be overwritten to call at least ->fill
157sub post_load { 137sub post_load {
158 my ($self) = @_; 138 my ($self) = @_;
159
160 {
161 my $guard = cf::lock_acquire "ext::world_gridmap";
162
163 my ($x, $y) = $self->wxwy;
164
165 if ($x >= 100 && $x <= 129 && $y >= 100 && $y <= 129) {
166 my $stride = $WORLD->{grid_w} * $WORLD->{tile_w};
167 my $top = ($y - 100) * $WORLD->{tile_h} * $stride
168 + ($x - 100) * $WORLD->{tile_w};
169
170 $self->add_underlay ($WORLD->{arc_data}, $top, $stride, $WORLD->{arc_plt});
171 $self->set_regiondata ($WORLD->{reg_data}, $top, $stride, $WORLD->{reg_plt});
172
173 } else {
174 $self->fill;
175 }
176 }
177 139
178 $self->create_region_treasure 140 $self->create_region_treasure
179 if delete $self->{need_create_treasure}; 141 if delete $self->{need_create_treasure};
180} 142}
181 143
1821
183

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines