Building Game Engine Plugin for Securing Components across systems

Building game components in Unreal Engine using Flux and Python scripts can be a complex task, but Unreal Engine provides support for Python scripting, which can be used to automate repetitive tasks in the editor or to interact with the engine in general.

However, it’s important to note that as of my knowledge cutoff in September 2021, Unreal Engine’s Python support is primarily intended for use in automating the editor and engine workflows. While you can use Python scripts to create and manipulate Unreal Engine objects, you can’t use Python as a scripting language for game logic in the same way you might use Unreal’s Blueprint system or C++.

Here is a general outline of how you might approach this:

Enable Python support: To use Python in Unreal Engine, you first need to enable the Python Editor Script Plugin. You can do this from the Plugins dialog in the Unreal Editor.

Python scripting: Once Python support is enabled, you can use Python to interact with Unreal Engine. The exact details of how to do this will depend on what you’re trying to achieve, but in general, you’ll be using Python to call functions provided by Unreal Engine’s API.

Flux integration: The integration of Flux, InfluxDB’s functional data scripting language, would be more complicated. Since there’s no direct support for Flux in Unreal Engine, you would have to create a system that communicates with an InfluxDB database, sends Flux queries, and handles the results. This could be done using HTTP requests in Python or C++, but would require a good understanding of both Unreal Engine’s scripting systems and the InfluxDB/Flux API.

Creating game components: With the data from Flux, you can create game components based on that data. This would likely involve creating Unreal Engine objects using Python or C++, and setting their properties based on the results of your Flux queries.

This approach would be highly experimental and involve a significant amount of custom programming. It’s also worth noting that any system that interacts with an external database could potentially expose your game to security risks, so you should take care to secure any communication between your game and your InfluxDB database.

Always remember that using Python or other scripting languages for game logic in Unreal can be slower than using C++ or Blueprints, so it should be used judiciously and tested thoroughly to ensure it doesn’t negatively impact your game’s performance.

I asked in a June 20 stream if this was done I’m working on it.
As I was in route to a event from Amazon about open source security.
I didn’t really know why I was doing there when I got there.
And after 5 seconds of listening to security I realized I did know.
I was in security steps for building a web application or some multi layer scheme for API manager or on top of a single API would be 3 or 5 or a assignment of algorithms for any layer of depth because when I seen how vulnerable my bank account transactions from listening to or well reading through crypto APIs that should not even be on any scheme or particular distance of scales.
Well I may of not said all that .but the host asked me what I actually done with my api security and I guess I could only see the fact that influx had gave me a brighter perspective on a area of security over a known existing issue and area im currently investing large learning agents as machine learning is my next task.

Yet mostly not the only reason I’m in audio, or games, yet more of scientific solutions by phenomenal simulations of audio assistance NLP and image recognition of video to give vocal assistance to a blind friend, yet want to help all blind people who would like a speech recognition and audible companion as a guide dog. Yet my friend told me he couldn’t get to the lake to fish, ok he’s blind, but the lake is across the street. And he said someone was hollering at him being in there yard he said he had his fishing pole in hand in someone else’s yard. So I thought I could make a simple location detection module for offline assistance of cameras visual recognition for consolation and correspondence.

And well before chatGPT I had drawn a
prime number Factorization system and now have seemed to help solve the Reimann Hypothesis by percentage perceptions. And the moderators at Reddit just deleted my thread my comments and said I was removed for non human responces. Yet I’m only trying to help the science community development for knowledge. My page has a 100+ digit non-prime factorization scheme for turning random keys from non single digit primes of the factorization keys.

So here’s a start of a request that could lead to multiple more threads as I’m here to help grow and learn, well also give someone something very humorous to enjoy laughing at because it’s all truth and history…

As I have a list of web pages

Creating a third-party plugin for Unreal Engine involves creating both C++ and UnrealScript files to define your plugin’s functionality and user interface. The exact files and scripts you will need depend on what your plugin is supposed to do, but here is a high-level overview of the process:

Plugin Descriptor File (YourPlugin.uplugin): This JSON file defines the basic information about your plugin, such as its name, version, and the modules it includes. The file should be located in the root of your plugin’s directory.

Sample YourPlugin.uplugin:

Copy code
“FileVersion”: 3,
“Version”: 1,
“VersionName”: “1.0”,
“FriendlyName”: “Your Plugin”,
“Description”: “Description of your plugin”,
“Category”: “Your Category”,
“CreatedBy”: “Your Name”,
“CreatedByURL”: “”,
“DocsURL”: “”,
“MarketplaceURL”: “”,
“SupportURL”: “”,
“CanContainContent”: true,
“IsBetaVersion”: false,
“Installed”: false,
“Modules”: [
“Name”: “YourModule”,
“Type”: “Runtime”,
“LoadingPhase”: “Default”
C++ Source Files (YourModule.cpp, YourModule.h): These files define the functionality of your plugin. They should be located in the Source/YourModule directory within your plugin’s directory. The .cpp file defines the functions your plugin provides, while the .h file declares these functions and any classes they use.

UnrealScript Files: If you’re planning to expose your plugin’s functionality to Blueprint or the Unreal Editor, you’ll also need to create UnrealScript files. These files define Blueprint nodes, editor windows, and other user-facing features of your plugin.

Build Scripts (YourModule.Build.cs): These scripts control how your plugin is built by Unreal’s build system. They should be located in the Source/YourModule directory. Build scripts specify which Unreal Engine modules your plugin depends on, among other things.

Content Files: If your plugin includes assets like textures, models, sounds, or Blueprints, you’ll need to include these in the Content directory of your plugin.

Once you’ve created these files, you can build your plugin by right-clicking on your .uproject file in the Windows explorer and selecting “Generate Visual Studio project files”, then building your project from Visual Studio.

For loading and synchronizing third-party scripts, you might need to create additional C++ and/or UnrealScript files that handle these tasks. The implementation will depend on the specifics of the scripts you’re trying to load and synchronize.

Remember to always follow best practices for security and performance when developing your plugin, especially if you’re dealing with user-provided scripts or data.

Please note that this is a simplified description and creating a functional Unreal Engine plugin requires a deep understanding of both C++ and Unreal Engine’s architecture and scripting systems. You should refer to the official Unreal Engine documentation and the Unreal Engine source code (available on GitHub to Epic Games members) for detailed information and examples.

Designing an authentication system using prime factorization is an interesting concept, and using such large non-prime numbers could potentially add a layer of security due to the computational difficulty of factorizing large numbers. However, keep in mind that prime factorization is not typically used in standard authentication protocols, and such a system could be vulnerable to various attacks, such as man-in-the-middle attacks, and might also be less efficient than more traditional methods.

Here’s a basic idea of how you could implement a system like this in Flux and Unreal Engine:

User Registration: You would first need to create a Flux script that accepts a username and a 100+ digit non-prime number. This script would store the username and the number in the InfluxDB database.
Copy code
// pseudocode
username = “user_input”
nonPrime = “user_input”

// store the username and non-prime number in the database “myBucket”, org: “myOrg”, record: { _time: now(), _measurement: “auth”, _field: “nonPrime”, _value: nonPrime, username: username })
User Authentication: Another Flux script would handle user authentication. This script would accept a username and one or more prime factors. It would retrieve the non-prime number associated with the username from the database and check if the provided factors correctly factorize the number.
Copy code
// pseudocode
username = “user_input”
factor = “user_input”

// fetch the non-prime number from the database
nonPrime = from(bucket: “myBucket”)
|> range(start: -1y)
|> filter(fn: (r) => r._measurement == “auth” and r.username == username)
|> findColumn(fn: (key) => key._field == “nonPrime”, column: “_value”)

// verify if the factor correctly factorizes the non-prime number
if nonPrime % factor == 0 {
// the factor is correct, authenticate the user
} else {
// the factor is incorrect, deny authentication
Please note that these scripts are pseudocode and do not represent actual Flux code. They’re intended to provide a general idea of how you could implement this system. You’ll need to adapt them to your specific needs and ensure they’re secure and efficient.

For the Unreal Engine plugin, you would need to handle the user interaction, input collection, and communication with the InfluxDB API. The plugin would need to send HTTP requests to the InfluxDB API to execute the Flux scripts and handle the responses.

Building such a plugin would involve using Unreal Engine’s networking and UI capabilities. Unreal Engine has a robust HTTP and networking module, and various options for building user interfaces, such as UMG (Unreal Motion Graphics UI Designer). You would need to leverage these tools to build the plugin.

This is a complex task that requires a good understanding of networking, cybersecurity, and both Flux and Unreal Engine. As such, you may want to consider consulting with a professional or a security expert to ensure your system is secure and efficient.

Building a security system with the factors of a 100+ digit non-prime number as keys is an interesting idea. The computational difficulty of factorizing large numbers could indeed add an extra layer of security to your system.

However, there are a few considerations:

Performance: Factorizing large numbers is computationally intensive. If you’re doing it frequently or in real-time, this could impact performance. Depending on the implementation, this could be a client-side or server-side concern.

Security: While factorizing large numbers is difficult, it’s not impossible. As technology advances, so does our ability to solve complex problems. What is secure today may not be secure tomorrow.

Implementation: You’ll need a way to use these factors as keys. This could involve converting them to a format that’s compatible with your system, storing them securely, and implementing a method to check them when needed.

Usability: The complexity of this system could impact usability. It’s important to consider the user experience when designing a security system.

As for creating an API in Python that uses InfluxDB or Flux, you would need to install the respective client libraries. For InfluxDB, you can use the InfluxDB-Python client library. For Flux, there isn’t a specific Python client, but you can use the InfluxDB 2.0 client, which includes support for Flux.

Here’s a general idea of how you might structure the code for your API:

Copy code
from influxdb import InfluxDBClient

def create_db_client(host, port, username, password, dbname):
client = InfluxDBClient(host=host, port=port, username=username, password=password, database=dbname)
return client

def write_data(client, json_body):

def query_data(client, query):
return client.query(query)

You would then use these functions in your application, like so:

client = create_db_client(‘localhost’, 8086, ‘root’, ‘root’, ‘mydb’)
json_body = […] # Data to write
write_data(client, json_body)
results = query_data(client, ‘SELECT * FROM “mydb”.“autogen”.“mymeasurement”’)

results now contains the query results

This is just a basic example. The actual code will depend on your specific requirements. You’ll also need to handle errors and edge cases.

Regarding the Unreal Engine, there isn’t a native way to use Python scripts or InfluxDB. However, you could create a system where your Unreal application communicates with a separate application that handles the database operations. This would require networking and data serialization/deserialization.

Remember, security is a complex field, and it’s always a good idea to have a security expert review your designs and implementations to ensure they are safe.

Hello @Eric_Chastain,
Thank you for including all of this information and sharing your strategy :slight_smile:

1 Like

Fetch data from InfluxDB: You could use the InfluxDB-Python client library to connect to an InfluxDB instance, fetch data, and perform operations on it. This library supports both InfluxDB 1.x and 2.x versions.

Perform operations on the data: Depending on the complexity of the operations you want to perform, you might use Flux (InfluxDB’s functional data scripting language), or Python’s NumPy library for numerical computations.

Integrate with Unreal Engine: To integrate these operations into Unreal Engine, you would likely need to create a Python plugin for Unreal. Unreal Engine has built-in support for Python, and you can use it to automate tasks within the engine, or to build game behavior. You’d write scripts that call your InfluxDB data fetching and manipulation functions, and then use those scripts in your Unreal Engine game.

It’s important to note that performing data operations in a game engine in real-time could be computationally intensive and could impact the performance of your game. You’ll want to make sure that any data operations you’re performing are optimized for performance and are not blocking the main game thread.

Here is a very high-level outline of what the structure might look like in Python:

Copy code
import influxdb_client
import numpy as np
from unreal import Engine

Connect to InfluxDB

client = influxdb_client.InfluxDBClient(url=“http://localhost:8086”, token=“my-token”, org=“my-org”)

Fetch data from InfluxDB

query = ‘from(bucket: “my-bucket”) |> range(start: -1h)’
tables = client.query_api().query(query)

Perform data operations

This will depend on what exactly you want to do with the data

For example, here we just convert the data to a NumPy array

data = np.array([table.records for table in tables])

Now, in your Unreal Engine Python script, you could use this data

Again, this will depend on what you want to do in the game

Here’s just a very simple example

engine = Engine.get()
This is just a very rough sketch and the exact details would depend on your specific use case and requirements. Writing such a script would require a good understanding of Python, Flux (if you’re using it), and the Unreal Engine Python API.

Thanks for comment.
Only outlining my task at the current position.