gde/GCE/Util.pm

package GCE::Util;
=head1 NAME

   GCE::Util - some utility functions

=over 4

=cut

use base 'Exporter';

use Crossfire;

use Carp ();
use Storable;
use List::Util qw(min max);

use Crossfire;
use Crossfire::MapWidget;

our @EXPORT = qw(insert_arch_stack_layer replace_arch_stack_layer new_arch_pb fill_pb_from_arch arch_is_floor stack_find_floor stack_find_wall stack_find arch_is_wall arch_is_monster add_table_widget quick_msg def);

sub def($$) {
   return defined ($_[0]) ? $_[0] : $_[1];
}

sub quick_msg {
   my $wid = shift;
   my $msg;
   my $win = $::MAINWIN;
   if (ref $wid) {
      $win = $wid;
      $msg = shift;
   } else {
      $msg = $wid;
   }
   my $dia = Gtk2::Dialog->new ('Message', $win, 'destroy-with-parent', 'gtk-ok' => 'none');

   my $lbl = Gtk2::Label->new ($msg);
   $dia->vbox->add ($lbl);
   $dia->signal_connect (response => sub { $_[0]->destroy });

   unless (defined $_[0]) {
      Glib::Timeout->add (1000, sub { $dia->destroy; 0 });
   }

   $dia->show_all;
}

sub new_arch_pb {
   # this is awful, is this really the best way?
   my $pb = new Gtk2::Gdk::Pixbuf 'rgb', 1, 8, TILESIZE, TILESIZE;
   return $pb;
}

sub fill_pb_from_arch {
   my ($pb, $arch) = @_;

   $pb->fill (0x00000000);
   $TILE->composite ($pb,
      0, 0,
      TILESIZE, TILESIZE,
      - ($arch->{_face} % 64) * TILESIZE, - TILESIZE * int $arch->{_face} / 64,
      1, 1, 'nearest', 255
   );
}

sub classify_arch_layer {
   my ($arch) = @_;

   if ($arch->{invisible}) { # just a heuristic for 'special' tiles (er. pedestals)

      return 'below';

   } elsif ($arch->{monster}) {

      return 'top';

   } else { # $arch->{is_floor} and all other arches are 'between' monsters and floor

      return 'between';
   }
}

sub arch_is_floor {
   my ($a) = @_;
   return $Crossfire::ARCH{$a->{_name}}->{is_floor};
}

sub arch_is_wall {
   my ($a) = @_;
   return $Crossfire::ARCH{$a->{_name}}->{no_pass};
}

sub arch_is_monster {
   my ($a) = @_;
   my $arch = $Crossfire::ARCH{$a->{_name}};
   return $arch->{alive} and ($arch->{monster} or $arch->{generator});
}

sub stack_find {
   my ($stack, $dir, $pred) = @_;


   if ($dir eq 'from_top') {
      my $i = scalar (@$stack) - 1;
      if ($i < 0) { $i = 0 }

      for (reverse @$stack) {
         $pred->($_)
            and return $i;

         $i--;
      }

   } else {
      my $i = 0;

      for (@$stack) {
         $pred->($_)
            and return $i;

         $i++;
      }
   }

   return 0;

}

sub stack_find_floor {
   my ($stack, $dir) = @_;
   return stack_find ($stack, $dir, \&arch_is_floor);
}

sub stack_find_wall {
   my ($stack, $dir) = @_;
   return stack_find ($stack, $dir, \&arch_is_wall);
}

sub insert_arch_stack_layer {
   my ($stack, $arch) = @_;

   unless (@$stack) {
      return [ $arch ];
   }

   my @outstack;

   my $l = classify_arch_layer ($Crossfire::ARCH{$arch->{_name}});

   if ($l eq 'between') {

      # loop until we reached the first 'between' arch above 'below' arches and the floor
      while (my $a = shift @$stack) {

         unless ($Crossfire::ARCH{$a->{_name}}->{is_floor}
                 or classify_arch_layer ($Crossfire::ARCH{$a->{_name}}) eq 'below') {

            unshift @$stack, $a;
            last;
         }

         push @outstack, $a;
      }

      # ignore duplicates
      # FIXME: Broken if non-floor are drawn (too tired to fix)
      return [ @outstack, @$stack ]
         if @outstack and $outstack[-1]->{_name} eq $arch->{_name};

      push @outstack, ($arch, @$stack);

   } elsif ($l eq 'top') {

      # ignore duplicates
      return [ @$stack ]
         if $stack->[-1]->{_name} eq $arch->{_name};

      @outstack = (@$stack, $arch);

   } else {

      # ignore duplicates
      return [ @$stack ]
         if $stack->[0]->{_name} eq $arch->{_name};

      @outstack = ($arch, @$stack);
   }

   return \@outstack;
}

sub add_table_widget {
   my ($table, $row, $data, $type, $cb) = @_;
   my $edwid;

   if ($type eq 'string') {
      $table->attach_defaults (my $lbl = Gtk2::Label->new ($data->[0]), 0, 1, $row, $row + 1);
      $edwid = Gtk2::Entry->new;
         $edwid->set_text ($data->[1]);
         $edwid->signal_connect (changed => sub {
            $data->[1] = $_[0]->get_text;
            $cb->($data->[1]) if $cb;
         });
      $table->attach_defaults ($edwid, 1, 2, $row, $row + 1);

   } elsif ($type eq 'button') {
      $table->attach_defaults (my $b = Gtk2::Button->new_with_label ($data), 0, 2, $row, $row + 1);
      $b->signal_connect (clicked => ($cb || sub {}));

   } elsif ($type eq 'label') {
      $table->attach_defaults (my $lbl = Gtk2::Label->new ($data->[0]), 0, 1, $row, $row + 1);
      $edwid = Gtk2::Label->new ($data->[1]);
      $table->attach_defaults ($edwid, 1, 2, $row, $row + 1);

   } else {
      $edwid = Gtk2::Label->new ("FOO");
   }
}

sub replace_arch_stack_layer {
   my ($stack, $arch) = @_;

   my @outstack;

   my $l = classify_arch_layer ($Crossfire::ARCH{$arch->{_name}});

   if ($l eq 'between') {

      while (shift @$stack) {
         last unless $Crossfire::ARCH{$_->{_name}}->{is_floor};
         push @outstack, $_;
      }

      if (@outstack and $Crossfire::ARCH{$outstack[-1]->{_name}}->{is_floor}) {
         pop @outstack;
      }

      push @outstack, ($arch, @$stack);

   } elsif ($l eq 'top') {

      @outstack = (@$stack, $arch);

   } else {

      @outstack = ($arch, @$stack);
   }

   return \@outstack;
}

=head1 AUTHOR

 Marc Lehmann <schmorp@schmorp.de>
 http://home.schmorp.de/

 Robin Redeker <elmex@ta-sa.org>
 http://www.ta-sa.org/

=cut
1;
Revision:	1.5
Committed:	Thu Mar 16 11:59:34 2006 UTC (18 years, 2 months ago) by elmex
Branch:	MAIN
Changes since 1.4:	+28 -1 lines
Log Message:	implemented connect tool for exits and some minor improvements in saving
#	User	Rev	Content
1	elmex	1.1	package GCE::Util;
2			=head1 NAME
3
4			GCE::Util - some utility functions
5
6			=over 4
7
8			=cut
9
10			use base 'Exporter';
11
12			use Crossfire;
13
14			use Carp ();
15			use Storable;
16			use List::Util qw(min max);
17
18	elmex	1.2	use Crossfire;
19			use Crossfire::MapWidget;
20
21	elmex	1.5	our @EXPORT = qw(insert_arch_stack_layer replace_arch_stack_layer new_arch_pb fill_pb_from_arch arch_is_floor stack_find_floor stack_find_wall stack_find arch_is_wall arch_is_monster add_table_widget quick_msg def);
22
23			sub def($$) {
24			return defined ($_[0]) ? $_[0] : $_[1];
25			}
26
27			sub quick_msg {
28			my $wid = shift;
29			my $msg;
30			my $win = $::MAINWIN;
31			if (ref $wid) {
32			$win = $wid;
33			$msg = shift;
34			} else {
35			$msg = $wid;
36			}
37			my $dia = Gtk2::Dialog->new ('Message', $win, 'destroy-with-parent', 'gtk-ok' => 'none');
38
39			my $lbl = Gtk2::Label->new ($msg);
40			$dia->vbox->add ($lbl);
41			$dia->signal_connect (response => sub { $_[0]->destroy });
42
43			unless (defined $_[0]) {
44			Glib::Timeout->add (1000, sub { $dia->destroy; 0 });
45			}
46
47			$dia->show_all;
48			}
49	elmex	1.2
50			sub new_arch_pb {
51			# this is awful, is this really the best way?
52			my $pb = new Gtk2::Gdk::Pixbuf 'rgb', 1, 8, TILESIZE, TILESIZE;
53			return $pb;
54			}
55
56			sub fill_pb_from_arch {
57			my ($pb, $arch) = @_;
58
59			$pb->fill (0x00000000);
60			$TILE->composite ($pb,
61			0, 0,
62			TILESIZE, TILESIZE,
63			- ($arch->{_face} % 64) * TILESIZE, - TILESIZE * int $arch->{_face} / 64,
64			1, 1, 'nearest', 255
65			);
66			}
67	elmex	1.1
68			sub classify_arch_layer {
69			my ($arch) = @_;
70
71			if ($arch->{invisible}) { # just a heuristic for 'special' tiles (er. pedestals)
72
73			return 'below';
74
75			} elsif ($arch->{monster}) {
76
77			return 'top';
78
79			} else { # $arch->{is_floor} and all other arches are 'between' monsters and floor
80
81			return 'between';
82			}
83			}
84
85	elmex	1.2	sub arch_is_floor {
86			my ($a) = @_;
87			return $Crossfire::ARCH{$a->{_name}}->{is_floor};
88			}
89
90			sub arch_is_wall {
91			my ($a) = @_;
92			return $Crossfire::ARCH{$a->{_name}}->{no_pass};
93			}
94
95	elmex	1.3	sub arch_is_monster {
96			my ($a) = @_;
97			my $arch = $Crossfire::ARCH{$a->{_name}};
98			return $arch->{alive} and ($arch->{monster} or $arch->{generator});
99			}
100
101	elmex	1.2	sub stack_find {
102			my ($stack, $dir, $pred) = @_;
103
104
105			if ($dir eq 'from_top') {
106			my $i = scalar (@$stack) - 1;
107			if ($i < 0) { $i = 0 }
108
109			for (reverse @$stack) {
110			$pred->($_)
111			and return $i;
112
113			$i--;
114			}
115
116			} else {
117			my $i = 0;
118
119			for (@$stack) {
120			$pred->($_)
121			and return $i;
122
123			$i++;
124			}
125			}
126
127			return 0;
128
129			}
130
131			sub stack_find_floor {
132			my ($stack, $dir) = @_;
133			return stack_find ($stack, $dir, \&arch_is_floor);
134			}
135
136			sub stack_find_wall {
137			my ($stack, $dir) = @_;
138			return stack_find ($stack, $dir, \&arch_is_wall);
139			}
140
141	elmex	1.1	sub insert_arch_stack_layer {
142			my ($stack, $arch) = @_;
143
144			unless (@$stack) {
145			return [ $arch ];
146			}
147
148			my @outstack;
149
150			my $l = classify_arch_layer ($Crossfire::ARCH{$arch->{_name}});
151
152			if ($l eq 'between') {
153
154			# loop until we reached the first 'between' arch above 'below' arches and the floor
155			while (my $a = shift @$stack) {
156
157			unless ($Crossfire::ARCH{$a->{_name}}->{is_floor}
158			or classify_arch_layer ($Crossfire::ARCH{$a->{_name}}) eq 'below') {
159
160			unshift @$stack, $a;
161			last;
162			}
163
164			push @outstack, $a;
165			}
166
167			# ignore duplicates
168			# FIXME: Broken if non-floor are drawn (too tired to fix)
169			return [ @outstack, @$stack ]
170			if @outstack and $outstack[-1]->{_name} eq $arch->{_name};
171
172			push @outstack, ($arch, @$stack);
173
174			} elsif ($l eq 'top') {
175
176			# ignore duplicates
177			return [ @$stack ]
178			if $stack->[-1]->{_name} eq $arch->{_name};
179
180			@outstack = (@$stack, $arch);
181
182			} else {
183
184			# ignore duplicates
185			return [ @$stack ]
186			if $stack->[0]->{_name} eq $arch->{_name};
187
188			@outstack = ($arch, @$stack);
189			}
190
191			return \@outstack;
192			}
193
194	elmex	1.4	sub add_table_widget {
195			my ($table, $row, $data, $type, $cb) = @_;
196			my $edwid;
197
198			if ($type eq 'string') {
199			$table->attach_defaults (my $lbl = Gtk2::Label->new ($data->[0]), 0, 1, $row, $row + 1);
200			$edwid = Gtk2::Entry->new;
201			$edwid->set_text ($data->[1]);
202			$edwid->signal_connect (changed => sub {
203			$data->[1] = $_[0]->get_text;
204			$cb->($data->[1]) if $cb;
205			});
206			$table->attach_defaults ($edwid, 1, 2, $row, $row + 1);
207
208			} elsif ($type eq 'button') {
209			$table->attach_defaults (my $b = Gtk2::Button->new_with_label ($data), 0, 2, $row, $row + 1);
210			$b->signal_connect (clicked => ($cb \|\| sub {}));
211
212			} elsif ($type eq 'label') {
213			$table->attach_defaults (my $lbl = Gtk2::Label->new ($data->[0]), 0, 1, $row, $row + 1);
214			$edwid = Gtk2::Label->new ($data->[1]);
215			$table->attach_defaults ($edwid, 1, 2, $row, $row + 1);
216
217			} else {
218			$edwid = Gtk2::Label->new ("FOO");
219			}
220			}
221
222	elmex	1.1	sub replace_arch_stack_layer {
223			my ($stack, $arch) = @_;
224
225			my @outstack;
226
227			my $l = classify_arch_layer ($Crossfire::ARCH{$arch->{_name}});
228
229			if ($l eq 'between') {
230
231			while (shift @$stack) {
232			last unless $Crossfire::ARCH{$_->{_name}}->{is_floor};
233			push @outstack, $_;
234			}
235
236			if (@outstack and $Crossfire::ARCH{$outstack[-1]->{_name}}->{is_floor}) {
237			pop @outstack;
238			}
239
240			push @outstack, ($arch, @$stack);
241
242			} elsif ($l eq 'top') {
243
244			@outstack = (@$stack, $arch);
245
246			} else {
247
248			@outstack = ($arch, @$stack);
249			}
250
251			return \@outstack;
252			}
253
254			=head1 AUTHOR
255
256			Marc Lehmann <schmorp@schmorp.de>
257			http://home.schmorp.de/
258
259			Robin Redeker <elmex@ta-sa.org>
260			http://www.ta-sa.org/
261
262			=cut
263			1;