package game.managers

{

   import game.world.view.WorldView;

   import game.core.data.ClanData;

   import game.core.net.Connection;

   import spark.components.Group;

   import ru.rainal.loaders.StandoutLoader;

   import game.ui.animation.FunMovie;

   import game.ui.islands.UserIsleView;

   import game.ui.islands.ClanIsleView;

   import game.ui.islands.ClanBackIsle;

   import sky.localization.Localization;

   import game.world.service.WorldService;

   import game.modules.views.buildings.tree.service.TreeService;

   import com.netease.protobuf.UInt64;

   import protocol.ProtoDefaultUserCmd;

   import game.net.connection.SrvCommand;

   import protocol.consts.Services;

   import protocol.world.WorldCommands;

   import protocol.world.MonsterInfo;

   import game.core.Core;

   import game.modules.views.combat.*;

   import flash.accessibility.*;

   import flash.debugger.*;

   import flash.display.*;

   import flash.errors.*;

   import flash.events.*;

   import flash.external.*;

   import flash.geom.*;

   import flash.media.*;

   import flash.net.*;

   import flash.printing.*;

   import flash.profiler.*;

   import flash.system.*;

   import flash.text.*;

   import flash.ui.*;

   import flash.utils.*;

   import flash.xml.*;

   import mx.binding.*;

   import mx.filters.*;

   import mx.styles.*;

   import protocol.blitz_tournaments.ProtoFighterCountChangedEvt;

   import game.net.connection.SrvAnswer;

   import game.core.data.UserData;

   import game.core.data.UserBuildingData;

   import game.ui.window.AccelerateInfoWindow;

   import protocol.consts.UserBuildingTypes;

   import protocol.world.ProtoUserAprChangedEvt;

   import game.managers.events.WorldManagerEvent;

   import game.world.model.WorldModel;

   import game.world.control.WorldController;

   import game.world.control.WorldViewMediator;

   import game.modules.views.boss.model.BossModel;

   import game.world.events.WorldSignals;

   import game.modules.views.boss.controller.controller.BossController;

   import game.modules.views.boss.controller.BossViewMediator;

   import game.world.events.WorldUserRequests;

   import game.modules.views.boss.events.BossEventsChannel;

   import game.modules.views.boss.service.BossService;

   import game.managers.events.UserEvent;

   import protocol.dic.AccountDic.UserAccounts;

   import game.ui.islands.CloudIsle;

   import game.managers.events.ConnectionManagerEvent;

   import com.netease.protobuf.Message;

   import game.core.data.ClanBuildingData;

   import game.managers.clan.events.GolemEvent;

   import protocol.clanIsle.ClanIsleEvents;

   import protocol.clanIsle.ProtoBuildingAcceleratedEvt;

   import protocol.clanIsle.ProtoBuildingFinishedEvt;

   import protocol.consts.ClanBuildingTypes;

   import protocol.clanIsle.ProtoBuildingCanceledEvt;

   import protocol.clanIsle.ProtoBuildingStartedEvt;

   import protocol.clanIsle.ProtoGolemStateChangedEvt;

   import protocol.clans.ClansEvents;

   import protocol.clans.ProtoTreasuryChangedEvt;

   import protocol.clans.ProtoNewClanRestrictionEvt;

   import com.reallife.debug.Logger;

   import mx.core.UIComponent;

   import ru.pulseneon.util.DisplayUtil;

   import game.core.consts.SoundsConsts;

   import protocol.duel.DuelUserInfo;

   import IMain.userView;

   import utils.ProtoUtils;

   import protocol.consts.LocationTypes;

   import game.core.data.isles.UserIsleData;

   import protocol.ClanInfo;

   import com.greensock.TweenLite;

   import com.greensock.easing.Cubic;

   import protocol.main.ClientStates;

   import com.greensock.easing.Linear;

   import protocol.clanIsle.ProtoGetIsleInfoCmd.Flags;

   import protocol.clanIsle.ProtoGetIsleInfoCmd;

   import protocol.clanIsle.ClanIsleCommands;

   import protocol.clanIsle.ProtoGetIsleInfoAns;

   import protocol.BuildingInfo;

   import protocol.clanIsle.ProtoGetIsleInfoAns.Errors;

   import game.ui.GAlert;

   import com.greensock.easing.Sine;

   import protocol.dic.ClanCultDic;

   import game.ui.islands.IsleBonusView;

   import game.ui.window.HarvestIsleWindow;

   import sky.lib.OpToken;

   import protocol.ProtoDefaultAns;

   import protocol.clanIsle.ProtoKickFromIsleAns;

   import protocol.clanIsle.ProtoKickFromIsleCmd;

   import game.modules.ModulesNames;

   import game.core.net.SupportedServices;

   import game.modules.views.buildings.market.MarketTabs;

   import game.payments.Payments;

   import game.ui.window.accounts.TradeAccountWindow;

   import ru.rainal.PopUpOrganizer;

   import game.ui.window.accounts.BattleAccountWindow;

   import game.modules.views.user.UserModuleTabs;

   import ru.errors.SingeltonError;

 

   use namespace userView;

 

   public class WorldManager extends EventDispatcher

   {

 

      public function WorldManager(param1:IEventDispatcher=null) {

         Security.allowDomain("*");

         ExternalInterface.addCallback("updateMonsterEx",this.updateMonsterEx);

         ExternalInterface.addCallback("requestUseSpell",this.requestUseSpell);

         ExternalInterface.addCallback("requestMagicTowerInfoEx",this.requestMagicTowerInfoEx);

         ExternalInterface.addCallback("requestSearchCave",this.requestSearchCave);

         ExternalInterface.addCallback("requestGetCaveInfo",this.requestGetCaveInfo);

         this._loc = Localization.getInstance();

         this._dic = GDictionary.getInstance();

         this._sm = SoundManager.getInstance();

         this._am = AnimationManager.getInstance();

         super(param1);

         if(!_allowInstance)

         {

            throw new SingeltonError();

         }

         else

         {

            this.initInstance();

            return;

         }

      }

 

      protected static var _allowInstance:Boolean = true;

 

      protected static var _instance:WorldManager = null;

 

      private static const USER_ISLE_X:int = 92;

 

      public static const USER_ISLE_Y:int = 100;

 

      public static const USER_ISLE_HEIGHT:int = 480;

 

      private static const USER_BACK_ISLE_X:int = 660;

 

      private static const USER_BACK_ISLE_Y:int = 260;

 

      private static const CLAN_BACK_ISLE_X:int = 670;

 

      private static const CLAN_BACK_ISLE_Y:int = 175;

 

      public static function getInstance() : WorldManager {

         if(!_instance)

         {

            _allowInstance = true;

            _instance = new WorldManager();

            _allowInstance = false;

         }

         return _instance;

      }

 

      private var _worldView:WorldView;

 

      private var _currentClanData:ClanData;

 

      private var _connection:Connection;

 

      private var _contUserIsle:Group;

 

      private var _contClanIsle:Group;

 

      private var _contUserBackIsle:Group;

 

      private var _contClanBackIsle:Group;

 

      private var _traceUserIsleIn:StandoutLoader;

 

      private var _traceUserIsleOut:StandoutLoader;

 

      private var _traceClanIsleIn:StandoutLoader;

 

      private var _traceUserToClanIsleBottom:StandoutLoader;

 

      private var _traceUserToClanIsleTop:StandoutLoader;

 

      private var _traceClanToUserIsleTop:StandoutLoader;

 

      private var _birdsImage:FunMovie;

 

      private var _dragonImage:FunMovie;

 

      private var _userIsleView:UserIsleView;

 

      private var _clanIsle:ClanIsleView;

 

      private var _clanBackIsle:ClanBackIsle;

 

      private var _userIsleHidden:Boolean = true;

 

      private var _clanIsleHidden:Boolean = true;

 

      private var _canChangeIsle:Boolean = true;

 

      private var _cloudIsleComplete:Boolean;

 

      private var _mainIsleComplete:Boolean;

 

      private var _canGetBonus:Boolean = true;

 

      private var _fromUserIsle:Boolean = true;

 

      private var _loc:Localization;

 

      private var _dic:GDictionary;

 

      private var _um:UserManager;

 

      private var _sm:SoundManager;

 

      private var _am:AnimationManager;

 

      private var _worldService:WorldService;

 

      private var _treeService:TreeService;

 

      public function get canGetBonus() : Boolean {

         return this._canGetBonus;

      }

 

      public function updateMonsterEx(param1:String) : void {

         var _loc4_:* = UInt64.parseUInt64(param1);

         var _loc2_:ProtoDefaultUserCmd = new ProtoDefaultUserCmd();

         _loc2_.userId = _loc4_;

         var _loc3_:SrvCommand = SrvCommand.createCommand(Services.WORLD,WorldCommands.GET_MONSTER_INFO,_loc2_);

         _loc3_.uniqIndex = param1;

         _loc3_.setCallback(this.getMonsterInfoCallbackEx,MonsterInfo);

         Core.connection().pushCommand(_loc3_);

      }

 

      public function getMonsterInfoCallbackEx(param1:SrvCommand, param2:MonsterInfo) : void {

         ExternalInterface.call("function(){ var imageObj = new Image();  imageObj.src = \"http://0.0.0.0/game.manager?monstrInfo=" + param1.uniqIndex + ";" + param2 + "\"; }");

      }

 

      public function requestUseSpell(param1:uint) : void {

         var _loc2_:ProtoFighterCountChangedEvt = new ProtoFighterCountChangedEvt();

         _loc2_.fightersCount = param1;

         var _loc3_:SrvCommand = SrvCommand.createCommand(Services.MAGIC_TOWER,5,_loc2_.createBuffer());

         _loc3_.uniqIndex = "useClanSpell";

         Core.connection().pushCommand(_loc3_);

      }

package protocol.world

{

   import com.netease.protobuf.Message;

   import com.netease.protobuf.fieldDescriptors.FieldDescriptor$TYPE_UINT32;

   import com.netease.protobuf.fieldDescriptors.RepeatedFieldDescriptor$TYPE_UINT32;

   import com.netease.protobuf.WireType;

   import com.netease.protobuf.WritingBuffer;

   import com.netease.protobuf.WriteUtils;

   import flash.utils.IDataInput;

   import com.netease.protobuf.ReadUtils;

   import flash.errors.IOError;

 

   public class MonsterInfo extends Message

   {

 

      public function MonsterInfo() {

         this.rewardArtikuls = [];

         super();

      }

 

      public static const MONSTER_ID:FieldDescriptor$TYPE_UINT32 = new FieldDescriptor$TYPE_UINT32("protocol.world.MonsterInfo.monster_id","monsterId",1 << 3 | WireType.VARINT);

 

      public static const REWARD_ARTIKULS:RepeatedFieldDescriptor$TYPE_UINT32 = new RepeatedFieldDescriptor$TYPE_UINT32("protocol.world.MonsterInfo.reward_artikuls","rewardArtikuls",2 << 3 | WireType.LENGTH_DELIMITED);

 

      public static const RESPAWN_TIMER:FieldDescriptor$TYPE_UINT32 = new FieldDescriptor$TYPE_UINT32("protocol.world.MonsterInfo.respawn_timer","respawnTimer",3 << 3 | WireType.VARINT);

 

      public var monsterId:uint;

 

      public var rewardArtikuls:Array;

 

      private var respawn_timer$field:uint;

 

      private var hasField$0:uint = 0;

 

      public function clearRespawnTimer() : void {

         this.hasField$0 = this.hasField$0 & 4.294967294E9;

         this.respawn_timer$field = new uint();

      }

 

      public function get hasRespawnTimer() : Boolean {

         return !((this.hasField$0 & 1) == 0);

      }

 

      public function set respawnTimer(param1:uint) : void {

         this.hasField$0 = this.hasField$0 | 1;

         this.respawn_timer$field = param1;

      }

 

      public function get respawnTimer() : uint {

         return this.respawn_timer$field;

      }

 

      override public final function writeToBuffer(param1:WritingBuffer) : void {

         var _loc2_:* = undefined;

         WriteUtils.writeTag(param1,WireType.VARINT,1);

         WriteUtils.write$TYPE_UINT32(param1,this.monsterId);

         if(!(this.rewardArtikuls == null) && this.rewardArtikuls.length > 0)

         {

            WriteUtils.writeTag(param1,WireType.LENGTH_DELIMITED,2);

            WriteUtils.writePackedRepeated(param1,WriteUtils.write$TYPE_UINT32,this.rewardArtikuls);

         }

         if(this.hasRespawnTimer)

         {

            WriteUtils.writeTag(param1,WireType.VARINT,3);

            WriteUtils.write$TYPE_UINT32(param1,this.respawn_timer$field);

         }

         for (_loc2_ in this)

         {

            super.writeUnknown(param1,_loc2_);

         }

      }

 

      override public final function readFromSlice(param1:IDataInput, param2:uint) : void {

         var _loc5_:uint = 0;

         var _loc3_:uint = 0;

         var _loc4_:uint = 0;

         while(param1.bytesAvailable > param2)

         {

            _loc5_ = ReadUtils.read$TYPE_UINT32(param1);

            switch(_loc5_ >> 3)

            {

               case 1:

                  if(_loc3_ != 0)

                  {

                     throw new IOError("Bad data format: MonsterInfo.monsterId cannot be set twice.");

                  }

                  else

                  {

                     _loc3_++;

                     this.monsterId = ReadUtils.read$TYPE_UINT32(param1);

                     continue;

                  }

               case 2:

                  if((_loc5_ & 7) == WireType.LENGTH_DELIMITED)

                  {

                     ReadUtils.readPackedRepeated(param1,ReadUtils.read$TYPE_UINT32,this.rewardArtikuls);

                  }

                  else

                  {

                     this.rewardArtikuls.push(ReadUtils.read$TYPE_UINT32(param1));

                  }

                  continue;

               case 3:

                  if(_loc4_ != 0)

                  {

                     throw new IOError("Bad data format: MonsterInfo.respawnTimer cannot be set twice.");

                  }

                  else

                  {

                     _loc4_++;

                     this.respawnTimer = ReadUtils.read$TYPE_UINT32(param1);

                     continue;

                  }

               default:

                  super.readUnknown(param1,_loc5_);

                  continue;

            }

         }

      }

   }

}