// **********************************************************************
//
// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
//
// Ice version 3.6.4
//
// <auto-generated>
//
// Generated from file `ZoneManager.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//


using _System = global::System;
using _Microsoft = global::Microsoft;

#pragma warning disable 1591

namespace IceCompactId
{
}

namespace BattleIce
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
    public partial interface ZoneManagerCallback : Ice.Object, ZoneManagerCallbackOperations_, ZoneManagerCallbackOperationsNC_
    {
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1715")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1720")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1722")]
    [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724")]
    public partial interface ZoneManager : Ice.Object, ZoneManagerOperations_, ZoneManagerOperationsNC_
    {
    }
}

namespace BattleIce
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManagerCallback_eventNotify();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_setCallback(int ret__);

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_createZoneRequest(int ret__);

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_destroyZoneRequest();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_clearAllPlayersRequest();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_getAllPlayerCountRequest(int ret__);

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_playerEnterRequest();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_playerLeaveRequest();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_playerNetStateChanged();

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_getServerState(string ret__);

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_registerGameServer(string ret__);

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public delegate void Callback_ZoneManager_getUnitHP(int ret__);
}

namespace BattleIce
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface ZoneManagerCallbackPrx : Ice.ObjectPrx
    {
        void eventNotify(string eventType, string msg);

        void eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg);

        Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_eventNotify(string eventType, string msg, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_eventNotify(Ice.AsyncResult r__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface ZoneManagerPrx : Ice.ObjectPrx
    {
        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        
        int setCallback(Ice.Identity ident, string srvUUID);

        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        
        int setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__);

        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID);

        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__);

        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, Ice.AsyncCallback cb__, object cookie__);

        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <param name="r__">The asynchronous result object for the invocation.</param>
        int end_setCallback(Ice.AsyncResult r__);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        
        int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        
        int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.AsyncCallback cb__, object cookie__);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="r__">The asynchronous result object for the invocation.</param>
        int end_createZoneRequest(Ice.AsyncResult r__);

        void destroyZoneRequest(string instanceId);

        void destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_destroyZoneRequest(string instanceId, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_destroyZoneRequest(Ice.AsyncResult r__);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        
        void clearAllPlayersRequest();

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        
        void clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest();

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult begin_clearAllPlayersRequest(Ice.AsyncCallback cb__, object cookie__);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="ctx__">The Context map to send with the invocation.</param>
        /// <param name="cb__">Asynchronous callback invoked when the operation completes.</param>
        /// <param name="cookie__">Application data to store in the asynchronous result object.</param>
        /// <returns>An asynchronous result object.</returns>
        Ice.AsyncResult begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="r__">The asynchronous result object for the invocation.</param>
        void end_clearAllPlayersRequest(Ice.AsyncResult r__);

        int getAllPlayerCountRequest();

        int getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest();

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_getAllPlayerCountRequest(Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        int end_getAllPlayerCountRequest(Ice.AsyncResult r__);

        void playerEnterRequest(string playerId, string instanceId, string data);

        void playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_playerEnterRequest(Ice.AsyncResult r__);

        void playerLeaveRequest(string playerId, string instanceId, bool keepObject);

        void playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_playerLeaveRequest(Ice.AsyncResult r__);

        void playerNetStateChanged(string playerId, string state);

        void playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        void end_playerNetStateChanged(Ice.AsyncResult r__);

        string getServerState(string serverId);

        string getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_getServerState(string serverId, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        string end_getServerState(Ice.AsyncResult r__);

        string registerGameServer(int serverid, int crossid);

        string registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        string end_registerGameServer(Ice.AsyncResult r__);

        int getUnitHP(string instanceId, int objectId);

        int getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId);

        Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__);

        Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, Ice.AsyncCallback cb__, object cookie__);

        Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__);

        int end_getUnitHP(Ice.AsyncResult r__);
    }
}

namespace BattleIce
{
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface ZoneManagerCallbackOperations_
    {
        void eventNotify(string eventType, string msg, Ice.Current current__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface ZoneManagerCallbackOperationsNC_
    {
        void eventNotify(string eventType, string msg);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface ZoneManagerOperations_
    {
        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        /// <param name="current__">The Current object for the invocation.</param>
        
        int setCallback(Ice.Identity ident, string srvUUID, Ice.Current current__);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="cb__">The callback object for the operation.</param>
        /// <param name="current__">The Current object for the invocation.</param>
        void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.Current current__);

        void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId, Ice.Current current__);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="cb__">The callback object for the operation.</param>
        /// <param name="current__">The Current object for the invocation.</param>
        void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__, Ice.Current current__);

        void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__, Ice.Current current__);

        void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data, Ice.Current current__);

        void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject, Ice.Current current__);

        void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state, Ice.Current current__);

        void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId, Ice.Current current__);

        void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid, Ice.Current current__);

        void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId, Ice.Current current__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface ZoneManagerOperationsNC_
    {
        /// <summary>
        /// 场景管理器相关协议
        /// </summary>
        
        int setCallback(Ice.Identity ident, string srvUUID);

        /// <summary>
        /// 场景副本相关协议
        /// </summary>
        /// <param name="cb__">The callback object for the operation.</param>
        void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data);

        void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId);

        /// <summary>
        /// 玩家相关协议
        /// </summary>
        /// <param name="cb__">The callback object for the operation.</param>
        void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__);

        void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__);

        void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data);

        void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject);

        void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state);

        void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId);

        void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid);

        void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId);
    }
}

namespace BattleIce
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public sealed class ZoneManagerCallbackPrxHelper : Ice.ObjectPrxHelperBase, ZoneManagerCallbackPrx
    {
        #region Synchronous operations

        public void eventNotify(string eventType, string msg)
        {
            this.eventNotify(eventType, msg, null, false);
        }

        public void eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            this.eventNotify(eventType, msg, ctx__, true);
        }

        private void eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            end_eventNotify(begin_eventNotify(eventType, msg, context__, explicitCtx__, true, null, null));
        }

        #endregion

        #region Asynchronous operations

        public Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg)
        {
            return begin_eventNotify(eventType, msg, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_eventNotify(eventType, msg, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_eventNotify(string eventType, string msg, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_eventNotify(eventType, msg, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_eventNotify(eventType, msg, ctx__, true, false, cb__, cookie__);
        }

        private const string __eventNotify_name = "eventNotify";

        public void end_eventNotify(Ice.AsyncResult r__)
        {
            end__(r__, __eventNotify_name);
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManagerCallback_eventNotify> begin_eventNotify(string eventType, string msg, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManagerCallback_eventNotify> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManagerCallback_eventNotify>(__eventNotify_name, eventNotify_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__eventNotify_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(eventType);
                os__.writeString(msg);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void eventNotify_completed__(BattleIce.Callback_ZoneManagerCallback_eventNotify cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        #endregion

        #region Checked and unchecked cast operations

        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ZoneManagerCallbackPrx r = b as ZoneManagerCallbackPrx;
            if((r == null) && b.ice_isA(ice_staticId()))
            {
                ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            ZoneManagerCallbackPrx r = b as ZoneManagerCallbackPrx;
            if((r == null) && b.ice_isA(ice_staticId(), ctx))
            {
                ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId()))
                {
                    ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ZoneManagerCallbackPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId(), ctx))
                {
                    ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ZoneManagerCallbackPrx uncheckedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ZoneManagerCallbackPrx r = b as ZoneManagerCallbackPrx;
            if(r == null)
            {
                ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ZoneManagerCallbackPrx uncheckedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            ZoneManagerCallbackPrxHelper h = new ZoneManagerCallbackPrxHelper();
            h.copyFrom__(bb);
            return h;
        }

        public static readonly string[] ids__ =
        {
            "::BattleIce::ZoneManagerCallback",
            "::Ice::Object"
        };

        public static string ice_staticId()
        {
            return ids__[0];
        }

        #endregion

        #region Marshaling support

        public static void write__(IceInternal.BasicStream os__, ZoneManagerCallbackPrx v__)
        {
            os__.writeProxy(v__);
        }

        public static ZoneManagerCallbackPrx read__(IceInternal.BasicStream is__)
        {
            Ice.ObjectPrx proxy = is__.readProxy();
            if(proxy != null)
            {
                ZoneManagerCallbackPrxHelper result = new ZoneManagerCallbackPrxHelper();
                result.copyFrom__(proxy);
                return result;
            }
            return null;
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public sealed class ZoneManagerPrxHelper : Ice.ObjectPrxHelperBase, ZoneManagerPrx
    {
        #region Synchronous operations

        public void clearAllPlayersRequest()
        {
            this.clearAllPlayersRequest(null, false);
        }

        public void clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            this.clearAllPlayersRequest(ctx__, true);
        }

        private void clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            end_clearAllPlayersRequest(begin_clearAllPlayersRequest(context__, explicitCtx__, true, null, null));
        }

        public int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data)
        {
            return this.createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, null, false);
        }

        public int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return this.createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, ctx__, true);
        }

        private int createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            checkTwowayOnly__(__createZoneRequest_name);
            return end_createZoneRequest(begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, context__, explicitCtx__, true, null, null));
        }

        public void destroyZoneRequest(string instanceId)
        {
            this.destroyZoneRequest(instanceId, null, false);
        }

        public void destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            this.destroyZoneRequest(instanceId, ctx__, true);
        }

        private void destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            end_destroyZoneRequest(begin_destroyZoneRequest(instanceId, context__, explicitCtx__, true, null, null));
        }

        public int getAllPlayerCountRequest()
        {
            return this.getAllPlayerCountRequest(null, false);
        }

        public int getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return this.getAllPlayerCountRequest(ctx__, true);
        }

        private int getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            checkTwowayOnly__(__getAllPlayerCountRequest_name);
            return end_getAllPlayerCountRequest(begin_getAllPlayerCountRequest(context__, explicitCtx__, true, null, null));
        }

        public string getServerState(string serverId)
        {
            return this.getServerState(serverId, null, false);
        }

        public string getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return this.getServerState(serverId, ctx__, true);
        }

        private string getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            checkTwowayOnly__(__getServerState_name);
            return end_getServerState(begin_getServerState(serverId, context__, explicitCtx__, true, null, null));
        }

        public int getUnitHP(string instanceId, int objectId)
        {
            return this.getUnitHP(instanceId, objectId, null, false);
        }

        public int getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return this.getUnitHP(instanceId, objectId, ctx__, true);
        }

        private int getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            checkTwowayOnly__(__getUnitHP_name);
            return end_getUnitHP(begin_getUnitHP(instanceId, objectId, context__, explicitCtx__, true, null, null));
        }

        public void playerEnterRequest(string playerId, string instanceId, string data)
        {
            this.playerEnterRequest(playerId, instanceId, data, null, false);
        }

        public void playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            this.playerEnterRequest(playerId, instanceId, data, ctx__, true);
        }

        private void playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            end_playerEnterRequest(begin_playerEnterRequest(playerId, instanceId, data, context__, explicitCtx__, true, null, null));
        }

        public void playerLeaveRequest(string playerId, string instanceId, bool keepObject)
        {
            this.playerLeaveRequest(playerId, instanceId, keepObject, null, false);
        }

        public void playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            this.playerLeaveRequest(playerId, instanceId, keepObject, ctx__, true);
        }

        private void playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            end_playerLeaveRequest(begin_playerLeaveRequest(playerId, instanceId, keepObject, context__, explicitCtx__, true, null, null));
        }

        public void playerNetStateChanged(string playerId, string state)
        {
            this.playerNetStateChanged(playerId, state, null, false);
        }

        public void playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            this.playerNetStateChanged(playerId, state, ctx__, true);
        }

        private void playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            end_playerNetStateChanged(begin_playerNetStateChanged(playerId, state, context__, explicitCtx__, true, null, null));
        }

        public string registerGameServer(int serverid, int crossid)
        {
            return this.registerGameServer(serverid, crossid, null, false);
        }

        public string registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return this.registerGameServer(serverid, crossid, ctx__, true);
        }

        private string registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            checkTwowayOnly__(__registerGameServer_name);
            return end_registerGameServer(begin_registerGameServer(serverid, crossid, context__, explicitCtx__, true, null, null));
        }

        public int setCallback(Ice.Identity ident, string srvUUID)
        {
            return this.setCallback(ident, srvUUID, null, false);
        }

        public int setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return this.setCallback(ident, srvUUID, ctx__, true);
        }

        private int setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> context__, bool explicitCtx__)
        {
            checkTwowayOnly__(__setCallback_name);
            return end_setCallback(begin_setCallback(ident, srvUUID, context__, explicitCtx__, true, null, null));
        }

        #endregion

        #region Asynchronous operations

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest()
        {
            return begin_clearAllPlayersRequest(null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_clearAllPlayersRequest(ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_clearAllPlayersRequest(Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_clearAllPlayersRequest(null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_clearAllPlayersRequest(ctx__, true, false, cb__, cookie__);
        }

        private const string __clearAllPlayersRequest_name = "clearAllPlayersRequest";

        public void end_clearAllPlayersRequest(Ice.AsyncResult r__)
        {
            end__(r__, __clearAllPlayersRequest_name);
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> begin_clearAllPlayersRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_clearAllPlayersRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_clearAllPlayersRequest>(__clearAllPlayersRequest_name, clearAllPlayersRequest_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__clearAllPlayersRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                result__.writeEmptyParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void clearAllPlayersRequest_completed__(BattleIce.Callback_ZoneManager_clearAllPlayersRequest cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data)
        {
            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_createZoneRequest(playerId, gameServerId, mapTemplateId, instanceId, force, data, ctx__, true, false, cb__, cookie__);
        }

        private const string __createZoneRequest_name = "createZoneRequest";

        public int end_createZoneRequest(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __createZoneRequest_name);
            try
            {
                if(!outAsync__.wait())
                {
                    try
                    {
                        outAsync__.throwUserException();
                    }
                    catch(Ice.UserException ex__)
                    {
                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                    }
                }
                int ret__;
                IceInternal.BasicStream is__ = outAsync__.startReadParams();
                ret__ = is__.readInt();
                outAsync__.endReadParams();
                return ret__;
            }
            finally
            {
                outAsync__.cacheMessageBuffers();
            }
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_createZoneRequest> begin_createZoneRequest(string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            checkAsyncTwowayOnly__(__createZoneRequest_name);
            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_createZoneRequest> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_createZoneRequest>(__createZoneRequest_name, createZoneRequest_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__createZoneRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(playerId);
                os__.writeString(gameServerId);
                os__.writeInt(mapTemplateId);
                os__.writeString(instanceId);
                os__.writeBool(force);
                os__.writeString(data);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void createZoneRequest_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_createZoneRequest cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;
            try
            {
                ret__ = end_createZoneRequest(r__);
            }
            catch(Ice.Exception ex__)
            {
                if(excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if(cb__ != null)
            {
                cb__(ret__);
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId)
        {
            return begin_destroyZoneRequest(instanceId, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_destroyZoneRequest(instanceId, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_destroyZoneRequest(string instanceId, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_destroyZoneRequest(instanceId, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_destroyZoneRequest(instanceId, ctx__, true, false, cb__, cookie__);
        }

        private const string __destroyZoneRequest_name = "destroyZoneRequest";

        public void end_destroyZoneRequest(Ice.AsyncResult r__)
        {
            end__(r__, __destroyZoneRequest_name);
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_destroyZoneRequest> begin_destroyZoneRequest(string instanceId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_destroyZoneRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_destroyZoneRequest>(__destroyZoneRequest_name, destroyZoneRequest_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__destroyZoneRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(instanceId);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void destroyZoneRequest_completed__(BattleIce.Callback_ZoneManager_destroyZoneRequest cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest()
        {
            return begin_getAllPlayerCountRequest(null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_getAllPlayerCountRequest(ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_getAllPlayerCountRequest(Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_getAllPlayerCountRequest(null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_getAllPlayerCountRequest(ctx__, true, false, cb__, cookie__);
        }

        private const string __getAllPlayerCountRequest_name = "getAllPlayerCountRequest";

        public int end_getAllPlayerCountRequest(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getAllPlayerCountRequest_name);
            try
            {
                if(!outAsync__.wait())
                {
                    try
                    {
                        outAsync__.throwUserException();
                    }
                    catch(Ice.UserException ex__)
                    {
                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                    }
                }
                int ret__;
                IceInternal.BasicStream is__ = outAsync__.startReadParams();
                ret__ = is__.readInt();
                outAsync__.endReadParams();
                return ret__;
            }
            finally
            {
                outAsync__.cacheMessageBuffers();
            }
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> begin_getAllPlayerCountRequest(_System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            checkAsyncTwowayOnly__(__getAllPlayerCountRequest_name);
            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getAllPlayerCountRequest>(__getAllPlayerCountRequest_name, getAllPlayerCountRequest_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__getAllPlayerCountRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                result__.writeEmptyParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void getAllPlayerCountRequest_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_getAllPlayerCountRequest cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;
            try
            {
                ret__ = end_getAllPlayerCountRequest(r__);
            }
            catch(Ice.Exception ex__)
            {
                if(excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if(cb__ != null)
            {
                cb__(ret__);
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId)
        {
            return begin_getServerState(serverId, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_getServerState(serverId, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_getServerState(string serverId, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_getServerState(serverId, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_getServerState(serverId, ctx__, true, false, cb__, cookie__);
        }

        private const string __getServerState_name = "getServerState";

        public string end_getServerState(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getServerState_name);
            try
            {
                if(!outAsync__.wait())
                {
                    try
                    {
                        outAsync__.throwUserException();
                    }
                    catch(Ice.UserException ex__)
                    {
                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                    }
                }
                string ret__;
                IceInternal.BasicStream is__ = outAsync__.startReadParams();
                ret__ = is__.readString();
                outAsync__.endReadParams();
                return ret__;
            }
            finally
            {
                outAsync__.cacheMessageBuffers();
            }
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_getServerState> begin_getServerState(string serverId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            checkAsyncTwowayOnly__(__getServerState_name);
            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getServerState> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getServerState>(__getServerState_name, getServerState_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__getServerState_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(serverId);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void getServerState_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_getServerState cb__, Ice.ExceptionCallback excb__)
        {
            string ret__;
            try
            {
                ret__ = end_getServerState(r__);
            }
            catch(Ice.Exception ex__)
            {
                if(excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if(cb__ != null)
            {
                cb__(ret__);
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId)
        {
            return begin_getUnitHP(instanceId, objectId, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_getUnitHP(instanceId, objectId, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_getUnitHP(instanceId, objectId, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_getUnitHP(instanceId, objectId, ctx__, true, false, cb__, cookie__);
        }

        private const string __getUnitHP_name = "getUnitHP";

        public int end_getUnitHP(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __getUnitHP_name);
            try
            {
                if(!outAsync__.wait())
                {
                    try
                    {
                        outAsync__.throwUserException();
                    }
                    catch(Ice.UserException ex__)
                    {
                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                    }
                }
                int ret__;
                IceInternal.BasicStream is__ = outAsync__.startReadParams();
                ret__ = is__.readInt();
                outAsync__.endReadParams();
                return ret__;
            }
            finally
            {
                outAsync__.cacheMessageBuffers();
            }
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_getUnitHP> begin_getUnitHP(string instanceId, int objectId, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            checkAsyncTwowayOnly__(__getUnitHP_name);
            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getUnitHP> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_getUnitHP>(__getUnitHP_name, getUnitHP_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__getUnitHP_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(instanceId);
                os__.writeInt(objectId);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void getUnitHP_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_getUnitHP cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;
            try
            {
                ret__ = end_getUnitHP(r__);
            }
            catch(Ice.Exception ex__)
            {
                if(excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if(cb__ != null)
            {
                cb__(ret__);
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data)
        {
            return begin_playerEnterRequest(playerId, instanceId, data, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_playerEnterRequest(playerId, instanceId, data, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_playerEnterRequest(playerId, instanceId, data, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_playerEnterRequest(playerId, instanceId, data, ctx__, true, false, cb__, cookie__);
        }

        private const string __playerEnterRequest_name = "playerEnterRequest";

        public void end_playerEnterRequest(Ice.AsyncResult r__)
        {
            end__(r__, __playerEnterRequest_name);
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerEnterRequest> begin_playerEnterRequest(string playerId, string instanceId, string data, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerEnterRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerEnterRequest>(__playerEnterRequest_name, playerEnterRequest_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__playerEnterRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(playerId);
                os__.writeString(instanceId);
                os__.writeString(data);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void playerEnterRequest_completed__(BattleIce.Callback_ZoneManager_playerEnterRequest cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject)
        {
            return begin_playerLeaveRequest(playerId, instanceId, keepObject, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_playerLeaveRequest(playerId, instanceId, keepObject, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_playerLeaveRequest(playerId, instanceId, keepObject, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_playerLeaveRequest(playerId, instanceId, keepObject, ctx__, true, false, cb__, cookie__);
        }

        private const string __playerLeaveRequest_name = "playerLeaveRequest";

        public void end_playerLeaveRequest(Ice.AsyncResult r__)
        {
            end__(r__, __playerLeaveRequest_name);
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerLeaveRequest> begin_playerLeaveRequest(string playerId, string instanceId, bool keepObject, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerLeaveRequest> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerLeaveRequest>(__playerLeaveRequest_name, playerLeaveRequest_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__playerLeaveRequest_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(playerId);
                os__.writeString(instanceId);
                os__.writeBool(keepObject);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void playerLeaveRequest_completed__(BattleIce.Callback_ZoneManager_playerLeaveRequest cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state)
        {
            return begin_playerNetStateChanged(playerId, state, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_playerNetStateChanged(playerId, state, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_playerNetStateChanged(playerId, state, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_playerNetStateChanged(playerId, state, ctx__, true, false, cb__, cookie__);
        }

        private const string __playerNetStateChanged_name = "playerNetStateChanged";

        public void end_playerNetStateChanged(Ice.AsyncResult r__)
        {
            end__(r__, __playerNetStateChanged_name);
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_playerNetStateChanged> begin_playerNetStateChanged(string playerId, string state, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            IceInternal.OnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerNetStateChanged> result__ = getOnewayOutgoingAsync<BattleIce.Callback_ZoneManager_playerNetStateChanged>(__playerNetStateChanged_name, playerNetStateChanged_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__playerNetStateChanged_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeString(playerId);
                os__.writeString(state);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void playerNetStateChanged_completed__(BattleIce.Callback_ZoneManager_playerNetStateChanged cb__)
        {
            if(cb__ != null)
            {
                cb__();
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid)
        {
            return begin_registerGameServer(serverid, crossid, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_registerGameServer(serverid, crossid, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_registerGameServer(serverid, crossid, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_registerGameServer(serverid, crossid, ctx__, true, false, cb__, cookie__);
        }

        private const string __registerGameServer_name = "registerGameServer";

        public string end_registerGameServer(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __registerGameServer_name);
            try
            {
                if(!outAsync__.wait())
                {
                    try
                    {
                        outAsync__.throwUserException();
                    }
                    catch(Ice.UserException ex__)
                    {
                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                    }
                }
                string ret__;
                IceInternal.BasicStream is__ = outAsync__.startReadParams();
                ret__ = is__.readString();
                outAsync__.endReadParams();
                return ret__;
            }
            finally
            {
                outAsync__.cacheMessageBuffers();
            }
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_registerGameServer> begin_registerGameServer(int serverid, int crossid, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            checkAsyncTwowayOnly__(__registerGameServer_name);
            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_registerGameServer> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_registerGameServer>(__registerGameServer_name, registerGameServer_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__registerGameServer_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                os__.writeInt(serverid);
                os__.writeInt(crossid);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void registerGameServer_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_registerGameServer cb__, Ice.ExceptionCallback excb__)
        {
            string ret__;
            try
            {
                ret__ = end_registerGameServer(r__);
            }
            catch(Ice.Exception ex__)
            {
                if(excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if(cb__ != null)
            {
                cb__(ret__);
            }
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID)
        {
            return begin_setCallback(ident, srvUUID, null, false, false, null, null);
        }

        public Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__)
        {
            return begin_setCallback(ident, srvUUID, ctx__, true, false, null, null);
        }

        public Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_setCallback(ident, srvUUID, null, false, false, cb__, cookie__);
        }

        public Ice.AsyncResult begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__, Ice.AsyncCallback cb__, object cookie__)
        {
            return begin_setCallback(ident, srvUUID, ctx__, true, false, cb__, cookie__);
        }

        private const string __setCallback_name = "setCallback";

        public int end_setCallback(Ice.AsyncResult r__)
        {
            IceInternal.OutgoingAsync outAsync__ = IceInternal.OutgoingAsync.check(r__, this, __setCallback_name);
            try
            {
                if(!outAsync__.wait())
                {
                    try
                    {
                        outAsync__.throwUserException();
                    }
                    catch(Ice.UserException ex__)
                    {
                        throw new Ice.UnknownUserException(ex__.ice_name(), ex__);
                    }
                }
                int ret__;
                IceInternal.BasicStream is__ = outAsync__.startReadParams();
                ret__ = is__.readInt();
                outAsync__.endReadParams();
                return ret__;
            }
            finally
            {
                outAsync__.cacheMessageBuffers();
            }
        }

        private Ice.AsyncResult<BattleIce.Callback_ZoneManager_setCallback> begin_setCallback(Ice.Identity ident, string srvUUID, _System.Collections.Generic.Dictionary<string, string> ctx__, bool explicitContext__, bool synchronous__, Ice.AsyncCallback cb__, object cookie__)
        {
            checkAsyncTwowayOnly__(__setCallback_name);
            IceInternal.TwowayOutgoingAsync<BattleIce.Callback_ZoneManager_setCallback> result__ =  getTwowayOutgoingAsync<BattleIce.Callback_ZoneManager_setCallback>(__setCallback_name, setCallback_completed__, cookie__);
            if(cb__ != null)
            {
                result__.whenCompletedWithAsyncCallback(cb__);
            }
            try
            {
                result__.prepare(__setCallback_name, Ice.OperationMode.Normal, ctx__, explicitContext__, synchronous__);
                IceInternal.BasicStream os__ = result__.startWriteParams(Ice.FormatType.DefaultFormat);
                Ice.Identity.write__(os__, ident);
                os__.writeString(srvUUID);
                result__.endWriteParams();
                result__.invoke();
            }
            catch(Ice.Exception ex__)
            {
                result__.abort(ex__);
            }
            return result__;
        }

        private void setCallback_completed__(Ice.AsyncResult r__, BattleIce.Callback_ZoneManager_setCallback cb__, Ice.ExceptionCallback excb__)
        {
            int ret__;
            try
            {
                ret__ = end_setCallback(r__);
            }
            catch(Ice.Exception ex__)
            {
                if(excb__ != null)
                {
                    excb__(ex__);
                }
                return;
            }
            if(cb__ != null)
            {
                cb__(ret__);
            }
        }

        #endregion

        #region Checked and unchecked cast operations

        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ZoneManagerPrx r = b as ZoneManagerPrx;
            if((r == null) && b.ice_isA(ice_staticId()))
            {
                ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            ZoneManagerPrx r = b as ZoneManagerPrx;
            if((r == null) && b.ice_isA(ice_staticId(), ctx))
            {
                ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId()))
                {
                    ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ZoneManagerPrx checkedCast(Ice.ObjectPrx b, string f, _System.Collections.Generic.Dictionary<string, string> ctx)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            try
            {
                if(bb.ice_isA(ice_staticId(), ctx))
                {
                    ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
                    h.copyFrom__(bb);
                    return h;
                }
            }
            catch(Ice.FacetNotExistException)
            {
            }
            return null;
        }

        public static ZoneManagerPrx uncheckedCast(Ice.ObjectPrx b)
        {
            if(b == null)
            {
                return null;
            }
            ZoneManagerPrx r = b as ZoneManagerPrx;
            if(r == null)
            {
                ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
                h.copyFrom__(b);
                r = h;
            }
            return r;
        }

        public static ZoneManagerPrx uncheckedCast(Ice.ObjectPrx b, string f)
        {
            if(b == null)
            {
                return null;
            }
            Ice.ObjectPrx bb = b.ice_facet(f);
            ZoneManagerPrxHelper h = new ZoneManagerPrxHelper();
            h.copyFrom__(bb);
            return h;
        }

        public static readonly string[] ids__ =
        {
            "::BattleIce::ZoneManager",
            "::Ice::Object"
        };

        public static string ice_staticId()
        {
            return ids__[0];
        }

        #endregion

        #region Marshaling support

        public static void write__(IceInternal.BasicStream os__, ZoneManagerPrx v__)
        {
            os__.writeProxy(v__);
        }

        public static ZoneManagerPrx read__(IceInternal.BasicStream is__)
        {
            Ice.ObjectPrx proxy = is__.readProxy();
            if(proxy != null)
            {
                ZoneManagerPrxHelper result = new ZoneManagerPrxHelper();
                result.copyFrom__(proxy);
                return result;
            }
            return null;
        }

        #endregion
    }
}

namespace BattleIce
{
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public abstract class ZoneManagerCallbackDisp_ : Ice.ObjectImpl, ZoneManagerCallback
    {
        #region Slice operations

        public void eventNotify(string eventType, string msg)
        {
            eventNotify(eventType, msg, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void eventNotify(string eventType, string msg, Ice.Current current__);

        #endregion

        #region Slice type-related members

        public static new readonly string[] ids__ = 
        {
            "::BattleIce::ZoneManagerCallback",
            "::Ice::Object"
        };

        public override bool ice_isA(string s)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override bool ice_isA(string s, Ice.Current current__)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override string[] ice_ids()
        {
            return ids__;
        }

        public override string[] ice_ids(Ice.Current current__)
        {
            return ids__;
        }

        public override string ice_id()
        {
            return ids__[0];
        }

        public override string ice_id(Ice.Current current__)
        {
            return ids__[0];
        }

        public static new string ice_staticId()
        {
            return ids__[0];
        }

        #endregion

        #region Operation dispatch

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus eventNotify___(ZoneManagerCallback obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string eventType;
            string msg;
            eventType = is__.readString();
            msg = is__.readString();
            inS__.endReadParams();
            obj__.eventNotify(eventType, msg, current__);
            inS__.writeEmptyParams__();
            return Ice.DispatchStatus.DispatchOK;
        }

        private static string[] all__ =
        {
            "eventNotify",
            "ice_id",
            "ice_ids",
            "ice_isA",
            "ice_ping"
        };

        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
        {
            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
            if(pos < 0)
            {
                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
            }

            switch(pos)
            {
                case 0:
                {
                    return eventNotify___(this, inS__, current__);
                }
                case 1:
                {
                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
                }
                case 2:
                {
                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
                }
                case 3:
                {
                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
                }
                case 4:
                {
                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
                }
            }

            _System.Diagnostics.Debug.Assert(false);
            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
        }

        #endregion

        #region Marshaling support

        protected override void writeImpl__(IceInternal.BasicStream os__)
        {
            os__.startWriteSlice(ice_staticId(), -1, true);
            os__.endWriteSlice();
        }

        protected override void readImpl__(IceInternal.BasicStream is__)
        {
            is__.startReadSlice();
            is__.endReadSlice();
        }

        #endregion
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public abstract class ZoneManagerDisp_ : Ice.ObjectImpl, ZoneManager
    {
        #region Slice operations

        public int setCallback(Ice.Identity ident, string srvUUID)
        {
            return setCallback(ident, srvUUID, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract int setCallback(Ice.Identity ident, string srvUUID, Ice.Current current__);

        public void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data)
        {
            createZoneRequest_async(cb__, playerId, gameServerId, mapTemplateId, instanceId, force, data, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void createZoneRequest_async(BattleIce.AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, int mapTemplateId, string instanceId, bool force, string data, Ice.Current current__);

        public void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId)
        {
            destroyZoneRequest_async(cb__, instanceId, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void destroyZoneRequest_async(BattleIce.AMD_ZoneManager_destroyZoneRequest cb__, string instanceId, Ice.Current current__);

        public void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__)
        {
            clearAllPlayersRequest_async(cb__, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void clearAllPlayersRequest_async(BattleIce.AMD_ZoneManager_clearAllPlayersRequest cb__, Ice.Current current__);

        public void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__)
        {
            getAllPlayerCountRequest_async(cb__, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void getAllPlayerCountRequest_async(BattleIce.AMD_ZoneManager_getAllPlayerCountRequest cb__, Ice.Current current__);

        public void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data)
        {
            playerEnterRequest_async(cb__, playerId, instanceId, data, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void playerEnterRequest_async(BattleIce.AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data, Ice.Current current__);

        public void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject)
        {
            playerLeaveRequest_async(cb__, playerId, instanceId, keepObject, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void playerLeaveRequest_async(BattleIce.AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject, Ice.Current current__);

        public void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state)
        {
            playerNetStateChanged_async(cb__, playerId, state, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void playerNetStateChanged_async(BattleIce.AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state, Ice.Current current__);

        public void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId)
        {
            getServerState_async(cb__, serverId, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void getServerState_async(BattleIce.AMD_ZoneManager_getServerState cb__, string serverId, Ice.Current current__);

        public void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid)
        {
            registerGameServer_async(cb__, serverid, crossid, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void registerGameServer_async(BattleIce.AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid, Ice.Current current__);

        public void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId)
        {
            getUnitHP_async(cb__, instanceId, objectId, Ice.ObjectImpl.defaultCurrent);
        }

        public abstract void getUnitHP_async(BattleIce.AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId, Ice.Current current__);

        #endregion

        #region Slice type-related members

        public static new readonly string[] ids__ = 
        {
            "::BattleIce::ZoneManager",
            "::Ice::Object"
        };

        public override bool ice_isA(string s)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override bool ice_isA(string s, Ice.Current current__)
        {
            return _System.Array.BinarySearch(ids__, s, IceUtilInternal.StringUtil.OrdinalStringComparer) >= 0;
        }

        public override string[] ice_ids()
        {
            return ids__;
        }

        public override string[] ice_ids(Ice.Current current__)
        {
            return ids__;
        }

        public override string ice_id()
        {
            return ids__[0];
        }

        public override string ice_id(Ice.Current current__)
        {
            return ids__[0];
        }

        public static new string ice_staticId()
        {
            return ids__[0];
        }

        #endregion

        #region Operation dispatch

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus setCallback___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            Ice.Identity ident;
            ident = null;
            string srvUUID;
            ident = Ice.Identity.read__(is__, ident);
            srvUUID = is__.readString();
            inS__.endReadParams();
            int ret__ = obj__.setCallback(ident, srvUUID, current__);
            IceInternal.BasicStream os__ = inS__.startWriteParams__(Ice.FormatType.DefaultFormat);
            os__.writeInt(ret__);
            inS__.endWriteParams__(true);
            return Ice.DispatchStatus.DispatchOK;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus createZoneRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string playerId;
            string gameServerId;
            int mapTemplateId;
            string instanceId;
            bool force;
            string data;
            playerId = is__.readString();
            gameServerId = is__.readString();
            mapTemplateId = is__.readInt();
            instanceId = is__.readString();
            force = is__.readBool();
            data = is__.readString();
            inS__.endReadParams();
            AMD_ZoneManager_createZoneRequest cb__ = new _AMD_ZoneManager_createZoneRequest(inS__);
            try
            {
                obj__.createZoneRequest_async(cb__, playerId, gameServerId, mapTemplateId, instanceId, force, data, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus destroyZoneRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string instanceId;
            instanceId = is__.readString();
            inS__.endReadParams();
            AMD_ZoneManager_destroyZoneRequest cb__ = new _AMD_ZoneManager_destroyZoneRequest(inS__);
            try
            {
                obj__.destroyZoneRequest_async(cb__, instanceId, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus clearAllPlayersRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            inS__.readEmptyParams();
            AMD_ZoneManager_clearAllPlayersRequest cb__ = new _AMD_ZoneManager_clearAllPlayersRequest(inS__);
            try
            {
                obj__.clearAllPlayersRequest_async(cb__, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus getAllPlayerCountRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            inS__.readEmptyParams();
            AMD_ZoneManager_getAllPlayerCountRequest cb__ = new _AMD_ZoneManager_getAllPlayerCountRequest(inS__);
            try
            {
                obj__.getAllPlayerCountRequest_async(cb__, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus playerEnterRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string playerId;
            string instanceId;
            string data;
            playerId = is__.readString();
            instanceId = is__.readString();
            data = is__.readString();
            inS__.endReadParams();
            AMD_ZoneManager_playerEnterRequest cb__ = new _AMD_ZoneManager_playerEnterRequest(inS__);
            try
            {
                obj__.playerEnterRequest_async(cb__, playerId, instanceId, data, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus playerLeaveRequest___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string playerId;
            string instanceId;
            bool keepObject;
            playerId = is__.readString();
            instanceId = is__.readString();
            keepObject = is__.readBool();
            inS__.endReadParams();
            AMD_ZoneManager_playerLeaveRequest cb__ = new _AMD_ZoneManager_playerLeaveRequest(inS__);
            try
            {
                obj__.playerLeaveRequest_async(cb__, playerId, instanceId, keepObject, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus playerNetStateChanged___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string playerId;
            string state;
            playerId = is__.readString();
            state = is__.readString();
            inS__.endReadParams();
            AMD_ZoneManager_playerNetStateChanged cb__ = new _AMD_ZoneManager_playerNetStateChanged(inS__);
            try
            {
                obj__.playerNetStateChanged_async(cb__, playerId, state, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus getServerState___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string serverId;
            serverId = is__.readString();
            inS__.endReadParams();
            AMD_ZoneManager_getServerState cb__ = new _AMD_ZoneManager_getServerState(inS__);
            try
            {
                obj__.getServerState_async(cb__, serverId, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus registerGameServer___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            int serverid;
            int crossid;
            serverid = is__.readInt();
            crossid = is__.readInt();
            inS__.endReadParams();
            AMD_ZoneManager_registerGameServer cb__ = new _AMD_ZoneManager_registerGameServer(inS__);
            try
            {
                obj__.registerGameServer_async(cb__, serverid, crossid, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        [_System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011")]
        public static Ice.DispatchStatus getUnitHP___(ZoneManager obj__, IceInternal.Incoming inS__, Ice.Current current__)
        {
            Ice.ObjectImpl.checkMode__(Ice.OperationMode.Normal, current__.mode);
            IceInternal.BasicStream is__ = inS__.startReadParams();
            string instanceId;
            int objectId;
            instanceId = is__.readString();
            objectId = is__.readInt();
            inS__.endReadParams();
            AMD_ZoneManager_getUnitHP cb__ = new _AMD_ZoneManager_getUnitHP(inS__);
            try
            {
                obj__.getUnitHP_async(cb__, instanceId, objectId, current__);
            }
            catch(_System.Exception ex__)
            {
                cb__.ice_exception(ex__);
            }
            return Ice.DispatchStatus.DispatchAsync;
        }

        private static string[] all__ =
        {
            "clearAllPlayersRequest",
            "createZoneRequest",
            "destroyZoneRequest",
            "getAllPlayerCountRequest",
            "getServerState",
            "getUnitHP",
            "ice_id",
            "ice_ids",
            "ice_isA",
            "ice_ping",
            "playerEnterRequest",
            "playerLeaveRequest",
            "playerNetStateChanged",
            "registerGameServer",
            "setCallback"
        };

        public override Ice.DispatchStatus dispatch__(IceInternal.Incoming inS__, Ice.Current current__)
        {
            int pos = _System.Array.BinarySearch(all__, current__.operation, IceUtilInternal.StringUtil.OrdinalStringComparer);
            if(pos < 0)
            {
                throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
            }

            switch(pos)
            {
                case 0:
                {
                    return clearAllPlayersRequest___(this, inS__, current__);
                }
                case 1:
                {
                    return createZoneRequest___(this, inS__, current__);
                }
                case 2:
                {
                    return destroyZoneRequest___(this, inS__, current__);
                }
                case 3:
                {
                    return getAllPlayerCountRequest___(this, inS__, current__);
                }
                case 4:
                {
                    return getServerState___(this, inS__, current__);
                }
                case 5:
                {
                    return getUnitHP___(this, inS__, current__);
                }
                case 6:
                {
                    return Ice.ObjectImpl.ice_id___(this, inS__, current__);
                }
                case 7:
                {
                    return Ice.ObjectImpl.ice_ids___(this, inS__, current__);
                }
                case 8:
                {
                    return Ice.ObjectImpl.ice_isA___(this, inS__, current__);
                }
                case 9:
                {
                    return Ice.ObjectImpl.ice_ping___(this, inS__, current__);
                }
                case 10:
                {
                    return playerEnterRequest___(this, inS__, current__);
                }
                case 11:
                {
                    return playerLeaveRequest___(this, inS__, current__);
                }
                case 12:
                {
                    return playerNetStateChanged___(this, inS__, current__);
                }
                case 13:
                {
                    return registerGameServer___(this, inS__, current__);
                }
                case 14:
                {
                    return setCallback___(this, inS__, current__);
                }
            }

            _System.Diagnostics.Debug.Assert(false);
            throw new Ice.OperationNotExistException(current__.id, current__.facet, current__.operation);
        }

        #endregion

        #region Marshaling support

        protected override void writeImpl__(IceInternal.BasicStream os__)
        {
            os__.startWriteSlice(ice_staticId(), -1, true);
            os__.endWriteSlice();
        }

        protected override void readImpl__(IceInternal.BasicStream is__)
        {
            is__.startReadSlice();
            is__.endReadSlice();
        }

        #endregion
    }
}

namespace BattleIce
{
    /// <summary>
    /// 场景副本相关协议
    /// </summary>
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_createZoneRequest : Ice.AMDCallback
    {
        /// <summary>
        /// ice_response indicates that
        /// the operation completed successfully.
        /// </summary>
        void ice_response(int ret__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_createZoneRequest : IceInternal.IncomingAsync, AMD_ZoneManager_createZoneRequest
    {
        public _AMD_ZoneManager_createZoneRequest(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response(int ret__)
        {
            if(validateResponse__(true))
            {
                try
                {
                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
                    os__.writeInt(ret__);
                    endWriteParams__(true);
                }
                catch(Ice.LocalException ex__)
                {
                    exception__(ex__);
                    return;
                }
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_destroyZoneRequest : Ice.AMDCallback
    {
        void ice_response();
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_destroyZoneRequest : IceInternal.IncomingAsync, AMD_ZoneManager_destroyZoneRequest
    {
        public _AMD_ZoneManager_destroyZoneRequest(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response()
        {
            if(validateResponse__(true))
            {
                writeEmptyParams__();
                response__();
            }
        }
    }

    /// <summary>
    /// 玩家相关协议
    /// </summary>
    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_clearAllPlayersRequest : Ice.AMDCallback
    {
        /// <summary>
        /// ice_response indicates that
        /// the operation completed successfully.
        /// </summary>
        void ice_response();
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_clearAllPlayersRequest : IceInternal.IncomingAsync, AMD_ZoneManager_clearAllPlayersRequest
    {
        public _AMD_ZoneManager_clearAllPlayersRequest(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response()
        {
            if(validateResponse__(true))
            {
                writeEmptyParams__();
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_getAllPlayerCountRequest : Ice.AMDCallback
    {
        void ice_response(int ret__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_getAllPlayerCountRequest : IceInternal.IncomingAsync, AMD_ZoneManager_getAllPlayerCountRequest
    {
        public _AMD_ZoneManager_getAllPlayerCountRequest(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response(int ret__)
        {
            if(validateResponse__(true))
            {
                try
                {
                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
                    os__.writeInt(ret__);
                    endWriteParams__(true);
                }
                catch(Ice.LocalException ex__)
                {
                    exception__(ex__);
                    return;
                }
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_playerEnterRequest : Ice.AMDCallback
    {
        void ice_response();
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_playerEnterRequest : IceInternal.IncomingAsync, AMD_ZoneManager_playerEnterRequest
    {
        public _AMD_ZoneManager_playerEnterRequest(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response()
        {
            if(validateResponse__(true))
            {
                writeEmptyParams__();
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_playerLeaveRequest : Ice.AMDCallback
    {
        void ice_response();
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_playerLeaveRequest : IceInternal.IncomingAsync, AMD_ZoneManager_playerLeaveRequest
    {
        public _AMD_ZoneManager_playerLeaveRequest(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response()
        {
            if(validateResponse__(true))
            {
                writeEmptyParams__();
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_playerNetStateChanged : Ice.AMDCallback
    {
        void ice_response();
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_playerNetStateChanged : IceInternal.IncomingAsync, AMD_ZoneManager_playerNetStateChanged
    {
        public _AMD_ZoneManager_playerNetStateChanged(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response()
        {
            if(validateResponse__(true))
            {
                writeEmptyParams__();
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_getServerState : Ice.AMDCallback
    {
        void ice_response(string ret__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_getServerState : IceInternal.IncomingAsync, AMD_ZoneManager_getServerState
    {
        public _AMD_ZoneManager_getServerState(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response(string ret__)
        {
            if(validateResponse__(true))
            {
                try
                {
                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
                    os__.writeString(ret__);
                    endWriteParams__(true);
                }
                catch(Ice.LocalException ex__)
                {
                    exception__(ex__);
                    return;
                }
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_registerGameServer : Ice.AMDCallback
    {
        void ice_response(string ret__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_registerGameServer : IceInternal.IncomingAsync, AMD_ZoneManager_registerGameServer
    {
        public _AMD_ZoneManager_registerGameServer(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response(string ret__)
        {
            if(validateResponse__(true))
            {
                try
                {
                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
                    os__.writeString(ret__);
                    endWriteParams__(true);
                }
                catch(Ice.LocalException ex__)
                {
                    exception__(ex__);
                    return;
                }
                response__();
            }
        }
    }

    [_System.Runtime.InteropServices.ComVisible(false)]
    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    public interface AMD_ZoneManager_getUnitHP : Ice.AMDCallback
    {
        void ice_response(int ret__);
    }

    [_System.CodeDom.Compiler.GeneratedCodeAttribute("slice2cs", "3.6.4")]
    class _AMD_ZoneManager_getUnitHP : IceInternal.IncomingAsync, AMD_ZoneManager_getUnitHP
    {
        public _AMD_ZoneManager_getUnitHP(IceInternal.Incoming inc) : base(inc)
        {
        }

        public void ice_response(int ret__)
        {
            if(validateResponse__(true))
            {
                try
                {
                    IceInternal.BasicStream os__ = startWriteParams__(Ice.FormatType.DefaultFormat);
                    os__.writeInt(ret__);
                    endWriteParams__(true);
                }
                catch(Ice.LocalException ex__)
                {
                    exception__(ex__);
                    return;
                }
                response__();
            }
        }
    }
}