WSHCommon/Common/Pomelo/PomeloShare/ZoneManagerI.cs

using Ice;
using System;
using System.Collections.Generic;
using System.Web.Helpers;
using CommonLang.Log;
using System.Collections;
using Pomelo.JSGModule;
using System.Threading;
using BattleIce;

namespace Pomelo
{
    class ZoneManagerI : ZoneManagerDisp_
    {
        private IZone zone;


        public ZoneManagerI(IZone zone)
        {
            this.zone = zone;
        }
        private CommonLang.Log.Logger log = LoggerFactory.GetLogger("ZoneManagerI");


        public override int setCallback(Identity ident, string srvUUID, Current current__)
        {
			string gameSrvId = ident.name;
			if (string.IsNullOrEmpty(gameSrvId) || string.IsNullOrEmpty(srvUUID))
			{
				return GSBindResult.PARAM_ERROR;
			}

            //current__.con.setCallback();
            Ice.ObjectPrx @base = current__.con.createProxy(ident);
            ZoneManagerCallbackPrx client = ZoneManagerCallbackPrxHelper.uncheckedCast(@base);
            int resCode = IceManager.instance().setCallback(ident.name, srvUUID, client, (ZoneManagerCallbackPrx)client.ice_oneway());
			zone.SetCallBack(ident.name);
			return resCode;
        }

        public void closed(Ice.Connection con)
        {
            try
            {
                
            }
            catch (Ice.LocalException)
            {
                // The client already destroyed this session, or the server is shutting down
            }
        }

        public override void createZoneRequest_async(AMD_ZoneManager_createZoneRequest cb__, string playerId, string gameServerId, 
			int mapTemplateId, string instanceId, bool forceCreate, string data, Current current__)
        {
            try
            {
                //log.Info("createZone begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                zone.CreateZone(playerId, gameServerId, mapTemplateId, instanceId, forceCreate, data,
					 (ret) => { cb__.ice_response(ret); },
					 (err) => { cb__.ice_exception(err); }
					 );

			} catch (System.Exception e){
                log.Error("CreateZone failed, error: " + e.Message, e);
                cb__.ice_exception(e);
            }
        }

        public override void destroyZoneRequest_async(AMD_ZoneManager_destroyZoneRequest cb__, string instanceId, Current current__)
        {
            try
            {
                //log.Info("destroyZone begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                zone.DestroyZone(instanceId, (err, ret) =>
               {
                   if (err != null)
                   {
                       cb__.ice_exception(err);
                   }
                   else
                   {
                       cb__.ice_response();
                   }
                   //log.Debug("destroyZone end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);

               });
            } catch (System.Exception e)
            {
                log.Error("stop failed, error: " + e.Message, e);
                cb__.ice_exception(e);
            }
        }


        public override void playerEnterRequest_async(AMD_ZoneManager_playerEnterRequest cb__, string playerId, string instanceId, string data, Current current__)
        {
            try
            {
                //log.Info("playerEnter begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                zone.PlayerEnter(playerId, instanceId, data, (err, ret) =>
                {
                    if (err != null)
                    {
                        cb__.ice_exception(err);
                    }
                    else
                    {
                        cb__.ice_response();
                    }
                    //log.Debug("playerEnter end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);

                });
            } catch (System.Exception e)
            {
                log.Error("add player failed, error: " + playerId + ", " + instanceId + ", " + e.Message, e);
                cb__.ice_exception(e);
            }
        }

        public override void playerLeaveRequest_async(AMD_ZoneManager_playerLeaveRequest cb__, string playerId, string instanceId, bool keepObject, Current current__)
        {
            try
            {
                //log.Info("playerLeave begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                zone.PlayerLeave(playerId, instanceId, keepObject, (err, ret) =>
                {
                    if (err != null)
                    {
                        cb__.ice_exception(err);
                    }
                    else
                    {
                        cb__.ice_response();
                    }
                    //log.Debug("playerLeave end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
                });
            } catch (System.Exception e)
            {
                log.Error("playerLeave failed, error: " + e.Message, e);
                cb__.ice_exception(e);
            }
        }

        public override void playerNetStateChanged_async(AMD_ZoneManager_playerNetStateChanged cb__, string playerId, string state, Current current__)
        {
            try
            {
                zone.PlayerNetStateChanged(playerId, state);
                cb__.ice_response();
            }
            catch (System.Exception err)
            {
                cb__.ice_exception(err);
            }
        }

        public override void clearAllPlayersRequest_async(AMD_ZoneManager_clearAllPlayersRequest cb__, Current current__)
        {
            //log.Info("clearAllPlayers begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            zone.ClearAllPlayers((err, ret) =>
            {
                if (err != null)
                {
                    cb__.ice_exception(err);
                }
                else
                {
                    cb__.ice_response();
                }
                log.Debug("clearAllPlayers end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            });
        }


        public override void getAllPlayerCountRequest_async(AMD_ZoneManager_getAllPlayerCountRequest cb__, Current current__)
        {
            //log.Info("getAllPlayerCount begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            zone.GetAllPlayerCount((err, ret) =>
            {
                if (err != null)
                {
                    cb__.ice_exception(err);
                }
                else
                {
                    cb__.ice_response(ret);
                }
                log.Debug("getAllPlayerCount end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            });
        }

        public override void getServerState_async(AMD_ZoneManager_getServerState cb__, string serverID, Current current__)
        {
            //log.Info("getServerState_async begin:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            zone.GetServerState(serverID, (err, ret) =>
            {
                if (err != null)
                {
                    cb__.ice_exception(err);
                }
                else
                {
                    cb__.ice_response(Json.Encode(ret));
                }
                log.Debug("getServerState_async end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            });
        }

        public override void registerGameServer_async(AMD_ZoneManager_registerGameServer cb__, int serverid, int crossid, Ice.Current current__)
        {
			zone.RegisterGameServer(serverid, crossid, (err, ret) =>
            {
                if (err != null)
                {
                    cb__.ice_exception(err);
                }
                else
                {
                    cb__.ice_response(ret);
                }
               // log.Debug("getServerState_async end:" + System.Threading.Thread.CurrentThread.ManagedThreadId);
            });
        }

		public override void getUnitHP_async(AMD_ZoneManager_getUnitHP cb__, string instanceId, int objectId, Current current__)
		{
			zone.GetUnitHP(instanceId, objectId, (err, ret) =>
			{
				if (err != null)
				{
					cb__.ice_exception(err);
				}
				else
				{
					cb__.ice_response(ret);
				}
			});
		}
    }
}