--- deliantra/Deliantra-Client/DC/Protocol.pm	2008/05/08 21:30:23	1.196
+++ deliantra/Deliantra-Client/DC/Protocol.pm	2008/10/17 11:21:55	1.204
@@ -14,6 +14,12 @@
 
 use base 'Deliantra::Protocol::Base';
 
+our $TEX_DIALOGUE = new_from_resource DC::Texture
+         "dialogue.png", minify => 1, mipmap => 1;
+
+our $TEX_NOFACE = new_from_resource DC::Texture
+        "noface.png", minify => 1, mipmap => 1;
+
 sub new {
    my ($class, %arg) = @_;
 
@@ -69,6 +75,7 @@
 
       delete $self->{items};
       $::INV->clear;
+      $::INVR->clear;
       $::INVR_HB->clear;
       $::FLOORBOX->clear;
    });
@@ -77,14 +84,12 @@
       for @cmd_help;
 
    {
-      $self->{dialogue} = my $tex = new_from_file DC::Texture
-         DC::find_rcfile "dialogue.png", minify => 1, mipmap => 1;
+      $self->{dialogue} = my $tex = $TEX_DIALOGUE;
       $self->{map}->set_texture (1, @$tex{qw(name w h s t)}, @{$tex->{minified}});
    }
 
    {
-     $self->{noface} = my $tex = new_from_file DC::Texture
-        DC::find_rcfile "noface.png", minify => 1, mipmap => 1;
+      $self->{noface} = my $tex = $TEX_NOFACE;
       $self->{map}->set_texture (2, @$tex{qw(name w h s t)}, @{$tex->{minified}});
    }
 
@@ -639,7 +644,7 @@
 sub map_scroll {
    my ($self, $dx, $dy) = @_;
 
-   $self->{map}->scroll ($dx, $dy);
+   $self->{map_widget}->scroll ($dx, $dy);
 }
 
 sub feed_map1a {
@@ -686,20 +691,26 @@
 sub flush_map {
    my ($self) = @_;
 
-   my $map_info = delete $self->{map_info}
-      or return;
+   return unless $self->{map_info};
 
-   my ($hash, $x, $y, $w, $h) = @$map_info;
+   for my $map_info (values %{ $self->{map_cache} || {} }) {
+      my ($hash, $rdata, $x, $y, $w, $h) = @$map_info;
 
-   my $data = Compress::LZF::compress $self->{map}->get_rect ($x, $y, $w, $h);
-   $self->{map_cache_new}{$hash} = \$data;
-   DC::DB::put $self->{mapcache} => $hash => $data, sub { };
+      my $data = $self->{map}->get_rect ($x, $y, $w, $h);
+
+      if ($data ne $$rdata) {
+         $map_info->[1] = \$data;
+         my $cdata = Compress::LZF::compress $data;
+         DC::DB::put $self->{mapcache} => $hash => $cdata, sub { };
+      }
+   }
 }
 
 sub map_clear {
    my ($self) = @_;
 
    $self->flush_map;
+   delete $self->{map_info};
    delete $self->{neigh_map};
 
    $self->{map}->clear;
@@ -730,36 +741,34 @@
    };
 }
 
-sub load_map($$$) {
-   my ($self, $hash, $x, $y) = @_;
+sub load_map($$$$$$) {
+   my ($self, $hash, $x, $y, $w, $h) = @_;
 
-   my $gen = $self->{map_change_gen};
+   my $map_info = $self->{map_cache}{$hash} = [$hash, \"", $x, $y, $w, $h];
 
    my $cb = sub {
-      return unless $gen == $self->{map_change_gen};
-
-      my ($data) = @_;
-
-      if (defined $data) {
-         $self->{map_cache_new}{$hash} = \$data;
+      $map_info->[1] = \$_[0];
 
-         my $data = Compress::LZF::decompress $data;
-
-         my $inprogress = @{ $self->{bg_fetch} || [] };
-         unshift @{ $self->{bg_fetch} }, $self->{map}->set_rect ($x, $y, $data);
-         $self->bg_fetch unless $inprogress;
-      }
+      my $inprogress = @{ $self->{bg_fetch} || [] };
+      unshift @{ $self->{bg_fetch} }, $self->{map}->set_rect ($x, $y, $_[0]);
+      $self->bg_fetch unless $inprogress;
    };
 
-   if (my $rdata = $self->{map_cache_old}{$hash}) {
-      $cb->($$rdata);
+   if (my $map_info = $self->{map_cache_old}{$hash}) {
+      $cb->(${ $map_info->[1] });
    } else {
-      DC::DB::get $self->{mapcache} => $hash, $cb;
+      my $gen = $self->{map_change_gen};
+
+      DC::DB::get $self->{mapcache} => $hash, sub {
+         return unless $gen == $self->{map_change_gen};
+         return unless defined $_[0];
+         $cb->(Compress::LZF::decompress $_[0]);
+      };
    }
 }
 
 # hardcode /world/world_xxx_xxx map names, the savings are enourmous,
-# (server resource,s latency, bandwidth), so this hack is warranted.
+# (server resources, latency, bandwidth), so this hack is warranted.
 # the right fix is to make real tiled maps with an overview file
 sub send_mapinfo {
    my ($self, $data, $cb) = @_;
@@ -794,7 +803,7 @@
 # this method does a "flood fill" into every tile direction
 # it assumes that tiles are arranged in a rectangular grid,
 # i.e. a map is the same as the left of the right map etc.
-# failure to comply are harmless and result in display errors
+# failure to comply is harmless and results in display errors
 # at worst.
 sub flood_fill {
    my ($self, $block, $gx, $gy, $path, $hash, $flags) = @_;
@@ -840,7 +849,7 @@
             $x += $self->{map}->ox;
             $y += $self->{map}->oy;
 
-            $self->load_map ($hash, $x, $y)
+            $self->load_map ($hash, $x, $y, $w, $h)
                unless $self->{neigh_map}{$hash}[5]++;#d#
 
             $neigh->[$tile] = [$flags, $x, $y, $w, $h, $hash];
@@ -858,7 +867,7 @@
    $self->flush_map;
 
    ++$self->{map_change_gen};
-   $self->{map_cache_old} = delete $self->{map_cache_new};
+   $self->{map_cache_old} = delete $self->{map_cache};
 
    my ($ox, $oy) = ($::MAP->ox, $::MAP->oy);
 
@@ -880,7 +889,7 @@
    (my $map = $hash) =~ s/^.*?\/([^\/]+)$/\1/;
    $::STATWIDS->{map}->set_text ("Map: " . $map);
 
-   $self->load_map ($hash, $x, $y);
+   $self->load_map ($hash, $x, $y, $w, $h);
    $self->flood_fill (0, 0, 0, "", $hash, $flags);
 }
 
@@ -1090,21 +1099,19 @@
       # no longer neecssary with TRT servers
       #$text =~ s/(?<=\S)\n(?=\w)/ /g;
 
-      for (split /\n/, $text) {
-         ::message ({
-            fg     => $fg,
-            markup => $_,
-            type   => $type,
-            extra  => [@extra],
-            color_flags => $color, #d# ugly, kill
-         });
+      ::message ({
+         fg     => $fg,
+         markup => $text,
+         type   => $type,
+         extra  => [@extra],
+         color_flags => $color, #d# ugly, kill
+      });
 
-         $color &= ~NDI_CLEAR; # only clear once for multiline messages
-         # actually, this is an ugly design. _we_ should control the channels,
-         # not some random other widget, as the channels are clearly protocol-specific.
-         # then we could also react to flags such as CLEAR without resorting to
-         # hacks such as color_flags, above.
-      }
+#      $color &= ~NDI_CLEAR; # only clear once for multiline messages
+#      # actually, this is an ugly design. _we_ should control the channels,
+#      # not some random other widget, as the channels are clearly protocol-specific.
+#      # then we could also react to flags such as CLEAR without resorting to
+#      # hacks such as color_flags, above.
 
       $self->{statusbox}->add ($text,
          group        => $text,
@@ -1362,6 +1369,9 @@
 
    $self->send_command ("output-rate $::CFG->{output_rate}") if $::CFG->{output_rate} > 0;
    $self->send_command ("pickup $::CFG->{pickup}");
+
+   $self->send_exti_msg (clientlog => sprintf "OpenGL Info: %s [%s]",
+                                              DC::OpenGL::gl_vendor, DC::OpenGL::gl_version);#d#
 }
 
 sub lookat {
@@ -1535,7 +1545,12 @@
 sub send {
    my ($self, $msg) = @_;
 
-   $self->{textview}->add_paragraph ({ markup => "\n" . DC::asxml $msg });
+   $self->{textview}->add_paragraph ({
+      markup =>
+         "\n<span foreground='#ffff00'><b>"
+         . (DC::asxml $msg)
+         . "</b></span>"
+   });
    $self->{textview}->scroll_to_bottom;
 
    $self->{conn}->send_ext_msg (npc_dialog_tell => $self->{id}, $msg);