Ma-Shell

You can not 100% protect the game files. You can only make it hard enough for an attacker to eventually give up and lose interest in deobfuscating what you did. The reason, why it is not possible to protect the files is that the pc must be able to execute and therefore decrypt your files and an attacker can simply e.g. attach a debugger to your program and read the contents from memory or reverse engineer the decryption-process. For this reason, one option for an attacker to cheat is by simply modifying the game files. For multiplayer games, an attacker can actually simply send data to the players / the server, without even touching your game files, if they figure out the protocol you are using. They can learn about your protocol e.g. by simply analyzing networking-dumps. The other party does not have any possibility to check that the data was sent from your program and not from any other program capable of sending networking-packets.

Why would the server do that? It should instead just tell the client the correct current state, the client takes this state as the new truth (it might use some smoothing operations, so the objects don't flip around) and starts simulating from that new state again... No need to simulate the past, if the actual current state is known. This network-model you are describing is called "client side prediction" and by googling that term, you should be able to find lots of articles to help you further with this.

You can see in the file "Leadwerks\Include\Classes\Drivers\Physics\NewtonDynamics\NewtonDynamicsPhysicsDriver.h", that the PhysicsDriver has a reference to the collisionWorld, which is a NewtonWorld pointer. You can get the current physics-driver from "_currentPhysicsDriver" but you need to cast it to a NewtonDynamicsPhysicsDriver, thus: ((NewtonDynamicsPhysicsDriver*)(_currentPhysicsDriver))->collisionWorld should be the droid you're looking for. (I haven't tested this but I am fairly certain, this will work)

The warning about spectre does not have anything to do with that linker error. Could you verify that the lib-file exists? It should be most likely in (the number might differ) C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.16.27023\lib\x86\libcpmtd.lib Furthermore make sure, the path, where you found the library is found in the Library Directories (in the expanded form of the $(VC_LibraryPath_x86) variable) of your active configuration (see image below) Also make sure, you are using the correct platform toolset: General -> Platform Toolset should be set to "Visual Studio 2017 (v141)" (at least it is for me )

(https://www.leadwerks.com/community/blogs/entry/2387-getting-started-with-vulkan/?tab=comments#comment-10207) So, do you wish to take back that statement or did you now find other ways to optimize that were not possible in the OpenGL implementation? Anyway, I'm happy, you decided to go with Vulkan

Which bootloader do you use? In the case of grub (Ubuntu default), you can press "e" before the countdown runs out and then modify the boot-string by simply appending "init=/bin/bash" to the end of the line which starts with "linux /boot/vmlinuz...". You might need to manually mount your harddrives before you can access them, not sure.

Just remove "exec". As @aiaf mentioned, by writing "exec", the process running the bash-script is replaced with the new one and thus the script is not further executed. Just leave out that one word and you should be fine.

Don't know about shadmar's one but you can try that one:

That way makes total sense to me. With Load() you are creating the first instance and with Copy() you are copying that instance... Copying (as opposed to instancing) makes only sense if you already have an object using that model, so you can just use that one. Have you tried the suggestion using the "Asset::CreateNew"-parameter?

For me this behaviour you described makes perfectly sense. The call to "Load" creates your first instance and the call to "Copy" creates your second instance by copying the first one. So if you could get a hand on your other model instance which comes from the same asset, you could go ahead and call other_instance->Copy(true) and you would get what you wanted. Furthermore, the documentation of Load (https://www.leadwerks.com/learn?page=API-Reference_Object_Entity_Model_Load) mentions that there is a second parameter called "flags" but it does not say, which ones are available. The description is simply "asset load parameters". That is something, you might want to add to the documentation @Josh. From the header file Asset.h, I find the following four constants defined, which I believe are those mentioned asset load parameters: Unmanaged, CreateNew, LoadQuiet and SkipTextures. You might want to give the following a shot (I haven't tried it myself): Model::Load("Models/level/ground.mdl", Asset::CreateNew);

The lua interpreter does a lot of memory allocating and deallocating, causing these false positives to show up. See more here:

The problem you are trying to solve is called "Principal Component Analysis (PCA)". The process involves quite a lot of math, computing Eigenvalues, etc. I'm not entirely familiar with how it works either but just throwing this term at you, so you can use the name for further research

Josh seems to have a way to extract the files if you can prove ownership to him: https://www.leadwerks.com/community/topic/16895-do-you-need-your-encrypted-game-files-extracted/?do=getNewComment

Nice, I like the concept you are proposing here. Just adding my 2 ct: When you said, there was no remove-function for a script, that makes perfect sense for scripts that are only setting variables, as you mentioned. However, you might want to have the option to remove these functions. Let's consider your tank-example: If you somehow lose your main cannon, you might want to remove the script associated with it, such that future calls to GetTarget() do not call the function of the main cannon anymore. There is another issue with your tank-example: If you have two functions called GetTarget(), you would likely also name the corresponding setter-function SetTarget(), each. However, this would mean that you can only set the target of both at the same time, if you did not name them AISetTarget() and CanonSetTarget(). For this reason, I think, you should draw a line here so you have to make explicit whether you want to call functions from a different script or only those of the same script. I would suggest, you do the following: SetTarget() will only execute the function from the current script. If there is no function named SetTarget in the current script, an error should be thrown All::SetTarget() (or something similar) will execute functions from all attached scripts (as well, as the current script) with the current name (i.e. the way you proposed) FILENAME::SetTarget() will only execute the function from the script called FILENAME. If this script does not exist or it does not have this function, an error should be thrown So for each function you define in your script, you would need to internally create three different mappings. Doing this would give everyone maximal flexibility while at the same time preventing some unforeseen errors. So, everyone could still use their isolated scripts the way they used them before without even needing to change anything. If you want to call functions from other scripts, you have the choice to select either only one specific other script or all others

In order to move the rotation center, you need to translate the point, such that the new rotation center lays at (0, 0), then apply the rotation matrix and then translate it back. This means, you need to change the last line to something similar to vTexCoords0 = (texcoords[gl_VertexID] - vec2(0.5, 0.5)) * rot + vec2(0.5, 0.5); I haven't tried it out, so you might need to switch the minus and the plus or play around a little bit but something like this should do the trick