--- deliantra/Deliantra/Deliantra.pm	2007/12/05 11:39:26	1.118
+++ deliantra/Deliantra/Deliantra.pm	2007/12/26 18:05:00	1.119
@@ -1,10 +1,10 @@
 =head1 NAME
 
-Crossfire - Crossfire maphandling
+Deliantra - Deliantra suppport module to read/write archetypes, maps etc.
 
 =cut
 
-package Crossfire;
+package Deliantra;
 
 our $VERSION = '1.13';
 
@@ -156,7 +156,7 @@
 our @MOVE_TYPE = keys %MOVE_TYPE;
 
 {
-   package Crossfire::MoveType;
+   package Deliantra::MoveType;
 
    use overload
       '='  => sub { bless [@{$_[0]}], ref $_[0] },
@@ -186,7 +186,7 @@
    ;
 }
 
-sub Crossfire::MoveType::new {
+sub Deliantra::MoveType::new {
    my ($class, $string) = @_;
 
    my $mask;
@@ -210,7 +210,7 @@
    (bless [$mask, $value], $class)->normalise
 }
 
-sub Crossfire::MoveType::normalise {
+sub Deliantra::MoveType::normalise {
    my ($self) = @_;
 
    if ($self->[0] & MOVE_ALL) {
@@ -224,15 +224,15 @@
    $self
 }
 
-sub Crossfire::MoveType::as_string {
+sub Deliantra::MoveType::as_string {
    my ($self) = @_;
 
    my @res;
 
    my ($mask, $value) = @$self;
 
-   for (@Crossfire::MOVE_TYPE) {
-      my $bit = $Crossfire::MOVE_TYPE{$_};
+   for (@Deliantra::MOVE_TYPE) {
+      my $bit = $Deliantra::MOVE_TYPE{$_};
       if (($mask & $bit) == $bit && (($value & $bit) == $bit || ($value & $bit) == 0)) {
          $mask &= ~$bit;
          push @res, $value & $bit ? $_ : "-$_";
@@ -382,31 +382,31 @@
    for my $attr (keys %FIELD_MOVEMENT) {
       next unless exists $ob->{$attr};
 
-      $ob->{$attr} = new Crossfire::MoveType $ob->{$attr};
+      $ob->{$attr} = new Deliantra::MoveType $ob->{$attr};
    }
 
    # convert outdated movement flags to new movement sets
    if (defined (my $v = delete $ob->{no_pass})) {
-      $ob->{move_block} = new Crossfire::MoveType $v ? "all" : "";
+      $ob->{move_block} = new Deliantra::MoveType $v ? "all" : "";
    }
    if (defined (my $v = delete $ob->{slow_move})) {
       $ob->{move_slow} += "walk";
       $ob->{move_slow_penalty} = $v;
    }
    if (defined (my $v = delete $ob->{walk_on})) {
-      $ob->{move_on}   ||= new Crossfire::MoveType; if ($v) { $ob->{move_on}  += "walk"     } else { $ob->{move_on}   -= "walk"    }
+      $ob->{move_on}   ||= new Deliantra::MoveType; if ($v) { $ob->{move_on}  += "walk"     } else { $ob->{move_on}   -= "walk"    }
    }
    if (defined (my $v = delete $ob->{walk_off})) {
-      $ob->{move_off}  ||= new Crossfire::MoveType; if ($v) { $ob->{move_off}  += "walk"    } else { $ob->{move_off}  -= "walk"    }
+      $ob->{move_off}  ||= new Deliantra::MoveType; if ($v) { $ob->{move_off}  += "walk"    } else { $ob->{move_off}  -= "walk"    }
    }
    if (defined (my $v = delete $ob->{fly_on})) {
-      $ob->{move_on}   ||= new Crossfire::MoveType; if ($v) { $ob->{move_on}   += "fly_low" } else { $ob->{move_on}   -= "fly_low" }
+      $ob->{move_on}   ||= new Deliantra::MoveType; if ($v) { $ob->{move_on}   += "fly_low" } else { $ob->{move_on}   -= "fly_low" }
    }
    if (defined (my $v = delete $ob->{fly_off})) {
-      $ob->{move_off}  ||= new Crossfire::MoveType; if ($v) { $ob->{move_off}  += "fly_low" } else { $ob->{move_off}  -= "fly_low" }
+      $ob->{move_off}  ||= new Deliantra::MoveType; if ($v) { $ob->{move_off}  += "fly_low" } else { $ob->{move_off}  -= "fly_low" }
    }
    if (defined (my $v = delete $ob->{flying})) {
-      $ob->{move_type} ||= new Crossfire::MoveType; if ($v) { $ob->{move_type} += "fly_low" } else { $ob->{move_type} -= "fly_low" }
+      $ob->{move_type} ||= new Deliantra::MoveType; if ($v) { $ob->{move_type} += "fly_low" } else { $ob->{move_type} -= "fly_low" }
    }
 
    # convert idiotic event_xxx things into objects
@@ -486,7 +486,7 @@
 sub attr_freeze($) {
    my ($ob) = @_;
 
-   $ob->{attach} = Crossfire::encode_json $ob->{attach}
+   $ob->{attach} = Deliantra::encode_json $ob->{attach}
       if exists $ob->{attach};
 
    $ob
@@ -626,8 +626,8 @@
    my $append; $append = sub {
       my %a = %{$_[0]};
 
-      Crossfire::attr_freeze \%a;
-      Crossfire::normalize_arch \%a;
+      Deliantra::attr_freeze \%a;
+      Deliantra::normalize_arch \%a;
 
       # undo the bit-split we did before
       if (exists $a{attack_movement_bits_0_3} or exists $a{attack_movement_bits_4_7}) {
@@ -655,8 +655,8 @@
       my @kv;
 
       for ($a{_name} eq "map"
-           ? @Crossfire::FIELD_ORDER_MAP
-           : @Crossfire::FIELD_ORDER) {
+           ? @Deliantra::FIELD_ORDER_MAP
+           : @Deliantra::FIELD_ORDER) {
          push @kv, [$_, delete $a{$_}]
             if exists $a{$_};
       }
@@ -669,7 +669,7 @@
       for (@kv) {
          my ($k, $v) = @$_;
 
-         if (my $end = $Crossfire::FIELD_MULTILINE{$k}) {
+         if (my $end = $Deliantra::FIELD_MULTILINE{$k}) {
             $v =~ s/\n$//;
             $str .= "$k\n$v\n$end\n";
          } else {
@@ -775,7 +775,7 @@
 sub arch_attr($) {
    my ($obj) = @_;
 
-   require Crossfire::Data;
+   require Deliantra::Data;
 
    my $root;
    my $attr = { };
@@ -784,26 +784,26 @@
    my $type = $obj->{type} || $arch->{type};
 
    if ($type > 0) {
-      $root = $Crossfire::Data::ATTR{$type};
+      $root = $Deliantra::Data::ATTR{$type};
    } else {
       my %a = (%$arch, %$obj);
 
       if ($a{is_floor} && !$a{alive}) {
-         $root = $Crossfire::Data::TYPE{Floor};
+         $root = $Deliantra::Data::TYPE{Floor};
       } elsif (!$a{is_floor} && $a{alive} && !$a{tear_down}) {
-         $root = $Crossfire::Data::TYPE{"Monster & NPC"};
+         $root = $Deliantra::Data::TYPE{"Monster & NPC"};
       } elsif (!$a{is_floor} && !$a{alive} && $a{move_block}) {
-         $root = $Crossfire::Data::TYPE{Wall};
+         $root = $Deliantra::Data::TYPE{Wall};
       } elsif (!$a{is_floor} && $a{alive} && $a{tear_down}) {
-         $root = $Crossfire::Data::TYPE{"Weak Wall"};
+         $root = $Deliantra::Data::TYPE{"Weak Wall"};
       } else {
-         $root = $Crossfire::Data::TYPE{Misc};
+         $root = $Deliantra::Data::TYPE{Misc};
       }
    }
 
    my @import = ($root);
    
-   unshift @import, \%Crossfire::Data::DEFAULT_ATTR
+   unshift @import, \%Deliantra::Data::DEFAULT_ATTR
       unless $type == 116;
 
    my (%ignore);
@@ -812,7 +812,7 @@
    while (my $type = shift @import) {
       push @import,
          grep $_,
-            map $Crossfire::Data::TYPE{$_},
+            map $Deliantra::Data::TYPE{$_},
                @{$type->{import} || []};
 
       $attr->{$_} ||= $type->{$_}