主人都不等並回頭找祭師隊員問題?

不知道有沒有大大有類似問題 我祭師有設定 跟隨主人 並且有設定好 距離 跟幫打怪
但主人 有時候跑太快 超過距離 都不等 隊員  然後小黑窗就會跑出  隊員 傳密語 給 主人 (move 座標)... 但是 主人的小黑窗 只會出現 隊員 密語  但是沒有 (move 座標)這些訊息  !! 然後 還是 打自己的 都不會回頭找 隊員   請問是 哪裡 設錯...  我研究一天 快暈了0.0  希望 有大大 能貼 自己成功的範本  感謝

1# 搞笑中中豬

你去看這篇吧

http://bbs.wgun.net/thread-339718-1-1.html

看5樓的應該就ok了

現在的半殘op應該還是一樣吧

我現在沒用這樣的功能

所以不清楚現在是不是還一樣

你試試看吧

大大 我2.07的 在receive pm 裡面 找不到009A .... 他有說 他那是2.06板的

主人不回頭 尋找 隊員   是因為   看不到 隊員 密頻嗎= =?..

3# 搞笑中中豬

我之前也是用07版的

我也是照他上面那樣設定就ok了

所以07版的也有...........

你有用搜尋去找嗎

還是你找錯檔了............

我剛剛又去找了

我確定是有的..........

確定一下吧

他那個應該就是看不到密頻的內容

所以他才會不知道你要他做什麼動作

那當然就不會回去找補師...........

3# 搞笑中中豬

噁..............

我發現你找錯東西了

我不是要你看5樓的回文嗎???

不是009A.............

他有說是0097.........

傻眼

你的名子取得真好

真的是在搞笑.........

請看清楚

不然白忙一場............

ㄆㄆ 拍謝@@   樓上的大大  真是好心人 感謝您

#########################################################################
#  OpenKore - Server message parsing
#
#  This software is open source, licensed under the GNU General Public
#  License, version 2.
#  Basically, this means that you're allowed to modify and distribute
#  this software. However, if you distribute modified versions, you MUST
#  also distribute the source code.
#  See http://www.gnu.org/licenses/gpl.html for the full license.
#########################################################################
##
# MODULE DESCRIPTION: Server message parsing
#
# This class is responsible for parsing messages that are sent by the RO
# server to Kore. Information in the messages are stored in global variables
# (in the module Globals).
#
# Please also read <a href="http://www.openkore.com/wiki/index.php/Network_subsystem">the
# network subsystem overview.</a>
package Network::Receive;

use strict;
use encoding 'utf8';
use Carp::Assert;
use Scalar::Util;

use Exception::Class ('Network::Receive::InvalidServerType', 'Network::Receive::CreationError');

use Globals;
#use Settings;
use Log qw(message warning error debug);
#use FileParsers;
use Interface;
use Network;
use Network::MessageTokenizer;
use Misc;
use Plugins;
use Utils;
use Utils::Exceptions;
use Utils::Crypton;
use Translation;

######################################
### Public methods
######################################

# Do not call this directly. Use create() instead.
sub new {
        my ($class) = @_;
        my $self;

        # If you are wondering about those funny strings like 'x2 v1' read http://perldoc.perl.org/functions/pack.html
        # and http://perldoc.perl.org/perlpacktut.html

        # Defines a list of Packet Handlers and decoding information
        # 'packetSwitch' => ['handler function','unpack string',[qw(argument names)]]

        $self->{packet_list} = {};

        return bless $self, $class;
}

##
# Network::Receive->create(String serverType)
#
# Create a new server message parsing object for the specified server type.
#
# Throws Network::Receive::InvalidServerType if the specified server type does
# not exist.
# Throws Network::Receive::CreationError if some other error occured.
sub create {
        my ($self, $serverType) = @_;
       
        my ($mode, $type, $param) = Settings::parseServerType ($serverType);
        my $class = "Network::Receive::$type" . ($param ? "::$param" : ""); #param like Thor in bRO_Thor
       
        debug "[ST recv] $class ". " (mode: " . ($mode ? "new" : "old") .")\n";

        undef $@;
        eval("use $class;");
        if ($@ =~ /^Can't locate /s) {
                Network::Receive::InvalidServerType->throw(
                        TF("Cannot load server message parser for server type '%s'.", $type)
                );
        } elsif ($@) {
                Network::Receive::CreationError->throw(
                        TF("An error occured while loading the server message parser for server type '%s':\n%s",
                                $type, $@)
                );
        }
       
        my $self = $class->new;
       
        if ($Settings::sys{devel_networkReceiveHooks}) {
                # hook all handlers from Network::Receive::* for compatibility
                # (if/when all handlers will be moved out of Network, this could be removed)
               
                # TODO: some way of handling only packets that are not handled by any plugins?
                my @handlers = grep { $self->can ($_) } keys %{{map { $_->[0] => 1 } values %{$self->{packet_list}}}};
               
                if (@handlers) {
                        debug TF("Adding hooks for packet handlers in %s: %s\n", $class, join ', ', @handlers), 'network_compatibility';
                       
                        Scalar::Util::weaken (my $weakSelf = $self);
                       
                        my $handler = sub {
                                my (undef, $args, $callback) = @_;
                               
                                $weakSelf->$callback ($args);
                                $args->{return} = 1;
                        };
                       
                        $self->{recvpacketHandleHooks} = Plugins::addHooks (map { ["packet_handle/$_", $handler, $_] } @handlers);
                }
        }
       
        return $self;
}

sub DESTROY {
        my ($self) = @_;
       
        if ($Settings::sys{devel_networkReceiveHooks} && $self->{recvpacketHandleHooks}) {
                debug T("Removing hooks for packet handlers in Network::Receive\n"), 'network_compatibility';
               
                Plugins::delHooks ($self->{recvpacketHandleHooks});
        }
}

# $packetParser->reconstruct($args)
#
# Reconstructs a raw packet from $args using $self->{packet_list}.
sub reconstruct {
        my ($self, $args) = @_;

        my $switch = $args->{switch};
        my $packet = $self->{packet_list}{$switch};
        my ($name, $packString, $varNames) = @{$packet};

        my @vars = ();
        for my $varName (@{$varNames}) {
                push(@vars, $args->{$varName});
        }
        my $packet = pack("H2 H2 $packString", substr($switch, 2, 2), substr($switch, 0, 2), @vars);
        return $packet;
}

sub parse {
        my ($self, $msg) = @_;

        $bytesReceived += length($msg);
        my $switch = Network::MessageTokenizer::getMessageID($msg);
        my $handler = $self->{packet_list}{$switch};

        unless ($handler) {
                warning "Packet Parser: Unk●嚴禁張貼廣告●n switch: $switch\n";
                return undef;
        }

        debug "Received packet: $switch Handler: $handler->[0]\n", "packetParser", 2;

        # RAW_MSG is the entire message, including packet switch
        my %args = (
                switch => $switch,
                RAW_MSG => $msg,
                RAW_MSG_SIZE => length($msg),
                KEYS => $handler->[2],
        );
        if ($handler->[1]) {
                my @unpacked_data = unpack("x2 $handler->[1]", $msg);
                foreach my $key (@{$handler->[2]}) {
                        $args{$key} = shift @unpacked_data;
                }
        }

        if ($Settings::sys{devel_networkReceiveHooks}) {
                Plugins::callHook("packet_pre/$handler->[0]", \%args);
                Misc::checkValidity("Packet: " . $handler->[0] . " (pre)");
                unless ($args{return}) {
                        if (Plugins::hasHook("packet_handle/$handler->[0]", \%args)) {
                                Plugins::callHook("packet_handle/$handler->[0]", \%args);
                                Misc::checkValidity("Packet: " . $handler->[0]);
                        } else {
                                warning "Packet Parser: Unhandled Packet: $switch Handler: $handler->[0]\n";
                                debug ("Unpacked: " . join(', ', @{\%args}{@{$handler->[2]}}) . "\n"), "packetParser", 2 if $handler->[2];
                        }
                }
        } else {
                my $callback = $self->can($handler->[0]);
                if ($callback) {
                        Plugins::callHook("packet_pre/$handler->[0]", \%args);
                        Misc::checkValidity("Packet: " . $handler->[0] . " (pre)");
                        $self->$callback(\%args);
                        Misc::checkValidity("Packet: " . $handler->[0]);
                } else {
                        warning "Packet Parser: Unhandled Packet: $switch Handler: $handler->[0]\n";
                        debug ("Unpacked: " . join(', ', @{\%args}{@{$handler->[2]}}) . "\n"), "packetParser", 2 if $handler->[2];
                }
        }

        Plugins::callHook("packet/$handler->[0]", \%args);
        return \%args;
}

##
# boolean $packetParser->willMangle(Bytes messageID)
# messageID: a message ID, such as "008A".
#
# Check whether the message with the specified message ID will be mangled.
# If the bot is running in X-Kore mode, then messages that will be mangled will not
# be sent to the RO client.
#
# By default, a message will never be mangled. Plugins can register mangling procedures
# though. This is done by using the following hooks:
# `l
# - "Network::Receive/willMangle" - This hook has arguments 'messageID' (Bytes) and 'name' (String).
#          'name' is a human-readable description of the message, and may be undef. Plugins
#          should set the 'return' argument to 1 if they want willMangle() to return 1.
# - "Network::Receive/mangle" - This hook has arguments 'messageArgs' and 'messageName' (the latter may be undef).
# `l`
# The following example demonstrates how this is done:
# <pre class="example">
# Plugins::addHook("Network::Receive/willMangle", \&willMangle);
# Plugins::addHook("Network::Receive/mangle", \&mangle);
#
# sub willMangle {
#     my (undef, $args) = @_;
#     if ($args->{messageID} eq '008A') {
#         $args->{willMangle} = 1;
#     }
# }
#
# sub mangle {
#     my (undef, $args) = @_;
#     my $message_args = $args->{messageArgs};
#     if ($message_args->{switch} eq '008A') {
#         ...Modify $message_args as necessary....
#     }
# }
# </pre>
sub willMangle {
        if (Plugins::hasHook("Network::Receive/willMangle")) {
                my ($self, $messageID) = @_;
                my $packet = $self->{packet_list}{$messageID};
                my $name;
                $name = $packet->[0] if ($packet);

                my %args = (
                        messageID => $messageID,
                        name => $name
                );
                Plugins::callHook("Network::Receive/willMangle", \%args);
                return $args{return};
        } else {
                return undef;
        }
}

# boolean $packetParser->mangle(Array* args)
#
# Calls the appropriate plugin function to mangle the packet, which
# destructively modifies $args.
# Returns false if the packet should be suppressed.
sub mangle {
        my ($self, $args) = @_;

        my %hook_args = (messageArgs => $args);
        my $entry = $self->{packet_list}{$args->{switch}};
        if ($entry) {
                $hook_args{messageName} = $entry->[0];
        }

        Plugins::callHook("Network::Receive/mangle", \%hook_args);
        return $hook_args{return};
}

##
# Network::Receive->decrypt(r_msg, themsg)
# r_msg: a reference to a scalar.
# themsg: the message to decrypt.
#
# Decrypts the packets in $themsg and put the result in the scalar
# referenced by $r_msg.
#
# This is an old method used back in the iRO beta 2 days when iRO had encrypted packets.
# At the moment (December 20 2006) there are no servers that still use encrypted packets.
#
# Example:
# } elsif ($switch eq "ABCD") {
#         my $level;
#         Network::Receive->decrypt(\$level, substr($msg, 0, 2));
sub decrypt {
        use bytes;
        my ($self, $r_msg, $themsg) = @_;
        my @mask;
        my $i;
        my ($temp, $msg_temp, $len_add, $len_total, $loopin, $len, $val);
        if ($config{encrypt} == 1) {
                undef $$r_msg;
                undef $len_add;
                undef $msg_temp;
                for ($i = 0; $i < 13;$i++) {
                        $mask[$i] = 0;
                }
                $len = unpack("v1",substr($themsg,0,2));
                $val = unpack("v1",substr($themsg,2,2));
                {
                        use integer;
                        $temp = ($val * $val * 1391);
                }
                $temp = ~(~($temp));
                $temp = $temp % 13;
                $mask[$temp] = 1;
                {
                        use integer;
                        $temp = $val * 1397;
                }
                $temp = ~(~($temp));
                $temp = $temp % 13;
                $mask[$temp] = 1;
                for($loopin = 0; ($loopin + 4) < $len; $loopin++) {
                        if (!($mask[$loopin % 13])) {
                                  $msg_temp .= substr($themsg,$loopin + 4,1);
                        }
                }
                if (($len - 4) % 8 != 0) {
                        $len_add = 8 - (($len - 4) % 8);
                }
                $len_total = $len + $len_add;
                $$r_msg = $msg_temp.substr($themsg, $len_total, length($themsg) - $len_total);
        } elsif ($config{encrypt} >= 2) {
                undef $$r_msg;
                undef $len_add;
                undef $msg_temp;
                for ($i = 0; $i < 17;$i++) {
                        $mask[$i] = 0;
                }
                $len = unpack("v1",substr($themsg,0,2));
                $val = unpack("v1",substr($themsg,2,2));
                {
                        use integer;
                        $temp = ($val * $val * 34953);
                }
                $temp = ~(~($temp));
                $temp = $temp % 17;
                $mask[$temp] = 1;
                {
                        use integer;
                        $temp = $val * 2341;
                }
                $temp = ~(~($temp));
                $temp = $temp % 17;
                $mask[$temp] = 1;
                for($loopin = 0; ($loopin + 4) < $len; $loopin++) {
                        if (!($mask[$loopin % 17])) {
                                  $msg_temp .= substr($themsg,$loopin + 4,1);
                        }
                }
                if (($len - 4) % 8 != 0) {
                        $len_add = 8 - (($len - 4) % 8);
                }
                $len_total = $len + $len_add;
                $$r_msg = $msg_temp.substr($themsg, $len_total, length($themsg) - $len_total);
        } else {
                $$r_msg = $themsg;
        }
}


#######################################
###### Private methods
#######################################

sub queryLoginPinCode {
        my $message = $_[0] || T("You've never set a login PIN code before.\nPlease enter a new login PIN code:");
        do {
                my $input = $interface->query($message, isPassword => 1,);
                if (!defined($input)) {
                        quit();
                        return;
                } else {
                        if ($input !~ /^\d+$/) {
                                $interface->errorDialog(T("The PIN code may only contain digits."));
                        } elsif ((length($input) <= 3) || (length($input) >= 9)) {
                                $interface->errorDialog(T("The PIN code must be between 4 and 9 characters."));
                        } else {
                                return $input;
                        }
                }
        } while (1);
}

sub queryAndSaveLoginPinCode {
        my ($self, $message) = @_;
        my $pin = queryLoginPinCode($message);
        if (defined $pin) {
                configModify('loginPinCode', $pin, silent => 1);
                return 1;
        } else {
                return 0;
        }
}

1;

我記的  半殘版本   好像可以收到密語

但是會不會回去找補師,好像不會呢

我把他全部複製下來 = =  一樣 搜尋不到 0097 .... 好怪

這一版確實找不到
但是我現在用起來還是可以收到密語