public static void UpdateTargets_Prefix()
 {
     if (SimulatedWorld.Initialized)
     {
         DroneManager.ClearCachedPositions();
     }
 }
Example #2
0
        public static bool BuildFinally_Prefix(PlanetFactory __instance, Player player, int prebuildId)
        {
            if (!SimulatedWorld.Initialized)
            {
                return(true);
            }

            if (LocalPlayer.IsMasterClient)
            {
                if (!FactoryManager.ContainsPrebuildRequest(__instance.planetId, prebuildId))
                {
                    // This prevents duplicating the entity when multiple players trigger the BuildFinally for the same entity at the same time.
                    // If it occurs in any other circumstances, it means that we have some desynchronization between clients and host prebuilds buffers.
                    Log.Warn($"BuildFinally was called without having a corresponding PrebuildRequest for the prebuild {prebuildId} on the planet {__instance.planetId}");
                    return(false);
                }

                // Remove the prebuild request from the list since we will now convert it to a real building
                FactoryManager.RemovePrebuildRequest(__instance.planetId, prebuildId);
            }

            if (LocalPlayer.IsMasterClient || !FactoryManager.EventFromServer)
            {
                LocalPlayer.SendPacket(new BuildEntityRequest(__instance.planetId, prebuildId, FactoryManager.PacketAuthor == -1 ? LocalPlayer.PlayerId : FactoryManager.PacketAuthor));
            }

            if (!LocalPlayer.IsMasterClient && !FactoryManager.EventFromServer)
            {
                DroneManager.AddBuildRequestSent(-prebuildId);
            }

            return(LocalPlayer.IsMasterClient || FactoryManager.EventFromServer);
        }
        static IEnumerable <CodeInstruction> FindNext_Transpiler(IEnumerable <CodeInstruction> instructions, ILGenerator iL)
        {
            var codeMatcher = new CodeMatcher(instructions, iL)
                              .MatchForward(false,
                                            new CodeMatch(i => i.opcode == OpCodes.Ldfld && ((FieldInfo)i.operand).Name == "serving"),
                                            new CodeMatch(i => i.IsLdloc()),
                                            new CodeMatch(OpCodes.Callvirt),
                                            new CodeMatch(OpCodes.Brtrue)
                                            );

            if (codeMatcher.IsInvalid)
            {
                NebulaModel.Logger.Log.Error("MechaDroneLogic_Transpiler.FindNext failed. Mod version not compatible with game version.");
                return(instructions);
            }

            var target = codeMatcher.InstructionAt(1);
            var jump   = codeMatcher.InstructionAt(3).operand;

            return(codeMatcher
                   .Advance(4)
                   .InsertAndAdvance(target)
                   .InsertAndAdvance(HarmonyLib.Transpilers.EmitDelegate <Func <int, bool> >((targetId) =>
            {
                return DroneManager.IsPendingBuildRequest(targetId);
            }))
                   .Insert(new CodeInstruction(OpCodes.Brtrue, jump))
                   .InstructionEnumeration());
        }
Example #4
0
        public void OneDroneTest()
        {
            var expected = 1;
            var actual   = DroneManager.FindUniqueDeliveryId(new int[] { 1 });

            Assert.AreEqual(expected, actual);
        }
        public void ProcessPacket(BuildEntityRequest packet, NebulaConnection conn)
        {
            PlanetData planet = GameMain.galaxy.PlanetById(packet.PlanetId);

            // We only execute the code if the client has loaded the factory at least once.
            // Else it will get it once it goes to the planet for the first time.
            if (planet.factory != null)
            {
                using (FactoryManager.EventFromServer.On())
                {
                    FactoryManager.EventFactory = planet.factory;
                    FactoryManager.TargetPlanet = packet.PlanetId;
                    FactoryManager.PacketAuthor = packet.AuthorId;

                    FactoryManager.AddPlanetTimer(packet.PlanetId);

                    //Remove building from drone queue
                    GameMain.mainPlayer.mecha.droneLogic.serving.Remove(-packet.PrebuildId);
                    planet.factory.BuildFinally(GameMain.mainPlayer, packet.PrebuildId);
                    DroneManager.RemoveBuildRequest(-packet.PrebuildId);

                    FactoryManager.PacketAuthor = -1;
                    FactoryManager.EventFactory = null;
                    FactoryManager.TargetPlanet = FactoryManager.PLANET_NONE;
                }
            }
        }
Example #6
0
        public void UniqueIdComesFirstTest()
        {
            var expected = 1;
            var actual   = DroneManager.FindUniqueDeliveryId(new int[] { 1, 2, 2 });

            Assert.AreEqual(expected, actual);
        }
Example #7
0
        public void UniqueIdInTheMiddleTest()
        {
            var expected = 1;
            var actual   = DroneManager.FindUniqueDeliveryId(new int[] { 3, 2, 1, 2, 3, 2, 2 });

            Assert.AreEqual(expected, actual);
        }
Example #8
0
        public override void ProcessPacket(NewDroneOrderPacket packet, NebulaConnection conn)
        {
            // Host does not need to know about flying drones of other players if he is not on the same planet
            if (IsHost)
            {
                if (GameMain.mainPlayer.planetId != packet.PlanetId)
                {
                    return;
                }

                Player player = playerManager.GetPlayer(conn);
                if (player != null)
                {
                    if (packet.Stage == 1 || packet.Stage == 2)
                    {
                        DroneManager.AddPlayerDronePlan(player.Id, packet.EntityId);
                    }
                    else if (packet.Stage == 3)
                    {
                        DroneManager.RemovePlayerDronePlan(player.Id, packet.EntityId);
                    }
                }
            }

            SimulatedWorld.UpdateRemotePlayerDrone(packet);
        }
Example #9
0
        public void UniqueIdComesLastTest2()
        {
            var expected = 1001;
            var actual   = DroneManager.FindUniqueDeliveryId(new int[] { 3, 17, 32, 32, 3, 17, 1001 });

            Assert.AreEqual(expected, actual);
        }
Example #10
0
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp     = (SerialPort)sender;
            string     inData = sp.ReadExisting();

            DroneManager.GetInstance().DataReceived(inData);
        }
Example #11
0
        public void ManyDronesTest()
        {
            var expected = 8;
            var actual   = DroneManager.FindUniqueDeliveryId(new int[] { 2, 5, 4, 8, 6, 3, 1, 4, 2, 3, 6, 5, 1 });

            Assert.AreEqual(expected, actual);
        }
Example #12
0
        static void Main(string[] args)
        {
            DroneManager m      = new DroneManager(args[0]);
            Thread       thread = new Thread(m.Process);

            thread.Start(m);
        }
Example #13
0
 public static void SellPlant(Plant plant, int storeX, int storeY)
 {
     plant.x = storeX;
     plant.y = storeY;
     soldPlants.Add(plant);
     soldPlantTimers.Add(0f);
     moneyForFarmers++;
     if (moneyForFarmers >= 10)
     {
         if (FarmerManager.farmerCount < FarmerManager.instance.maxFarmerCount)
         {
             FarmerManager.SpawnFarmer(storeX, storeY);
             moneyForFarmers -= 10;
         }
     }
     moneyForDrones++;
     if (moneyForDrones >= 50)
     {
         for (int i = 0; i < 5; i++)
         {
             if (DroneManager.droneCount < DroneManager.instance.maxDroneCount)
             {
                 DroneManager.SpawnDrone(storeX, storeY);
             }
         }
         moneyForDrones -= 50;
     }
 }
Example #14
0
    public void OnObjectInitiate(SpriteManager sm)
    {
        droneManager = (DroneManager)sm;
        this.transform.SetParent(sm.transform);

        bodyRenderer = BodyObject().GetComponent <SpriteRenderer>();
        initialColor = bodyRenderer.color;
    }
 void Start()
 {
     droneManager = this.GetComponent <DroneManager>();
     droneItem    = this.GetComponent <DroneItem>();
     //itemMask = LayerMask.GetMask("ITEM");
     //StartCoroutine(SpherecastHit());
     //StartCoroutine(SummonItem());
 }
Example #16
0
 // Tracking Line 끄고 키는 기능
 public void ToggleLineTracking(bool _bset)
 {
     for (int i = 0; i < DroneObjectList.Count; i++)
     {
         DroneManager _dm = DroneObjectList [i].GetComponent <DroneManager>();
         _dm.SetLineActive(_bset);
     }
 }
Example #17
0
 protected override void OnStart(string[] args)
 {
     //Start the main thread that will begin processing the data
     args           = Environment.GetCommandLineArgs();
     _manager       = new DroneManager(args[1]);       //param is the folder for which service we want to run (make sure dll's are all in the appropriate path
     _managerThread = new Thread(_manager.Process);
     _managerThread.Start(_manager);
 }
Example #18
0
 void Awake()
 {
     if (instance == null)
     {
         instance = this;
     }
     else if (instance != this)
     {
         Destroy(this);
     }
 }
Example #19
0
        public static void Initialize()
        {
            DroneManager.Initialize();
            FactoryManager.Initialize();
            PlanetManager.Initialize();
            Initialized = true;
            ExitingMultiplayerSession = false;

            using (GetRemotePlayersModels(out var remotePlayersModels))
            {
                remotePlayersModels.Clear();
            }
        }
Example #20
0
        public MainWindow()
        {
            InitializeComponent();
            ResizeMode = ResizeMode.NoResize;//disable sizing options
            DroneManager.SetMainWindow(this);

            //gives promition to HTML/pilot
            string curdir = Directory.GetCurrentDirectory();

            Gmaps.Navigate(String.Format("file:///{0}/HTML/pilot.html", curdir));


            refreshCom();
        }
Example #21
0
        protected override void CreateManagers()
        {
            base.CreateManagers();

            GameStateManager.CreateFromPrefab(_gameStateManagerPrefab, ManagersContainer);
            UIManager.CreateFromPrefab(_uiManagerPrefab, ManagersContainer);
            GameManager.CreateFromPrefab(_gameManagerPrefab, ManagersContainer);
            PlayerManager.CreateFromPrefab(_playerManagerPrefab, ManagersContainer);
            SpawnManager.Create(ManagersContainer);
            ItemManager.CreateFromPrefab(_itemManagerPrefab, ManagersContainer);
            HighScoreManager.Create(ManagersContainer);
            MailboxManager.CreateFromPrefab(_mailboxManagerPrefab, ManagersContainer);
            DroneManager.Create(ManagersContainer);
        }
        public void ProcessPacket(BuildEntityRequest packet, NebulaConnection conn)
        {
            PlanetData planet = GameMain.galaxy.PlanetById(packet.PlanetId);

            // We only execute the code if the client has loaded the factory at least once.
            // Else it will get it once it goes to the planet for the first time.
            if (planet.factory != null)
            {
                using (FactoryManager.EventFromServer.On())
                {
                    FactoryManager.EventFactory = planet.factory;
                    FactoryManager.PacketAuthor = packet.AuthorId;

                    // Physics could be null, if the host is not on the requested planet
                    if (packet.PlanetId != GameMain.localPlanet?.id)
                    {
                        planet.physics = new PlanetPhysics(planet);
                        planet.physics.Init();

                        planet.audio = new PlanetAudio(planet);
                        planet.audio.Init();
                    }

                    //Remove building from drone queue
                    GameMain.mainPlayer.mecha.droneLogic.serving.Remove(-packet.PrebuildId);
                    planet.factory.BuildFinally(GameMain.mainPlayer, packet.PrebuildId);
                    if (!DroneManager.RemoveBuildRequest(-packet.PrebuildId))
                    {
                        Log.Warn($"Build Request was not succesfully removed.");
                    }
                    planet.factory.BuildFinally(GameMain.mainPlayer, packet.PrebuildId);

                    // Make sure to free the physics once the FlattenTerrain is done
                    if (packet.PlanetId != GameMain.localPlanet?.id)
                    {
                        planet.physics.Free();
                        planet.physics = null;

                        planet.audio.Free();
                        planet.audio = null;
                    }
                    FactoryManager.PacketAuthor = -1;
                    FactoryManager.EventFactory = null;
                }
            }
        }
Example #23
0
    // 드론을 DronePatrol 에서 복사함
    private GameObject MakeDrone(DronePointData _data, int iNo)
    {
        GameObject Create_Drone;
        GameObject org_Drone;

        org_Drone = GameObject.Find("DronePatrol");

        Vector3 startPos = _data.GetPoint_Vector3(0);

        Create_Drone = Instantiate(org_Drone, startPos, org_Drone.transform.rotation);
        DroneManager _dm = Create_Drone.GetComponent <DroneManager>(); // 드론 오브젝트 내의 원활한 데이터 처리를 위한 클래스를 불러옴.

        _dm.SetPointData(_data);                                       //Point 데이터리스트를 전달
        _dm.SetColor(ColorList[iColorCount++]);                        //Line 색상을 전달
        Create_Drone.name = "Drone" + iNo.ToString();

        return(Create_Drone);
    }
Example #24
0
    // Start is called before the first frame update
    void Start()
    {
        this.dm = gameObject.GetComponent <DroneManager>();
        if (this.whatAmI == playerType.monster)
        {
            //        try {
            this.mb = GameObject.Find("Player").GetComponent <monsterbase>();
            //      }
            //    catch { }
        }
        else
        {
            this.pc = GameObject.Find("PlaneBase").GetComponent <PlaneController>();
        }

        this.RegisterWithServer();

        Debug.Log("sdalfasdfdasfa");
        Beep();
    }
Example #25
0
    // Start is called before the first frame update
    void Start()
    {
        fireCounter = fireDelay;
        x           = Random.Range(-BossDist, BossDist);
        y           = Random.Range(-BossDist, BossDist);


        while (x > -2 && x < 2)
        {
            x = Random.Range(-BossDist, BossDist);
        }
        while (y > -2 && y < 2)
        {
            y = Random.Range(-BossDist, BossDist);
        }

        dronemanager = FindObjectOfType <DroneManager>();
        start        = true;
        player       = PlayerController.instance.transform;
        center       = dronemanager.transform.position;
    }
Example #26
0
        public void PlayerDisconnected(NebulaConnection conn)
        {
            using (GetConnectedPlayers(out var connectedPlayers))
            {
                if (connectedPlayers.TryGetValue(conn, out Player player))
                {
                    SendPacketToOtherPlayers(new PlayerDisconnected(player.Id), player);
                    SimulatedWorld.DestroyRemotePlayerModel(player.Id);
                    connectedPlayers.Remove(conn);
                    using (threadSafe.availablePlayerIds.GetLocked(out var availablePlayerIds))
                    {
                        availablePlayerIds.Enqueue(player.Id);
                    }
                    StatisticsManager.instance.UnRegisterPlayer(player.Id);

                    //Notify players about queued building plans for drones
                    int[] DronePlans = DroneManager.GetPlayerDronePlans(player.Id);
                    if (DronePlans != null && DronePlans.Length > 0 && player.Data.LocalPlanetId > 0)
                    {
                        LocalPlayer.SendPacketToPlanet(new RemoveDroneOrdersPacket(DronePlans), player.Data.LocalPlanetId);
                        //Remove it also from host queue, if host is on the same planet
                        if (GameMain.mainPlayer.planetId == player.Data.LocalPlanetId)
                        {
                            for (int i = 0; i < DronePlans.Length; i++)
                            {
                                GameMain.mainPlayer.mecha.droneLogic.serving.Remove(DronePlans[i]);
                            }
                        }
                    }
                }
                else
                {
                    Log.Warn($"PlayerDisconnected NOT CALLED!");
                }

                // TODO: Should probably also handle playing that disconnect during "pending" or "syncing" steps.
            }
        }
Example #27
0
        public override void ProcessPacket(BuildEntityRequest packet, NebulaConnection conn)
        {
            if (IsHost && !FactoryManager.ContainsPrebuildRequest(packet.PlanetId, packet.PrebuildId))
            {
                Log.Warn($"BuildEntityRequest received does not have a corresponding PrebuildRequest with the id {packet.PrebuildId} for the planet {packet.PlanetId}");
                return;
            }

            PlanetData planet = GameMain.galaxy.PlanetById(packet.PlanetId);

            // We only execute the code if the client has loaded the factory at least once.
            // Else it will get it once it goes to the planet for the first time.
            if (planet.factory != null)
            {
                using (FactoryManager.IsIncomingRequest.On())
                {
                    FactoryManager.EventFactory = planet.factory;
                    FactoryManager.TargetPlanet = packet.PlanetId;
                    FactoryManager.PacketAuthor = packet.AuthorId;

                    FactoryManager.AddPlanetTimer(packet.PlanetId);

                    //Remove building from drone queue
                    GameMain.mainPlayer.mecha.droneLogic.serving.Remove(-packet.PrebuildId);
                    planet.factory.BuildFinally(GameMain.mainPlayer, packet.PrebuildId);

                    if (IsClient)
                    {
                        DroneManager.RemoveBuildRequest(-packet.PrebuildId);
                    }

                    FactoryManager.EventFactory = null;
                    FactoryManager.PacketAuthor = FactoryManager.AUTHOR_NONE;
                    FactoryManager.TargetPlanet = FactoryManager.PLANET_NONE;
                }
            }
        }
        static IEnumerable <CodeInstruction> UpdateTargets_Transpiler(IEnumerable <CodeInstruction> instructions, ILGenerator iL)
        {
            /*
             * Update search for new targets. Do not include targets that are already pending response from server.
             * Change:
             *   if (!this.serving.Contains(num4) && (prebuildPool[i].itemRequired == 0 || prebuildPool[i].itemRequired <= this.player.package.GetItemCount((int)prebuildPool[i].protoId)))
             *
             * To:
             *   if (!this.serving.Contains(num4) && !DroneManager.IsPendingBuildRequest(num4) && (prebuildPool[i].itemRequired == 0 || prebuildPool[i].itemRequired <= this.player.package.GetItemCount((int)prebuildPool[i].protoId)))
             */
            var codeMatcher = new CodeMatcher(instructions, iL)
                              .MatchForward(true,
                                            new CodeMatch(i => i.IsLdarg()),
                                            new CodeMatch(i => i.opcode == OpCodes.Ldfld && ((FieldInfo)i.operand).Name == "serving"),
                                            new CodeMatch(i => i.IsLdloc()),
                                            new CodeMatch(i => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "Contains"),
                                            new CodeMatch(OpCodes.Brtrue)
                                            );

            if (codeMatcher.IsInvalid)
            {
                NebulaModel.Logger.Log.Error("MechaDroneLogic_Transpiler.UpdateTargets_Transpiler 1 failed. Mod version not compatible with game version.");
                return(instructions);
            }

            var num4Instruction = codeMatcher.InstructionAt(-2);
            var jumpInstruction = codeMatcher.Instruction;

            codeMatcher = codeMatcher
                          .Advance(1)
                          .InsertAndAdvance(num4Instruction)
                          .InsertAndAdvance(HarmonyLib.Transpilers.EmitDelegate <Func <int, bool> >((num4) =>
            {
                return(DroneManager.IsPendingBuildRequest(num4));
            }))
                          .InsertAndAdvance(jumpInstruction);

            /*
             * Make sure targets are only chosen if player is closest to the build preview
             * Change:
             *  if (a.sqrMagnitude > this.sqrMinBuildAlt && sqrMagnitude <= num2)
             * To:
             *  if (DroneManager.AmIClosestPlayer(ref a) && a.sqrMagnitude > this.sqrMinBuildAlt && sqrMagnitude <= num2)
             */
            codeMatcher = codeMatcher
                          .MatchForward(false,
                                        new CodeMatch(i => i.IsLdloc()),
                                        new CodeMatch(i => i.opcode == OpCodes.Call && ((MethodInfo)i.operand).Name == "get_sqrMagnitude"),
                                        new CodeMatch(OpCodes.Ldarg_0),
                                        new CodeMatch(i => i.opcode == OpCodes.Ldfld && ((FieldInfo)i.operand).Name == "sqrMinBuildAlt"),
                                        new CodeMatch(OpCodes.Ble_Un)
                                        );

            if (codeMatcher.IsInvalid)
            {
                NebulaModel.Logger.Log.Error("MechaDroneLogic_Transpiler.UpdateTargets_Transpiler 2 failed. Mod version not compatible with game version.");
                return(codeMatcher.InstructionEnumeration());
            }

            var aOperand    = codeMatcher.Instruction.operand;
            var jumpOperand = codeMatcher.InstructionAt(4).operand;

            codeMatcher = codeMatcher
                          .InsertAndAdvance(new CodeInstruction(OpCodes.Ldloc_S, aOperand))
                          .InsertAndAdvance(HarmonyLib.Transpilers.EmitDelegate <Func <Vector3, bool> >((aVar) =>
            {
                return(DroneManager.AmIClosestPlayer(ref aVar));
            }))
                          .InsertAndAdvance(new CodeInstruction(OpCodes.Brfalse, jumpOperand));

            /*
             * Insert
             *  DroneManager.BroadcastDroneOrder(droneId, entityId, stage);
             * After
             *  this.serving.Add(num3);
             */
            codeMatcher = codeMatcher
                          .MatchForward(true,
                                        new CodeMatch(i => i.IsLdarg()),
                                        new CodeMatch(i => i.opcode == OpCodes.Ldfld && ((FieldInfo)i.operand).Name == "serving"),
                                        new CodeMatch(i => i.IsLdloc()),
                                        new CodeMatch(i => i.opcode == OpCodes.Callvirt && ((MethodInfo)i.operand).Name == "Add"),
                                        new CodeMatch(OpCodes.Pop)
                                        );

            if (codeMatcher.IsInvalid)
            {
                NebulaModel.Logger.Log.Error("MechaDroneLogic_Transpiler.UpdateTargets_Transpiler 3 failed. Mod version not compatible with game version.");
                return(codeMatcher.InstructionEnumeration());
            }

            // The index from drones[j]
            var droneIdInstruction = codeMatcher.InstructionAt(-8);

            // num3 from this.serving.Add(num3);
            var entityIdInstruction = codeMatcher.InstructionAt(-2);

            // drones[j].stage = 1;
            var stageInstruction = new CodeInstruction(OpCodes.Ldc_I4_1);

            return(codeMatcher
                   .Advance(1)
                   .InsertAndAdvance(droneIdInstruction)
                   .InsertAndAdvance(entityIdInstruction)
                   .InsertAndAdvance(stageInstruction)
                   .InsertAndAdvance(HarmonyLib.Transpilers.EmitDelegate <Action <int, int, int> >((droneId, entityId, stage) =>
            {
                DroneManager.BroadcastDroneOrder(droneId, entityId, stage);
            }))
                   .InstructionEnumeration());
        }
Example #29
0
        public static void SendPlayer(Player player)
        {
            try
            {
                player.SendCommand(player.GetShipInitializationCommand());

                if (player.Title != "")
                {
                    player.SendPacket($"0|n|t|{player.Id}|1|{player.Title}");
                }

                player.SendPacket(player.DroneManager.GetDronesPacket());
                player.SendCommand(DroneFormationChangeCommand.write(player.Id, DroneManager.GetSelectedFormationId(player.Settings.InGameSettings.selectedFormation)));
                player.SendPacket("0|S|CFG|" + player.CurrentConfig);

                player.SendPacket($"0|A|BK|{player.Equipment.Items.BootyKeys}");
                //player.SendPacket("0|A|JV|0"); //atlama kuponu miktarı

                if (player.Group != null)
                {
                    player.Group.InitializeGroup(player);
                }

                var spaceball = EventManager.Spaceball.Character;
                if (EventManager.Spaceball.Active && spaceball != null)
                {
                    player.SendPacket($"0|n|ssi|{spaceball.Mmo}|{spaceball.Eic}|{spaceball.Vru}");
                }
                else
                {
                    player.SendPacket($"0|n|ssi|0|0|0");
                }

                /*
                 * var priceList = new List<JumpCPUPriceMappingModule>();
                 * var price = new List<int>();
                 * price.Add(1);
                 * price.Add(14);
                 * price.Add(15);
                 * price.Add(16);
                 * priceList.Add(new JumpCPUPriceMappingModule(0, price));
                 * player.SendCommand(JumpCPUUpdateCommand.write(priceList));
                 *
                 * player.SendCommand(CpuInitializationCommand.write(true, false));
                 */
                //player.SendPacket("0|A|JCPU|S|20|1"); //ATLAMA GERİ SAYIM

                player.SendCommand(SetSpeedCommand.write(player.Speed, player.Speed));
                player.Spacemap.SendObjects(player);

                player.BoosterManager.Update();

                if (player.Pet != null)
                {
                    player.SendCommand(PetInitializationCommand.write(true, true, !player.Settings.InGameSettings.petDestroyed));

                    if (player.Settings.InGameSettings.petDestroyed)
                    {
                        player.SendCommand(PetUIRepairButtonCommand.write(true, 250));
                    }
                }

                player.UpdateStatus();

                //player.SendCommand(UbaWindowInitializationCommand.write(new Ubas3wModule(new UbaG3FModule(0, 0, 0, 0), new Uba64iModule("", 0, new //List<UbaHtModule>()), new UbahsModule(new List<Ubal4bModule>())), 0));


                //player.SendCommand(VideoWindowCreateCommand.write(1, "l", true, new List<string> { "start_head", "tutorial_video_msg_reward_premium_intro" }, 1, 1));

                //player.SendPacket("0|n|KSMSG|start_head");


                //player.SendCommand(command_e4W.write(1, "", new class_oS(0, 0, 0, 0, 0, 0, 0, 0, 0, 0), "", new class_s16(1, class_s16.varC3p), 1));

                //player.SendCommand(command_z3Q.write(command_z3Q.varC2f));

                /*
                 * var contacts = new List<class_i1d>();
                 *
                 * var DDDDD = new List<class_84I>();
                 *
                 *
                 * var DDDDsD = new List<class_533>();
                 * DDDDsD.Add(new class_533(class_533.varN2g));
                 *
                 * contacts.Add(new class_i1d(new class_O4f(2, DDDDD), new class_y3i(2, DDDDsD)));
                 * contacts.Add(new class_i1d(new class_O4f(1, DDDDD), new class_y3i(1, DDDDsD)));
                 *
                 * player.SendCommand(ContactsListUpdateCommand.write(new class_o3q(contacts), new class_g1a(true, true, true, true), new class_H4Q(false)));
                 */

                /*
                 * if (isLogin)
                 * {
                 * UBA SEASON
                 *
                 *  var ht = new List<UbaHtModule>();
                 *  var j3s = new List<command_j3s>();
                 *  j3s.Add(new Ubaf3kModule("currency_uridium", 250000));
                 *  ht.Add(new UbaHtModule("asddas", j3s));
                 *
                 *  var l4b = new List<Ubal4bModule>();
                 *  l4b.Add(new Ubal4bModule("Bilmemne Sezonu", 2));
                 *
                 *  player.SendCommand(UbaWindowInitializationCommand.write(new Ubas3wModule(new UbaG3FModule(55, 60, 5, 333443), new Uba64iModule("Yaz Sezonu", 1, ht), new UbahsModule(l4b)), 0));
                 * }
                 */

                player.SendCommand(player.GetBeaconCommand());
            }
            catch (Exception e)
            {
                Out.WriteLine("UID: " + player.Id + " SendPlayerItems void exception: " + e, "LoginRequestHandler.cs");
                Logger.Log("error_log", $"- [LoginRequestHandler.cs] SendPlayerItems void exception: {e}");
            }
        }
Example #30
0
        public bool AddInRangeCharacter(Character character)
        {
            try
            {
                if (character == null || InRangeCharacters.ContainsKey(character.Id) || character.Destroyed || character.Id == Id || character.Spacemap.Id != Spacemap.Id)
                {
                    return(false);
                }

                var success = InRangeCharacters.TryAdd(character.Id, character);

                if (success)
                {
                    InRangeCharacterAdded?.Invoke(this, new CharacterArgs(character));

                    if (this is Player player)
                    {
                        short relationType = character.Clan.Id != 0 && Clan.Id != 0 ? Clan.GetRelation(character.Clan) : (short)0;

                        if (character is Player)
                        {
                            var otherPlayer = character as Player;
                            player.SendCommand(otherPlayer.GetShipCreateCommand(player, relationType));

                            if (otherPlayer.Title != "" && !EventManager.JackpotBattle.InEvent(otherPlayer))
                            {
                                player.SendPacket($"0|n|t|{otherPlayer.Id}|1|{otherPlayer.Title}");
                            }

                            player.SendPacket(otherPlayer.DroneManager.GetDronesPacket());
                            player.SendCommand(DroneFormationChangeCommand.write(otherPlayer.Id, DroneManager.GetSelectedFormationId(otherPlayer.Settings.InGameSettings.selectedFormation)));
                        }
                        else if (character is Pet)
                        {
                            var pet = character as Pet;
                            if (pet == player.Pet)
                            {
                                player.SendCommand(PetHeroActivationCommand.write(pet.Owner.Id, pet.Id, 22, 3, pet.Name, (short)pet.Owner.FactionId, pet.Owner.Clan.Id, 15, pet.Owner.Clan.Tag, pet.Position.X, pet.Position.Y, pet.Speed, new class_11d(class_11d.DEFAULT)));
                            }
                            else
                            {
                                player.SendCommand(PetActivationCommand.write(pet.Owner.Id, pet.Id, 22, 3, pet.Name, (short)pet.Owner.FactionId, pet.Owner.Clan.Id, 15, pet.Owner.Clan.Tag, new ClanRelationModule(relationType), pet.Position.X, pet.Position.Y, pet.Speed, false, true, new class_11d(class_11d.DEFAULT)));
                            }
                        }
                        else
                        {
                            player.SendCommand(character.GetShipCreateCommand());
                        }

                        var timeElapsed = (DateTime.Now - character.MovementStartTime).TotalMilliseconds;
                        player.SendCommand(MoveCommand.write(character.Id, character.Destination.X, character.Destination.Y, (int)(character.MovementTime - timeElapsed)));
                    }
                }

                return(success);
            }
            catch (Exception e)
            {
                Out.WriteLine("AddInRangeCharacter void exception " + e, "Character.cs");
                Logger.Log("error_log", $"- [Character.cs] AddInRangeCharacter void exception: {e}");
                return(false);
            }
        }