Snippets
This section includes three useful code snippets for your LightScripts: meters, state handlers, and effects handlers.
The Meter
As a continuation from the previous section, the Meter class is designed to help track meaningful changes in unstable metered data. Think of it as a brake pedal for your code - providing stability even in complex zones. Each meter holds a customizable array of values collected during each run of your update function. When all values in that array are the same (i.e., the data is "stable"), the meter updates its value and triggers a linked callback function to activate an effect.
| Method | Description |
|---|---|
| Meter(size, callback) | The constructor accepts both a size and a callback. size - the number of times an identical value should be present in order for the meter value to be considered 'stable' enough to be processed. Higher values result in more accuracy, lower values result in less latency. callback - a function to be called when the meter value is stable and has changed. |
| Meter.setValue(value) | You should call setValue(value) every frame, or any time new raw data for this meter is available. |
The process of collecting screen data should generally follow this structure:
- The engine.vision.meter value updates based on new data from the screen.
- Inside the update function, Meter.setValue(engine.vision.meter) is called to record the new value.
- The Meter checks its internal array to see if all values are identical. If so, it updates its own state and runs its assigned callback function.
- The callback function then evaluates specific conditions using the Meter's variables and executes its code if those conditions are met.
IMPORTANT NOTE:
Do not skip using callbacks. Since the update function runs continuously, it must remain as efficient as possible. Its primary role should be to update Meter values. Avoid chaining conditionals within update to check meters and trigger effects, as this leads to unnecessary checks on every cycle. Instead, define your effects in separate functions and pass them into your Meter as callbacks.
Meter Variables
When stable, the Meter will provide a few values to its callback function:
| Variables | Description |
|---|---|
| Meter.value | The current value of the meter. |
| Meter.increased | A boolean that indicates whether or not our value has increased this update |
| Meter.decreased | A boolean that indicates whether or not our value has decreased this update |
| Meter.diff | The absolute value of the change the meter has experienced this update. |
Meter Example
Here is a basic single-meter setup, including the Meter class code:
<head> <title>Meter Example</title> <meta description="Step-by-step metering" /> <meta meter="health" tags="vlc,fortnite" x= ".05" y=".9" width=".189" h="70-140" s="40-100" l="40-100" type="linear" /></head> <body style="margin: 0; padding: 0; background: #000;"> <canvas id="exCanvas" width="320" height="200"></canvas></body><script> var c = document.getElementById("exCanvas"); var ctx = c.getContext("2d"); // Initialize meter var healthMeter = new Meter(5, healthEffect); function update(){ // Update Meter values healthMeter.setValue(engine.vision.health); window.requestAnimationFrame(update); } function healthEffect(){ if(healthMeter.increased){ // Trigger effect } else if (healthMeter.value == 0){ // Trigger effect } else if (healthMeter.diff > .3){ // Trigger effect } } function Meter(size, callback) { this.size = size; this.value = 0; this.diff = 0; this.increased = false; this.decreased = false; var values = []; this.setValue = function (updatedValue) { // Add and shift. values.push(updatedValue); if (values.length > this.size) { values.shift(); } // Exit early if we don't have a long-term match. for (var i = 0; i < values.length - 1; i++) { if (values[i] !== values[i + 1]) return; } // We got here, so we've got a matching value collection. Set variables and execute callback. if (this.value !== values[0]) { this.diff = Math.abs(this.value - values[0]); this.increased = this.value < values[0]; this.decreased = this.value > values[0]; this.value = values[0]; callback(); } }; } window.requestAnimationFrame(update); </script>The State Handler
The state handler is an effect stack that specifically handles effects that have precedence over all others. If you want one big dominant animation to run until it is done with no interruption, insert it into the state handler.
| Method | Description |
|---|---|
| StateHandler() | The constructor requires no arguments. |
| StateHandler.push(new State()) | You can push a new state onto the state stack using push, and processing will begin immediately. |
| StateHandler.pop() | Pops the current state off the state stack, and begins processing the previous state on the state stack. |
Any object pushed into the state handler must implement Process(). The Process function determines the lifespan of an effect in the handler.
State Handler Example
The following shows a basic state handler, plus the Process function that should run inside your effect functions:
var stateHdlr = new StateHandler();function StateHandler() { var stack = []; var state = null; // Set current state to the top item in the stack var updateState = function () { if (stack.length > 0) { state = stack[stack.length - 1]; } else { state = null; } }; // Allows dev to add effect to state handler this.Push = function (newState) { stack.push(newState); updateState(); }; // Allows dev to remove effect from handler this.Pop = function () { stack.pop(); updateState(); }; // Call the Process function of the current state (effect) this.Process = function () { if (state != null) { state.Process(); } }; }function update(){ stateHdlr.Process();}The Effect Handler
Effect handlers are excellent for storing and rendering smaller, lighter effects all together. Each effect in the handler will be evaluated on each update call, and they are removed when they reach the end of their lifespan.
The effects handler is just an array to store effects. That is all.
// Declare effects arraylet effects = [];// (Not shown) Evaluate Meter, callback function pushes effect into effects arrayeffects.push(new SpecialEffect());// Iterate through the array, animating a frame for each effect for (let i = 0; i < effects.length; i++) { effects[i].draw(); // Remove effect if the lifetime has ended if (effects[i].lifetime <= 0) { effects.splice(i, 1); }}EFFECT VS. STATE WARNING
The state manager is specifically for priority effects, which means we have to give it priority during execution. In your update function, process the effect handler THEN the state handler. This will draw the state effect on top of the effect handler's items.
Like this:
function update(){ // Evaluate effects handler for (let i = 0; i < effects.length; i++) { effects[i].draw(); if (effects[i].lifetime <= 0) { effects.splice(i, 1); } } // THEN evaluate state handler stateMgr.Process();}USB Data Capture Guide
Saving USB data is a straightforward process, but the drivers used by these programs are known to conflict with certain systems, sometimes disabling USB ports until the software is removed. The common fix is to disable 'Secure Boot' in your BIOS/UEFI settings. Before proceeding, it's strongly recommended to have a system restore available on a flash drive or a way to remotely access your computer that doesn’t rely on user input at boot time. This is important in case disabling Secure Boot doesn’t resolve the issue and you’re unable to access the system to uninstall the program. In such cases, a Windows refresh may be necessary to remove all installed programs while keeping your personal files. You are doing this at your own risk. If you don’t feel comfortable trying, request your device here. Do not use a laptop system for this process.
Once installed, the process is simple and will capture all data passing through your USB devices. Do not type any sensitive information while capturing if you plan to share the data, as keystrokes are included in the recording. Two third-party programs that can be used are Usblyzer(free trial) and Wireshark (free). Both work, but if you choose Wireshark, make sure USBPcap is selected.
Check out our next page, Callbacks, for more detail on constructing meter callbacks and effect functions.