WSHCommon/XmdsServerCS/XmdsServerEdgeJS/Zone/XmdsManagerICE.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Ice;
using BattleIce;
using XmdsCommon.Plugin;
using System.Web.Helpers;
using SuperSocket.SocketBase.Logging;
using CommonLang.Log;
using XmdsCommonServer.Message;

namespace XmdsServerEdgeJS.Zone
{
    public class XmdsManagerICE : XmdsManagerDisp_
    {
        protected static CommonLang.Log.Logger log = LoggerFactory.GetDefLogger();
        public override void addPlayerAtt_async(AMD_XmdsManager_addPlayerAtt cb__, string playerId, string strNotifyPlayerIds, string key, int value, Current current__)
        {
            try
            {
                List<string> notifyPlayerIds = new List<string>();
                foreach (dynamic obj in Json.Decode(strNotifyPlayerIds))
                {
                    string notifyPlayerId = (string)obj;
                    notifyPlayerIds.Add(notifyPlayerId);
                }
                ZoneServiceICE.InstanceICE.r2b_notify_addPlayerAtt(notifyPlayerIds, playerId, key, value);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getAllNpcInfo_async(AMD_XmdsManager_getAllNpcInfo cb__, string instanceId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getAllNpcInfo(instanceId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }


        public override void getAllUnitInfo_async(AMD_XmdsManager_getAllUnitInfo cb__, string instanceId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getAllUnitInfo(instanceId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getAllPlayerUUID_async(AMD_XmdsManager_getAllPlayerUUID cb__, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getAllPlayerUUID(
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getBornPlace_async(AMD_XmdsManager_getBornPlace cb__, string instanceId, int areaId, string pointId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_static_getBornPlace(instanceId, areaId, pointId,
                     (ret) => { cb__.ice_response(Json.Encode(ret)); },
                     (err) => { cb__.ice_exception(err); }
                     );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getPlayerData_async(AMD_XmdsManager_getPlayerData cb__, string playerId,bool changeArea, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getPlayerData(playerId, changeArea,
                    (ret) => { cb__.ice_response(ret == null ? "" : Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getPlayerPetData_async(AMD_XmdsManager_getPlayerPetData cb__, string playerId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getPlayerPetData(playerId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getPlayerPKInfoData_async(AMD_XmdsManager_getPlayerPKInfoData cb__, string playerId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getPlayerPKInfoData(playerId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getPlayerSkillCDTime_async(AMD_XmdsManager_getPlayerSkillCDTime cb__, string playerId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getPlayerSkillCDTime(playerId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void canTalkWithNpc_async(AMD_XmdsManager_canTalkWithNpc cb__, string playerId, int npcId, Ice.Current current__) {
            try
            {
                //long startTime = DateTime.Now.Millisecond;
                ZoneServiceICE.InstanceICE.r2b_get_CanTalkWithNpc(playerId, (uint)npcId,
                    (ret) => {
                        //Console.WriteLine("canTalkWithNpc use : " + (DateTime.Now.Millisecond - startTime));
                        cb__.ice_response(Json.Encode(ret));
                    },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }


        public override void getZoneRegions_async(AMD_XmdsManager_getZoneRegions cb__, string instanceId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_getZoneRegions(instanceId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void canUseItem_async(AMD_XmdsManager_canUseItem cb__, string playerId, Ice.Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_canUseItem(playerId,
                    (ret) => { cb__.ice_response(ret); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getZoneStaticData_async(AMD_XmdsManager_getZoneStaticData cb__, string instanceId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_get_static_getZoneStaticData(instanceId,
                    (ret) => { cb__.ice_response(Json.Encode(ret)); },
                    (err) => { cb__.ice_exception(err); }
                    );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void helpRevivePlayer_async(AMD_XmdsManager_helpRevivePlayer cb__, string playerId, string revivePlayerId, int time, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_helpRevivePlayer(playerId, revivePlayerId, time);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void notifyBattleServer_async(AMD_XmdsManager_notifyBattleServer cb__, string instanceId, string name, string data, Current current__)
        {
            try
            {
                dynamic param = Json.Decode(data);
                ZoneServiceICE.InstanceICE.r2b_notify_notifyBattleServer(instanceId, name, param);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void onMonsterDiedDrops_async(AMD_XmdsManager_onMonsterDiedDrops cb__, string instanceId, string data, Current current__)
        {
            try
            {
                dynamic param = Json.Decode(data);
                float x = (float)param.pos.x;
                float y = (float)param.pos.y;
                ZoneServiceICE.InstanceICE.r2b_notify_onMonsterDiedDrops(instanceId, x, y, param.items);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerAvatar_async(AMD_XmdsManager_refreshPlayerAvatar cb__, string playerId, string avatars, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerAvatar(playerId, Json.Decode(avatars).avatars);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerBasicData_async(AMD_XmdsManager_refreshPlayerBasicData cb__, string playerId, string basic, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerBasicData(playerId, Json.Decode(basic));
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerBattleEffect_async(AMD_XmdsManager_refreshPlayerBattleEffect cb__, string playerId, string effects, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerBattleEffect(playerId, Json.Decode(effects));
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPKLevel_async(AMD_XmdsManager_refreshPlayerPKLevel cb__, string playerId, int level, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPKLevel(playerId, level);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPKMode_async(AMD_XmdsManager_refreshPlayerPKMode cb__, string playerId, bool isLook, int mode, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPKMode(playerId, isLook, mode,
					 (ret) => { cb__.ice_response(ret); },
					 (err) => { cb__.ice_exception(err); }
					 );
			}
			catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPKValue_async(AMD_XmdsManager_refreshPlayerPKValue cb__, string playerId, int value, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPKValue(playerId, value);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }
        public override void refreshPlayerPropertyChange_async(AMD_XmdsManager_refreshPlayerPropertyChange cb__, string playerId, string data, Ice.Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);

                int changeType = (int)propertyData.changeType;
                int valueType = (int)propertyData.valueType;
                int value = (int)propertyData.value;
                int duration = (int)propertyData.duration;
                long timestamp = (long)propertyData.timestamp;

                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPropertyChange(playerId, changeType, valueType, value, duration, timestamp);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPetBaseInfoChange_async(AMD_XmdsManager_refreshPlayerPetBaseInfoChange cb__, string playerId, string data, Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPetBaseInfoChange(playerId, propertyData);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPetDataChange_async(AMD_XmdsManager_refreshPlayerPetDataChange cb__, string playerId, int type, string data, Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
				PetDataChangeEventR2B r2b = new PetDataChangeEventR2B();
				r2b.OpType = (PetDataChangeEventR2B.PetDataChangeType)type;
				if (r2b.OpType != PetDataChangeEventR2B.PetDataChangeType.Delete)
				{
					r2b.Data = XmdsPlayerUtil.instance().createPetData(propertyData.petBase, propertyData.petEffect, propertyData.petSkill, propertyData.petMode);
				}

				ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPetDataChange(playerId, type, r2b,
				  (ret) => { cb__.ice_response(ret); },
				  (err) => { cb__.ice_exception(err); }
				  );
				//ZoneServiceICE.InstanceICE.r2b_request_addUnit(instanceId, unitTemplateID, data,
				//   (ret) => { cb__.ice_response(ret); },
				//   (err) => { cb__.ice_exception(err); }
				//   );
			}
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPetSkillChange_async(AMD_XmdsManager_refreshPlayerPetSkillChange cb__, string playerId, int type, string data, Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPetSkillChange(playerId, type, propertyData);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerPetPropertyChange_async(AMD_XmdsManager_refreshPlayerPetPropertyChange cb__, string playerId, string data, Ice.Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPetPropertyChange(playerId, propertyData);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerRemainBagCountData_async(AMD_XmdsManager_refreshPlayerRemainBagCountData cb__, string playerId, int remainCount, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerRemainBagCountData(playerId, remainCount);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerRemainTeamBagCountData_async(AMD_XmdsManager_refreshPlayerRemainTeamBagCountData cb__, string playerId, int remainCount, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerRemainTeamBagCountData(playerId, remainCount);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerSkill_async(AMD_XmdsManager_refreshPlayerSkill cb__, string playerId, int operateID, string skills, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerSkill(playerId, operateID, Json.Decode(skills));
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshPlayerTeamData_async(AMD_XmdsManager_refreshPlayerTeamData cb__, string playerId, string data, Current current__)
        {
            try
            {
                List<string> uuidList = new List<string>();
                foreach (dynamic uuid in Json.Decode(data))
                {
                    uuidList.Add((string)uuid);
                }
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerTeamData(playerId, uuidList);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshSummonMount_async(AMD_XmdsManager_refreshSummonMount cb__, string playerId, int time, int isUp, Current current__)
        {
            try
            {
                bool IsSummonMount = false;
                if (isUp == 1)
                {
                    IsSummonMount = true;
                }
                ZoneServiceICE.InstanceICE.r2b_notify_refreshSummonMount(playerId, time, IsSummonMount);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void revivePlayer_async(AMD_XmdsManager_revivePlayer cb__, string playerId, string data, Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
                int type = propertyData.type;
                int qty = propertyData.qty;
                string itemType = propertyData.itemType;
                int hp = propertyData.hp;
                int mp = propertyData.mp;

                ZoneServiceICE.InstanceICE.r2b_notify_revivePlayer(playerId, type, qty, itemType, hp, mp);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void onFinishPickItem_async(AMD_XmdsManager_onFinishPickItem cb__, string playerId, string data, Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
                string itemIcon = propertyData.itemIcon;
                int quality = propertyData.quality;
                int num = propertyData.num;
				int objectId = propertyData.objectId;
				String instanceId = propertyData.instanceId;
                ZoneServiceICE.InstanceICE.r2b_notify_onFinishPickItem(playerId, itemIcon, quality, num, objectId, instanceId);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void triggrBattleFunction_async(AMD_XmdsManager_triggrBattleFunction cb__, string playerId, int eventId, int value1, 
			int value2, int value3, int value4, int value5, int value6, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_triggrBattleFunction(playerId, eventId, value1, value2, value3, value4, value5, value6);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void addUnits_async(AMD_XmdsManager_addUnits cb__, string instanceId, string data, Current current__)
        {
            try
            {
                //dynamic propertyData = Json.Decode(data);
                ZoneServiceICE.InstanceICE.r2b_notify_addUnits(instanceId, data, 
                     (ret) => { cb__.ice_response(ret); },
                     (err) => { cb__.ice_exception(err); }
                     );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }


        public override void removePointUnit_async(AMD_XmdsManager_removePointUnit cb__, string instanceId, int unitObjectId, Ice.Current current__)
        {
            try
            {
                try
                {
                    ZoneServiceICE.InstanceICE.r2b_request_removePointUnit(instanceId, unitObjectId);
                    cb__.ice_response();
                }
                catch (System.Exception e)
                {
                    cb__.ice_exception(e);
                }

            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

		public override void removeItem_async(AMD_XmdsManager_removeItem cb__, string instanceId, int itemId, Current current__)
		{
			try
			{
				try
				{
					ZoneServiceICE.InstanceICE.r2b_request_removeItem(instanceId, itemId);
					cb__.ice_response();
				}
				catch (System.Exception e)
				{
					cb__.ice_exception(e);
				}

			}
			catch (System.Exception e)
			{
				cb__.ice_exception(e);
			}
		}

		public override void refreshPlayerPetFollowModeChange_async(AMD_XmdsManager_refreshPlayerPetFollowModeChange cb__, string playerId, int mode, Ice.Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_refreshPlayerPetFollowModeChange(
                    playerId,
                    mode);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void playerReady_async(AMD_XmdsManager_playerReady cb__, string playerId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_playerReady(playerId);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void refreshTeamData_async(AMD_XmdsManager_refreshTeamData cb__, string playerId, string data, Current current__)
        {
            try
            {
                dynamic propertyData = Json.Decode(data);
                ZoneServiceICE.InstanceICE.r2b_notify_setTeamData(playerId, propertyData);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void autoBattle_async(AMD_XmdsManager_autoBattle cb__, string instanceId, string playerId, bool enable, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_request_autoBattle(instanceId, playerId, enable);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getPlayerStatistic_async(AMD_XmdsManager_getPlayerStatistic cb__, string instanceId, string playerId, int flag, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_request_getPlayerStatistic(instanceId, playerId, flag, 
                     (ret) => { cb__.ice_response(Json.Encode(ret)); },
                     (err) => { cb__.ice_exception(err); }
                     );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void getInstanceStatistic_async(AMD_XmdsManager_getInstanceStatistic cb__, string instanceId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_request_getInstanceStatistic(instanceId,
                     (ret) => { cb__.ice_response(Json.Encode(ret)); },
                     (err) => { cb__.ice_exception(err); }
                     );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void addUnit_async(AMD_XmdsManager_addUnit cb__, string instanceId, int unitTemplateID, string data, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_request_addUnit(instanceId, unitTemplateID, data,
                     (ret) => { cb__.ice_response(ret); },
                     (err) => { cb__.ice_exception(err); }
                     );
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void removeUnit_async(AMD_XmdsManager_removeUnit cb__, string instanceId, int unitId, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_request_removeUnit(instanceId, unitId);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void transferUnit_async(AMD_XmdsManager_transferUnit cb__, string instanceId, int unitObjectId, float x, float y, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_transferUnit(instanceId, (uint)unitObjectId, x, y);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void playerChangeSkill_async(AMD_XmdsManager_playerChangeSkill cb__, string playerId, int oldSkillID, int newSkillID, string data, Current current__)
		{
			try
			{
                ZoneServiceICE.InstanceICE.r2b_notify_playerChangeSkill(playerId, oldSkillID, newSkillID, Json.Decode(data));
                cb__.ice_response();
            }
			catch (System.Exception e)
			{
				cb__.ice_exception(e);
			}
		}

        public override void transferToPointPos_async(AMD_XmdsManager_transferToPointPos cb__, string instanceId, string playerId, string point, 
			bool setDirection, float direction, Current current__)
        {
            try
            {
                bool res = ZoneServiceICE.InstanceICE.r2b_notify_transferToPointPos(instanceId, playerId, point, setDirection, direction);
                cb__.ice_response(res);
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void changePlayerState_async(AMD_XmdsManager_changePlayerState cb__, string instanceId, string playerId, 
			byte status, int time, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_changePlayerStatus(instanceId, playerId, status, time);
                cb__.ice_response();
            }
            catch (System.Exception e)
            {
                cb__.ice_exception(e);
            }
        }

        public override void playerChuanGong_async(AMD_XmdsManager_playerChuanGong cb__, string instanceId, string playerIdA, string playerIdB, Current current__)
        {
            try
            {
                ZoneServiceICE.InstanceICE.r2b_notify_playerChuanGong(instanceId, playerIdA, playerIdB);
                cb__.ice_response();
            }
            catch (System.Exception e) 
            {
                cb__.ice_exception(e);
            }
        }

		public override void mountainKingRefreshNotify_async(AMD_XmdsManager_mountainKingRefreshNotify cb__, string instanceId, string data, Current current__)
		{
			try
			{
				ZoneServiceICE.InstanceICE.r2b_notifyMountainKingRefresh(instanceId, data);
				cb__.ice_response();
			}
			catch (System.Exception e)
			{
				cb__.ice_exception(e);
			}
		}
    }
}