public void InitializeShip(int x, int y)
    {
        if (!CheckIfCoordinatesExists(x, y))
        {
            return;
        }

        currentCoordinates = new PlayerCoordinates(x, y);
    }
Exemplo n.º 2
0
        private PlayerCoordinates getCoords()
        {
            PlayerCoordinates coordinates = new PlayerCoordinates
            {
                Z_AXIS = getValueFloat(getAddressLevelFour(localPlayerBase, OffSets.Z_COORD_1, OffSets.Z_COORD_2, OffSets.Z_COORD_3, OffSets.Z_COORD_4)),
                X_AXIS = getValueFloat(getAddressLevelFour(localPlayerBase, OffSets.X_COORD_1, OffSets.X_COORD_2, OffSets.X_COORD_3, OffSets.X_COORD_4)),
                Y_AXIS = getValueFloat(getAddressLevelFour(localPlayerBase, OffSets.Y_COORD_1, OffSets.Y_COORD_2, OffSets.Y_COORD_3, OffSets.Y_COORD_4))
            };

            return(coordinates);
        }
Exemplo n.º 3
0
        public override void Draw(GameTime gameTime)
        {
            fpsCounter.Draw(gameTime);

            Nocubeless.SpriteBatch.DrawString(font,
                                              "Player coordinates:\n" + PlayerCoordinates.ToString() +
                                              "\nIn chunk: " + ChunkCoordinates.ToString() +
                                              "\nPreviewable cube coordinates:\n" + ((Nocubeless.CubeWorld.PreviewableCube is null) ? "{None}" : Nocubeless.CubeWorld.PreviewableCube.Coordinates.ToString()) +
                                              "\n\nCurrent state: " + state,
                                              coordinatesDrawPosition, Color.Black);

            Nocubeless.SpriteBatch.DrawString(font,
                                              "FPS: " + fpsCounter.FramesPerSecond.ToString(CultureInfo.CurrentCulture),
                                              fpsDrawPosition, Color.Black);

            base.Draw(gameTime);
        }
Exemplo n.º 4
0
        private Tuple <Guid, object> ProcessData(GameCommands command, string playerIdData, string mainData, string IPAddress)
        {
            switch (command)
            {
            case GameCommands.None:
                break;

            case GameCommands.Login:
                _gameState.PlayersLoggedIn.AddOrUpdate(Guid.Parse(playerIdData), IPAddress, (key, oldvalue) => IPAddress);
                return(new Tuple <Guid, object>(Guid.Parse(playerIdData), IPAddress));

            case GameCommands.Position:
                PlayerCoordinates playerCoordinates = new PlayerCoordinates()
                {
                    X = uint.Parse(mainData.Substring(0, 4)),
                    Y = uint.Parse(mainData.Substring(4, 4)),
                };
                _gameState.PlayerCoordinates.AddOrUpdate(Guid.Parse(playerIdData), playerCoordinates, (key, oldvalue) => playerCoordinates);
                return(new Tuple <Guid, object>(Guid.Parse(playerIdData), playerCoordinates));
            }

            return(null);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Your own user code starts here.
        /// If this is your first time, do consider reading the notice above.
        /// It contains some very useful information.
        /// </summary>
        public static void Init()
        {
            /*
             *  Reloaded Mod Loader Sample: Memory Manipulation
             *  Architectures supported: X86, X64
             *
             *  An example of memory manipulation in Reloaded, showing how easily it is
             *  possible to write or read structures to and from memory.
             */

            // Want to see this in with a debugger? Uncomment this line.
            // Debugger.Launch();

            /// //////////////////////////////////
            /// Example #1: Reading/Writing Memory
            /// //////////////////////////////////

            // First let's allocate some memory to write our data to.
            // See footnote at 1*, you should really instead use the MemoryBufferManager class for this.
            IntPtr addressOfAllocation = GameProcess.AllocateMemory(2048);

            Bindings.PrintInfo($"Memory allocated at {addressOfAllocation.ToString("X")}");

            // Now let's write some memory to the given address.
            int oneThreeThreeSeven = 1337;

            GameProcess.WriteMemory(addressOfAllocation, ref oneThreeThreeSeven);
            Bindings.PrintInfo($"Written {1337} to address {addressOfAllocation.ToString("X")}");

            // Wait what!? That simple??
            // Well, of course, under the hood we use some generics and fancy C# to automatically convert a type
            // into an array of bytes to write into memory. Feel free to verify the result with Cheat Engine.

            // Let's read this address back.
            int valueAtAddress = GameProcess.ReadMemory <int>(addressOfAllocation);

            Bindings.PrintInfo($"Read {valueAtAddress} from address {addressOfAllocation.ToString("X")}");

            /// //////////////////////////////////////
            /// Example #2: Reading/Writing Structures
            /// //////////////////////////////////////

            // Let's try something a bit more complex now.
            addressOfAllocation += sizeof(int);     // Keep our previously written integer for later so you can verify it's there.
            Bindings.PrintInfo($"Demo #2, Read/Write address now at {addressOfAllocation.ToString("X")}");

            // Let's create and write our own custom structure.
            PlayerCoordinates playerCoordinates = new PlayerCoordinates()
            {
                xPosition = 10,
                yPosition = 1368.62F,
                zPosition = -5324.677F
            };

            // Now let's write it to memory.
            GameProcess.WriteMemory(addressOfAllocation, ref playerCoordinates);
            Bindings.PrintInfo($"Written arbitrary player coordinates {playerCoordinates.xPosition} {playerCoordinates.yPosition} {playerCoordinates.zPosition} to address {addressOfAllocation.ToString("X")}");

            // Wait... Nothing changed?
            // Of course I did say something about generics and fancy C# didn't I?
            // Let's read it back.
            PlayerCoordinates newPlayerCoordinates = GameProcess.ReadMemory <PlayerCoordinates>(addressOfAllocation);

            Bindings.PrintInfo($"Read player coordinates back from {addressOfAllocation.ToString("X")}");

            // Check if we are equal.
            if (newPlayerCoordinates.xPosition == playerCoordinates.xPosition &&
                newPlayerCoordinates.yPosition == playerCoordinates.yPosition &&
                newPlayerCoordinates.zPosition == playerCoordinates.zPosition)
            {
                Bindings.PrintInfo($"Success: See? It's incredibly easy!");
            }
            else
            {
                Bindings.PrintInfo($"Failure: Read back player coordinates are not equal.");
            }

            /// /////////////////////////////////////////
            /// Example #3: Reading/Writing Struct Arrays
            /// /////////////////////////////////////////

            // But what about arrays?
            // Well, libReloaded has an utility for even that.
            // First let's read some arbitrary array from a file and write it to memory.
            Bindings.PrintInfo($"Demo #3, Array Read/Write Test Begin! (This one you should see in a debugger)");

            // First write our arbitrary physics data into memory.
            byte[] physicsData   = File.ReadAllBytes($"{ModDirectory}\\phys.bin"); // ModDirectory is from Reloaded Template
            IntPtr arrayLocation = MemoryBufferManager.Add(physicsData);           // A good example of using MemoryBufferManager (see note below),

            // normally no guarantee our data will fit into our allocated memory,
            // MemoryBufferManager also handles that case without extra code.
            Bindings.PrintInfo($"Character physics data written to {arrayLocation.ToString("X")}");

            // Now let's read back the memory.
            // Length of array for this sample is known as 40.
            FixedArrayPtr <AdventurePhysics> adventurePhysicsArray = new FixedArrayPtr <AdventurePhysics>(arrayLocation, 40);

            // Let's try to read one entry back from memory.
            AdventurePhysics firstEntry = adventurePhysicsArray[0];                     // Wow! It's almost like a native array... isn't it?

            // But we want to know everything! Give me it all!
            AdventurePhysics[] adventurePhysicses = adventurePhysicsArray.ToArray();    // Huh? That's it. Yup.

            // How about writing to one of the entries?
            firstEntry.HangTime      = 1337;
            adventurePhysicsArray[0] = firstEntry;                                      // You've gotta be kidding me...
            Bindings.PrintInfo($"Physics at {arrayLocation.ToString("X")} changed.");
            Bindings.PrintInfo($"Demo end.");
        }