--- deliantra/Deliantra-Client/DC/MapWidget.pm	2008/07/19 20:33:47	1.133
+++ deliantra/Deliantra-Client/DC/MapWidget.pm	2008/08/27 20:19:52	1.141
@@ -423,7 +423,7 @@
          my $spd  = $::CONN->{stat}{DC::Protocol::CS_STAT_SPEED};
 
          # the minimum time for a single tile movement
-         my $mintime = DC::Protocol::TICK * DC::ceil 1 / ($spd * DC::Protocol::TICK);
+         my $mintime = DC::Protocol::TICK * DC::ceil 1 / ($spd * DC::Protocol::TICK || 1);
 
          # jump if "impossibly high" speed
          if (
@@ -433,17 +433,15 @@
             #warn "jump ", (max abs $self->{sdx}, abs $self->{sdy}), " ", $spd * $mintime * 1.0;#d#
             $self->{sdx} = $self->{sdy} = 0;
          } else {
-            my $upd = 0;
-
-            $spd *= $self->{tilesize} * $diff * 1.0001;
+            $spd *= $self->{tilesize} * $diff * 1.0001; # 1.0001 so that we don't accumulate rounding errors the wrong direction
 
             my $dx = $self->{sdx} < 0 ? -$spd : $spd;
             my $dy = $self->{sdy} < 0 ? -$spd : $spd;
 
-            if ($self->{sdx} * ($self->{sdx} - $dx) <= 0) { $self->{sdx} = 0 } else { $self->{sdx} -= $dx; $upd = 1 }
-            if ($self->{sdy} * ($self->{sdy} - $dy) <= 0) { $self->{sdy} = 0 } else { $self->{sdy} -= $dy; $upd = 1 }
+            if ($self->{sdx} * ($self->{sdx} - $dx) <= 0) { $self->{sdx} = 0 } else { $self->{sdx} -= $dx }
+            if ($self->{sdy} * ($self->{sdy} - $dy) <= 0) { $self->{sdy} = 0 } else { $self->{sdy} -= $dy }
 
-            $self->update if $upd;
+            $self->update;
          }
       }
    } else {
@@ -462,13 +460,16 @@
 
          my $tilesize = $self->{ctilesize} = (int $self->{tilesize} * $::CFG->{map_scale}) || 1;
 
+         my $sdx_t = DC::ceil $self->{sdx} / $tilesize;
+         my $sdy_t = DC::ceil $self->{sdy} / $tilesize;
+
          # width/height of map, in tiles
-         my $sw = $self->{sw} = 1 + DC::ceil $self->{w} / $tilesize;
-         my $sh = $self->{sh} = 1 + DC::ceil $self->{h} / $tilesize;
+         my $sw = $self->{sw} = 2 + DC::ceil $self->{w} / $tilesize;
+         my $sh = $self->{sh} = 2 + DC::ceil $self->{h} / $tilesize;
 
          # the map displacement, in tiles
-         my $sx = DC::ceil $::CFG->{map_shift_x} / $tilesize + $self->{sdx} / $self->{tilesize};
-         my $sy = DC::ceil $::CFG->{map_shift_y} / $tilesize + $self->{sdy} / $self->{tilesize};
+         my $sx = DC::ceil $::CFG->{map_shift_x} / $tilesize + $sdx_t;
+         my $sy = DC::ceil $::CFG->{map_shift_y} / $tilesize + $sdy_t;
 
          # the upper left "visible" corner, in pixels
          my $sx0 = $self->{sx0} = $::CFG->{map_shift_x} - $sx * $tilesize;
@@ -478,7 +479,13 @@
          my $dy = $self->{dy} = DC::ceil 0.5 * ($::MAP->h - $sh) - $sy;
 
          if ($::CFG->{fow_enable}) {
-            my ($w, $h, $data) = $::MAP->fow_texture ($dx, $dy, $sw, $sh);
+            $sdx_t = $sdy_t = 0;#d#
+            my ($w, $h, $data) = $::MAP->fow_texture (
+               $dx + (min 0, $sdx_t),
+               $dy + (min 0, $sdy_t),
+               $sw + abs $sdx_t,
+               $sh + abs $sdy_t
+            );
 
             $self->{fow_texture} = new DC::Texture
                w              => $w,
@@ -493,18 +500,21 @@
          glNewList ($self->{list} ||= glGenList);
 
          glPushMatrix;
-         glTranslate $sx0 + $self->{sdx}, $sy0 + $self->{sdy};
+         glTranslate $sx0, $sy0;
          glScale $::CFG->{map_scale}, $::CFG->{map_scale};
+         glTranslate $self->{sdx}, $self->{sdy};
 
          $::MAP->draw ($dx, $dy, $sw, $sh,
                        $self->{tilesize},
                        $::CONN->{player}{tag},
                        -$self->{sdx}, -$self->{sdy});
 
+         #glTranslate -$self->{sdx}, -$self->{sdy}; # anchro fow at player
          glScale $self->{tilesize}, $self->{tilesize};
 
          if (my $tex = $self->{fow_texture}) {
             glPushMatrix;
+            glTranslate +(min 0, $sdx_t), (min 0, $sdy_t);
             glScale 1/3, 1/3;
             glEnable GL_TEXTURE_2D;
             glTexEnv GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE;