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.11 by root, Sun Feb 11 01:38:47 2007 UTC vs.
Revision 1.43 by root, Sat Apr 23 04:46:26 2011 UTC

1#! perl # OPTIONAL 1#! perl # mandatory
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
9use Coro::Handle; 5cf::map->register (qr{^/world/world_(-?\d+)_(-?\d+)(?:_(-?\d+))?$}, 100);
10use Coro::AIO;
11 6
12our $WORLD; 7# universal
8our $TILE_W = 50;
9our $TILE_H = 50;
13 10
14sub load_indexed($$) { 11# registry
15 my ($path, $size) = @_; 12our @AREAS;
16 13
17 use bytes; 14sub register($$$$$$$@) {
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 0 < aio_load "$path.plt", my $plt 22 my $pkg = $meta->{pkg};
20 or cf::cleanup "$path.plt: $!";
21 23
22 my %plt; 24 @AREAS = sort { $b->{pri} <=> $a->{pri} }
23 my @plt; 25 $meta,
26 grep $pkg ne $_->{pkg},
27 @AREAS;
24 28
25 for (split /\n/, $plt) { 29 my $isa = \@{"$pkg\::ISA"};
26 my ($name, $rgb) = split /\s+/; 30
27 if (/^(\S+)\s+(\S+)$/) { 31 @$isa = (
28 my ($name, $rgb) = ($1, $2); 32 __PACKAGE__,
29 $rgb = join "", map chr, map $_ * 17, map hex, split //, $rgb; 33 grep __PACKAGE__ ne $_, @$isa
30 $plt{$rgb} = chr @plt; 34 );
31 push @plt, $name; 35}
36
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;
32 } 65 }
66
33 } 67 }
34 68
35 my $pid = open my $pipe, "-|"; 69 $self->SUPER::init;
36
37 defined $pid
38 or cf::cleanup "fork: $!";
39
40 unless ($pid) {
41 eval {
42 open my $fh, "convert \Q$path.png\E -depth 8 rgb:- |"
43 or die "convert: $!";
44 binmode $fh;
45
46 binmode $fh;
47 $size * 3 == read $fh, my $data, $size * 3
48 or die "$path.png, expected $size rgb triplets: $!";
49
50 $data =~ s{(...)}{
51 $plt{$1} or die "$path.png: color not in palette: #" . unpack "H*", $1
52 }sge;
53
54 binmode STDOUT;
55 syswrite STDOUT, $data;
56 };
57 warn $@ if $@;
58 cf::_exit;
59 }
60
61 $pipe = Coro::Handle::unblock $pipe;
62 binmode $pipe;
63 $size == read $pipe, my $data, $size
64 or cf::cleanup "$path.png, expected $size index octets ($!)";
65
66 ($data, \@plt)
67} 70}
68 71
69sub load_gridmap($) { 72sub init_worldmap {
70 my ($path) = @_; 73 # only for handlers
71
72 if (! -e "/tmp/xxxx.gridmap") {
73 0 < aio_load "$path/gridmap.meta", my $map
74 or cf::cleanup "$path/gridmap.meta: $!\n";
75
76 $map = cf::from_json $map;
77
78 my $size = $map->{tile_w} * $map->{tile_h} * $map->{grid_w} * $map->{grid_h}
79 or cf::cleanup "$path/gridmap.meta: empty gridmap?";
80
81 ($map->{arc_data}, $map->{arc_plt}) = load_indexed "$path/gridmap.arch", $size;
82 ($map->{reg_data}, $map->{reg_plt}) = load_indexed "$path/gridmap.regn", $size;
83
84 Storable::nstore $map, "/tmp/xxxx.gridmap";#d#
85
86 $map
87 } else {
88 Storable::retrieve "/tmp/xxxx.gridmap";
89 }
90}
91
92# this is contorted, but likely the correct way to acquire the lock :)
93cf::sync_job {
94 my $guard = cf::lock_acquire "ext::world_gridmap";
95 cf::async_ext {
96 $WORLD = load_gridmap sprintf "%s/%s/%s", cf::datadir, cf::mapdir, "world";
97 warn "worldmap gridmap loaded.";
98 undef $guard;
99 }
100};
101
102cf::map->register (qr{^/world/world_(\d\d\d)_(\d\d\d)$}, 100);
103
104sub wxwy {
105 $_[0]->path =~ m{/world/world_(\d\d\d)_(\d\d\d)$}
106 ? ($1, $2)
107 : (0, 0)
108} 74}
109 75
110sub load_header_orig { 76sub load_header_orig {
111 my ($self) = @_; 77 my ($self) = @_;
112 78
113 my ($x, $y) = $self->wxwy; 79 my ($x, $y, $z) = @$self{qw(x y z)};
114 80
115 my $guard = cf::lock_acquire "ext::world_gridmap"; 81 $self->width ($TILE_W);
82 $self->height ($TILE_H);
116 83
117 $self->width ($WORLD->{tile_w}); 84 $self->name (sprintf "'The World' at %+d%+d%+d", $x, $y, $z);
118 $self->height ($WORLD->{tile_h}); 85 $self->msg ("worldmap dynamically created by map-world extension");
86 $self->outdoor ($self->{z} >= 0);
87 $self->default_region (cf::region::find "wilderness");
119 88
120 $self->name ("'The World' at +$x+$y"); 89 # all possible worldmap tiles also exist
121 $self->msg ("worldmap dynamically created by map-world extension"); 90 $self->tile_path (0, format_xyz $x, $y - 1, $z);
122 $self->outdoor (1); 91 $self->tile_path (1, format_xyz $x + 1, $y, $z);
123 $self->default_region (undef); 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);
124 96
125# $self->tile_path (0, sprintf "/world/world_%03d_%03d", $x, $y - 1) if $y > 0; 97 # an overlay always wins
126# $self->tile_path (1, sprintf "/world/world_%03d_%03d", $x + 1, $y) if $x < 999; 98 my $overlay = sprintf "%s/%s.map", $cf::MAPDIR, format_xyz $x, $y, $z;
127# $self->tile_path (2, sprintf "/world/world_%03d_%03d", $x, $y + 1) if $y < 999;
128# $self->tile_path (3, sprintf "/world/world_%03d_%03d", $x - 1, $y) if $x > 0;
129 $self->tile_path (0, sprintf "/world/world_%03d_%03d", $x, $y - 1) if $y > 100;
130 $self->tile_path (1, sprintf "/world/world_%03d_%03d", $x + 1, $y) if $x < 129;
131 $self->tile_path (2, sprintf "/world/world_%03d_%03d", $x, $y + 1) if $y < 129;
132 $self->tile_path (3, sprintf "/world/world_%03d_%03d", $x - 1, $y) if $x > 100;
133 99
134 $self->{load_path} = sprintf "%s/%s/world-overlay/world_%03d_%03d", cf::datadir, cf::mapdir, $x, $y 100 $self->{load_path} = $overlay
135 if $x >= 100 && $x <= 129 && $y >= 100 && $y <= 129; 101 unless Coro::AIO::aio_stat $overlay;
102
103 $self->{need_create_treasure} = 1;
136 104
137 1 105 1
138} 106}
139 107
140sub load { 108# fill map with "default" data - first region and first archetype from palette
109# used when we have no map data from elsewhere
110sub fill {
141 my ($self) = @_; 111 my ($self) = @_;
142 112
143 if ($self->{load_path}) { 113 if ($self->{z} > 0) {
144 $self->SUPER::load; 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"]);
145 } else { 118 } else {
146 $self->alloc; 119 $self->add_underlay ("\x00" x ($TILE_W * $TILE_H), 0, $TILE_W, ["deep_sea"]);
147
148 for my $X (0 .. $WORLD->{tile_w} - 1) {
149 Coro::cede;
150 for my $Y (0 .. $WORLD->{tile_h} - 1) {
151 my $ob = cf::object::new "deep_sea";
152 $self->insert ($ob, $X, $Y);
153 }
154 }
155 $self->set_object_flag (cf::FLAG_NO_MAP_SAVE, 1);
156 $self->default_region (cf::region::find "ocean");
157
158 $self->in_memory (cf::MAP_IN_MEMORY);
159 } 120 }
160} 121}
161 122
123#sub load {
124# my ($self) = @_;
125#
126# if ($self->{load_path}) {
127# warn "load $self\n";#d#
128# $self->SUPER::load;
129# } else {
130# warn "fill $self\n";#d#
131# my $guard = cf::lock_acquire "map_data:$self->{path}";
132#
133# $self->alloc;
134# $self->fill;
135# $self->in_memory (cf::MAP_ACTIVE);
136# $self->activate;
137# $self->post_load;
138# }
139#}
140
141# MUST be overwritten to call at least ->fill
162sub post_load { 142sub post_load {
163 my ($self) = @_; 143 my ($self) = @_;
164 144
165 my $guard = cf::lock_acquire "ext::world_gridmap"; 145 $self->create_region_treasure
166 146 if delete $self->{need_create_treasure};
167 my ($x, $y) = $self->wxwy;
168
169 return
170 unless $x >= 100 && $x <= 129 && $y >= 100 && $y <= 129;
171
172 my $stride = $WORLD->{grid_w} * $WORLD->{tile_w};
173 my $top = ($y - 100) * $WORLD->{tile_h} * $stride
174 + ($x - 100) * $WORLD->{tile_w};
175
176 my $reg;
177
178 for my $Y (0 .. $WORLD->{tile_h} - 1) {
179 Coro::cede;
180 my $row = substr $WORLD->{arc_data}, $top + $Y * $stride, $WORLD->{tile_w};
181 $reg .= substr $WORLD->{reg_data}, $top + $Y * $stride, $WORLD->{tile_w};
182 for my $X (0 .. $WORLD->{tile_w} - 1) {
183 next if grep $_->flag (cf::FLAG_IS_FLOOR), $self->at ($X, $Y);
184 my $ob = cf::object::new $WORLD->{arc_plt}[ord substr $row, $X];
185 $ob->flag (cf::FLAG_NO_MAP_SAVE, 1);
186 $self->insert ($ob, $X, $Y, undef, cf::INS_ABOVE_FLOOR_ONLY);
187 }
188 }
189
190 $self->set_regiondata ($reg, $WORLD->{reg_plt});
191} 147}
192 148
1931
194

Diff Legend

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