
# Tutorials & Guides

Step-by-step guides to help you master game development, streaming, and creative technology.

## What You'll Learn

- UEFN & Verse Development
- Game Design Fundamentals
- Streaming & Content Creation
- Creative Tools & Workflows
- Debugging & Problem Solving

Whether you're just starting out or looking to level up, our tutorials have you covered.


Learn game development, streaming, and creative tools with in-depth tutorials

Tutorials & Guides

## Introduction
In this tutorial, we will explore how to create interactive UI widgets that can trigger events in Verse using the Verse fields event type in Unreal Motion Graphics (UMG).

## Getting Started
To begin, open the Variables window in the UMG Designer.

## Adding Verse Fields Events
1. Add fields of the new event type to a User Widget in the UMG Designer.
2. Bind these fields to widget events using View Bindings.

## Reacting to Events in Verse
Events added to the User Widget are reflected in the Verse asset digest, allowing you to wait for an event from Verse code to react accordingly.

## Additional Resources
For more detailed information and examples, refer to the [Using Verse fields event type in a UMG User Widget tutorial](https://dev.epicgames.com/community/learning/tutorials/woOK/fortnite-using-verse-fields-event-type-in-a-umg-user-widget).




Create Interactive UI: Verse Fields Events Now Available in UMG

# Say "No More" to OBS's Party-Pooper Pop-Up 🚫🎉

Alright, fellow brain-munchers and keyboard warriors, let's talk about that triple-headed Hydra gaming rig we've all drooled over! 🐉💻 Imagine hooking up all three HDMI inputs plus a cheeky fourth for that all-seeing eye (aka your camera). You're all set for co-op gaming glory, reviews, and those laugh-until-you-cry moments. But then, just like a zombie at a carnival, OBS decides to crash the party with its annoying "unclean shutdown" nag every time you reboot. Like, hello? Who invited you, Mr. Buzzkill?

Since OBS update XX.X (yeah, they're updating faster than you can say "revive me!"), every reboot greets you with that clingy pop-up asking, "Did you forget about me? Want to run in safe mode or normal?" It's like that one friend who can't take a hint when the party's over. 🙄 And there you are, trudging over to manually click "OK" before the real fun can start. Talk about a mood killer.

But fear not, my fellow survivors of the digital apocalypse! A simple command line charm is all it takes to exorcise this ghost. Who's got time to summon the command prompt and chant `obs64.exe --disable-shutdown-check` every time? Not us! We've got zombies to slay and victories to royale. So, let's conjure up a shortcut instead!

## Crafting the Magic Shortcut 🧙‍♂️✨

1. First, embark on a quest to the mystical land where OBS resides (aka navigate to where you installed or extracted OBS). If you're a nomad like me and run it in portable mode, I salute you.

   ![Summoning the Shortcut](obs-shortcut-guide-1.png)

   Find the sacred obs64.exe, right-click, and drag it into the realm of "Create shortcuts here." Like finding an epic loot drop in the middle of a heated Fortnite match.
2. Behold, you've spawned an entity known as "obs64 - shortcut." Right-click this mystical being and select "properties."

   ![Accessing the Arcane Properties](shortcut-properties-tabs-1.png)
3. Click the "Shortcut" tab and with the precision of a sniper, paste the following incantation:

   ```plaintext
   C:\OBS\bizanator\OBSStudio\bin\64bit\obs64.exe --disable-shutdown-check
   ```

   ![Casting the Spell](shortcut-command-field-1.png)

   Remember, fellow spellcasters, no quotation marks "" , no `` – just the spell as it is. Otherwise, you'll summon...

   ![A Wild Error Appears!](windows-advanced-properties-obs-launch-1.png)
4. With the grace of a default dance, click "OK." Congrats! You've now got a magic portal that launches OBS without the nagging spirit of shutdown checks. Pin it to your start menu, clone it to your desktop, tattoo it on your arm – whatever floats your boat.

And there you have it, my gaming ghouls and tech witches! Happy streaming and may your frames be high and your latency low. Welcome to a world where OBS behaves more like a trusty sidekick and less like an unwanted party crasher. 🎮👻


BizaNator

Obs did not shutdown properly?!


# Verse Function Renaming: The Art of Clean Code Through Smart Aliases

*Ever felt like your function names are longer than a loading screen tooltip?*

When developing games, we often start with descriptive but verbose function names that make perfect sense... until we have to type them for the hundredth time. Today, we'll explore a real-world example of simplifying function names while maintaining backward compatibility, using a technique that's smoother than a perfectly timed emote.

## What is Function Renaming? (For Those Who Type GetPlayerDataForPlayerForPlayerSession)

Function renaming is like giving your character a nickname – it's shorter, easier to remember, but still refers to the same entity. In our case, we're looking at transforming `GetPlayerDataForPlayer` into the more concise `GetPlayerData`. Think of it as upgrading from a lengthy gamertag to something you can actually type without getting thumb cramps.

## The Problem (Or: "Why Are We Still Typing ForPlayer When We Know It's For a Player?")

Here's what we're dealing with:

```verse
# Original verbose function
GetPlayerDataForPlayer<public>(Agent:agent)<transacts><decides>:player_data =
    GameSessionData := GetOrCreateSessionData(GetSession())
    Player := CheckPlayerDataForPlayer[Agent]
    PlayerData := GameSessionData.PlayerData[Player]
    return PlayerData
```

If you're experiencing any of these symptoms:
- Your function names are longer than your actual implementation
- You keep misspelling "ForPlayer" as "ForPLayer" at 2 AM
- Your autocomplete is getting RSI from suggesting the full name
- Your code reviews include more horizontal scrolling than a side-scroller game

## The Solution (In Order of "Why Didn't We Do This Sooner?")

### 1. The Clean Rename (Operation: Shorter Name, Same Game)

First, let's create our new, streamlined function:

```verse
# Get the player's data with a cleaner name
GetPlayerData<public>(Agent:agent)<transacts><decides>:player_data =
    # Get the session data
    GameSessionData := GetOrCreateSessionData(GetSession())
    # Check if the player has data, if not, create one
    Player := CheckPlayerDataForPlayer[Agent]
    # Get the player session data
    PlayerData := GameSessionData.PlayerData[Player]
    return PlayerData
```

### 2. The Backward Compatibility Trick (Or: How to Not Break Everything)

Here's where we pull out our secret weapon – the alias:

```verse
# Alias for backward compatibility
GetPlayerDataForPlayer<public>(Agent:agent)<transacts><decides>:player_data = GetPlayerData[Agent]
```

This is like setting up a redirect from your old gamertag to your new one – all the old references still work, but new code can use the shorter name.

## Understanding the Approach (Or: "Why This Won't Break Your Build")

Let's break down why this solution works perfectly:

1. **Clear Context**: The function is already in a player-focused context, so "ForPlayer" is as redundant as a double shield potion at full shields.

2. **Type Safety**: The `Agent` parameter type makes it crystal clear what we're dealing with – like having a clearly marked pickup in game.

3. **Return Clarity**: The `player_data` return type tells us exactly what we're getting back – no mystery loot boxes here.

4. **Verse Style**: Verse favors concise but clear names, like a well-designed UI that shows exactly what you need.

## Why This Works (The Technical Deep Dive)

Let's visualize the relationship between our old and new functions:

```mermaid
graph TD
    A[Client Code] --> B{GetPlayerDataForPlayer}
    B -->|Alias| C[GetPlayerData]
    C --> D[Session Data]
    D --> E[Player Data]
    style B fill:#ff2a6d,stroke:#fff,stroke-width:2px
    style C fill:#05d9e8,stroke:#fff,stroke-width:2px
```

The alias acts as a bridge, ensuring that:
- Old code continues to work flawlessly
- New code can use the cleaner name
- No functionality is changed
- We can gradually update references

## Conclusion

Renaming `GetPlayerDataForPlayer` to `GetPlayerData` is like upgrading your loadout – it's more efficient, cleaner, and just feels right. With our backward compatibility alias in place, we've achieved the perfect balance between improving our codebase and maintaining stability.

Remember: Good function names are like good emotes – short, memorable, and they get the job done with style.

---
*Note: No functions were harmed in the making of this article. The original function name is now living happily in retirement as an alias.*


Verse Function Renaming: The Art of Clean Code Through Smart Aliases


# So Your Fancy 10GbE Network Adapter Keeps Ghosting You: A Survival Guide

*Because getting disconnected in Fortnite is scarier than facing a horde of carnival zombies with nothing but a common pistol and a dream*

Listen, we get it. You spent good money on that shiny new motherboard with its promised blazing-fast 10GbE networking, only to find yourself in an on-again-off-again relationship with your internet connection. Like a Fortnite player who just lost their legendary loot to a disconnect, you're probably feeling pretty salty right now. Don't worry – you're not alone in this digital heartbreak. Let's fix that temperamental Marvell AQtion adapter faster than a Zero Build sweat can crank 90s.

## What Even Is 10GbE? (For Those Who Just Bought What Looked Expensive)
Think of 10GbE like finding a Supply Llama filled with networking speed. It's theoretically capable of transferring data at up to 10 gigabits per second – that's fast enough to move your entire Fortnite installation folder in the time it takes to drink a mini shield potion. When it works, it's amazing. When it doesn't... well, that's why you're here.

## The Symptoms (Or: "It's Not You, It's Your Network Adapter")

If you're experiencing any of these signs of network adapter rebellion:
- Random disconnections that make you question your life choices (and cost you Victory Royales)
- Connection drops during large Steam downloads (because obviously it would happen right as you're downloading the latest Unreal Engine)
- Speeds that make your old dial-up modem look ambitious
- The need to constantly perform the sacred ritual of "disable and re-enable network adapter"
- Ping spikes higher than a Fortnite rocket ride
- Your network adapter disappearing more often than a bush camper

## The Solutions (In Order of "Yeah, This Might Actually Work")

### 1. The Power Management Powerplay
First, let's tell Windows to stop trying to save power like it's hoarding shield potions:

1. Open Device Manager (like opening your inventory, but for your PC)
2. Find your Marvell AQtion adapter
3. Right-click → Properties
4. Go to the "Power Management" tab
5. \*\*Uncheck\*\* "Allow the computer to turn off this device to save power"
   (Because who thought putting your network card to sleep was a good idea anyway?)
6. Click Apply

### 2. The Advanced Tab Adventure
Time to dive into the advanced settings like you're dropping into Tilted Towers. Here's what each setting actually does (we know you're curious):

```
Energy-Efficient Ethernet: Disabled
(Because saving the planet is important, but not as important as your K/D ratio)
- This feature tries to save power during low network activity, but ends up causing more crashes than a bot's first build battle

Interrupt Moderation & Rate: Disabled
(Like turning off input lag for your network card)
- These settings control how often your network card interrupts your CPU
- Disabling them makes your connection more responsive than a pro player's edit speed

Speed & Duplex: 10 Gbps Full Duplex
(Manual > Auto, like choosing your landing spot instead of using auto-drop)
- Forces your connection to run at full speed instead of letting it get lazy
- Full duplex means data flows both ways simultaneously, like building and shooting at the same time

NDIS QoS: Enabled
(Quality of Service - like SBMM but for your network packets)
- Helps prioritize important network traffic
- Makes sure your gaming packets don't get stuck behind someone's Netflix stream
```

### 3. Optional Performance Tweaks (For the Sweats)
For when you want your network to perform like it's in the FNCS finals:

```
Jumbo Packets: 9014 bytes
(Like carrying more mats in one slot)
- Allows larger data packets to be transferred at once
- Only enable if your entire network supports it, or you'll create more problems than a prankster with a boom box

Flow Control: Disabled
(The networking equivalent of "just build, lol")
- Controls the "speed limit" of data transfer
- Some cards perform better with traffic jams than with police
```

### 4. Static IP Setup (Because Sometimes You Need a Home Base)
Why set a static IP? Here's the deal:

- It's like marking your favorite landing spot on the map – your PC will always know where to find its network location
- Perfect for:
  * Running a home media server (for watching those Victory Royale replays)
  * Port forwarding (for hosting creative maps)
  * Network attached storage (for saving all your clutch clips)
  * Making sure your PC doesn't get assigned a new IP address more often than meta changes

Here's how to set it up in Windows 11 (easier than finding a common chest):

1. Settings → Network & Internet → Ethernet
2. Click on your network adapter
3. Click "Edit" under IP assignment
4. Change from DHCP to Manual
5. Toggle on IPv4
6. Enter your desired settings:
   - IP address (like 192.168.1.100) - Your PC's permanent address in the network lobby
   - Subnet mask (typically 255.255.255.0) - Defines your local network's size
   - Gateway (your router's IP, usually 192.168.1.1) - Your connection to the outside world
   - Preferred DNS (8.8.4.4 for Google) - The phonebook that converts website names to IP addresses
   - Alternate DNS (8.8.8.8 for backup) - Backup phonebook when the first one is taking a chug jug

### Understanding Network Settings (Or: "What Are All These Numbers?")
Think of your network settings like your Fortnite loadout:

- \*\*IP Address\*\*: Your locker number in the giant internet gym
- \*\*Subnet Mask\*\*: The zone that defines where your teammates can find you
- \*\*Gateway\*\*: The battle bus that takes your data to the internet
- \*\*DNS\*\*: The map that shows where all the good websites are hiding
- \*\*Jumbo Packets\*\*: Like carrying a whole inventory of items in one slot
- \*\*Flow Control\*\*: Traffic lights for your data (that nobody wants to stop at)

## Conclusion

Remember, you're not alone in this struggle. Thousands of other users are out there, cursing at their network adapters just like you curse at third-party interventions. Until Marvell releases that mythical firmware update we've all been dreaming about (about as likely as Epic removing building), these workarounds are your best bet for maintaining your sanity.

And hey, if all else fails, there's always carrier pigeons. They might be slower than a default skin with a grey pistol, but at least they don't need driver updates. Plus, they're probably more reliable than the Marvell AQtion on a bad day.

---
*Note: This guide was written by sleep-deprived network administrators who have spent way too many hours staring at Device Manager while getting eliminated in Fortnite. No network adapters were harmed in the making of this guide (though we really wanted to yeet them into the storm). If you see us in-game, please don't eliminate us – we're probably troubleshooting our network connection anyway.*


Network Adapter Survival Guide: Taming the Rebellious Marvell AQtion

# Github Copilot Enterprise Setup

Fianlly got access to github copilot enterprise so going through getting it setup and configured.



If you don't already have Github Copilot installed you'll want to add the extensions:

Name: GitHub Copilot Chat
Id: GitHub.copilot-chat
Description: AI chat features powered by Copilot
Version: 0.22.4
Publisher: GitHub
VS Marketplace Link: https://marketplace.visualstudio.com/items?itemName=GitHub.copilot-chat



Name: GitHub Copilot
Id: GitHub.copilot
Description: Your AI pair programmer
Version: 1.249.0
Publisher: GitHub
VS Marketplace Link: https://marketplace.visualstudio.com/items?itemName=GitHub.copilot



![image-20241210173205870](github-copilot-outputwindow.png)

### Code completions

GitHub Copilot provides autocomplete-style suggestions from an AI pair programmer as you code. Just start writing your code in the editor and Copilot provides you with relevant suggestions. Need something specific? Add a natural language code comment to give directions to Copilot about what you want.

![Example of Copilot code completions in test.js](js-suggest.png)

### Chat

Sometimes you just want to ask a question. Whether you're troubleshooting a bug or crafting a new feature, GitHub Copilot is here to assist when you encounter challenges – simply ask for guidance via chat.

**[Chat view](https://code.visualstudio.com/docs/editor/github-copilot#_chat-view)**:

Ask Copilot for help with any task or question in the Chat view, bringing in code from your current files. Copilot is not just a search engine. Rather than giving you a generic answer, it can give answers that are relevant for your codebase.

![Chat view in VS Code](copilot-view.png)

**[Inline Chat](https://code.visualstudio.com/docs/editor/github-copilot#_inline-chat)**:

Apply Copilot's AI suggestions directly to your code, staying in the flow. Need help with refactoring a method, adding error handling, or explaining a complex algorithm? Just launch Copilot in the editor!

![Inline chat in VS Code](inline-chat-question-example.png)

**[Quick Chat](https://code.visualstudio.com/docs/editor/github-copilot#_quick-chat)**:

Do you just want to ask a quick question and immediately get back in the action? Open Quick Chat with the **Chat: Open Quick Chat** command , or use the `Ctrl+Shift+I` or `Cmd+Shift+I` keyboard shortcut.

![Quick Chat in VS Code](quick-chat-dropdown.png)

### Participants

Participants are experts in a particular domain, such as coding, the editor, or many other areas. You can tag them in any chat to scope your questions and get better answers.

Below are examples of using participants built into VS Code.

**@workspace** ![Using the workspace chat participant](participants-workspace.gif)

**@terminal** ![Using the terminal chat participant](participants-vscode.gif)

**@vscode** ![Using the VS Code chat participant](participants-terminal.gif)

### Slash commands

Chat participants can also contribute what we call slash commands, which are shortcuts to specific functionality. Slash commands give you access to meticulously crafted prompts for common coding workflows, no prompt engineering required.

Below are examples of using several slash commands.

**/fix** ![Using /fix in VS Code](slash-fix.gif)

**/doc** ![Using /doc in VS Code](slash-doc.png)

**/tests** ![Using /tests in VS Code](slash-tests.gif)

### Variables

Variables enable you to reference specific information in your code, the editor, or information from other extensions. Combine these with participants to easily pass all the necessary context to Copilot.

**#file** ![Using the file variable in VS Code](variables-file.gif)

**#terminalLastCommand** ![Using the terminal last command variable in VS Code](variables-terminalLastCommand.gif)

### Supported languages and frameworks

GitHub Copilot works on any language, including Java, PHP, Python, JavaScript, Ruby, Go, C#, or C++. Because it��s been trained on languages in public repositories, it works for most popular languages, libraries and frameworks.

### Version compatibility

As Copilot Chat releases in lockstep with VS Code due to its deep UI integration, every new version of Copilot Chat is only compatible with the latest and newest release of VS Code. This means that if you are using an older version of VS Code, you will not be able to use the latest Copilot Chat.

Only the latest Copilot Chat versions will use the latest models provided by the Copilot service, as even minor model upgrades require prompt changes and fixes in the extension. An older version of Copilot Chat will still use the latest version of Copilot completions.

## Commands for CoPilot Extension

All of these settings and Commands can be found inside the Extension Settings. 

In order to open and use these you'll need to access the VS Code Parameter menu, hold CTRL + SHIFT + P 

| ID                                         | Title                                     | Keyboard Shortcuts | Menu Contexts                                       |
| :----------------------------------------- | :---------------------------------------- | :----------------- | :-------------------------------------------------- |
| `editor.action.inlineSuggest.trigger`      |                                           | Alt+\              |                                                     |
| `github.copilot.acceptCursorPanelSolution` | Accept panel suggestion at the cursor     | Ctrl+/             | `commandPalette`                                    |
| `github.copilot.collectDiagnostics`        | Collect Diagnostics                       |                    | `commandPalette`                                    |
| `github.copilot.generate`                  | Open Completions Panel                    | Ctrl+Enter         | `commandPalette` `editor/inlineCompletions/actions` |
| `github.copilot.nextPanelSolution`         | Navigate to the next panel suggestion     | Alt+]              | `commandPalette`                                    |
| `github.copilot.openLogs`                  | Open Logs                                 |                    | `commandPalette`                                    |
| `github.copilot.previousPanelSolution`     | Navigate to the previous panel suggestion | Alt+[              | `commandPalette`                                    |
| `github.copilot.sendFeedback`              | Send Feedback                             |                    | `commandPalette`                                    |
| `github.copilot.signIn`                    | Sign In                                   |                    | `commandPalette`                                    |
| `github.copilot.toggleCopilot`             | Enable/Disable Copilot completions        |                    |                                                     |

### Settings

These enable some extra features	

| ID                                            | Description                                                  | Default                                                      |
| :-------------------------------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
| `github.copilot.advanced`                     |                                                              | `{} `                                                        |
| `github.copilot.editor.enableAutoCompletions` | Automatically show inline completions                        | `true `                                                      |
| `github.copilot.enable`                       | Enable or disable Copilot completions for specified [languages](vscode-file://vscode-app/c:/Users/Biza/AppData/Local/Programs/Microsoft VS Code/resources/app/out/vs/code/electron-sandbox/workbench/workbench.html) | `{  "*": true,  "plaintext": false,  "markdown": false,  "scminput": false } ` |
| `github.copilot.inlineSuggest.enable`         | Show inline suggestions                                      |                                                              |



## Commands for CoPilot Chat

In order to open and use these you'll need to access the VS Code Parameter menu, hold CTRL + SHIFT + P 

Commands

| ID                                                           | Title                                                       | Keyboard Shortcuts | Menu Contexts                                                |
| :----------------------------------------------------------- | :---------------------------------------------------------- | :----------------- | :----------------------------------------------------------- |
| `github.copilot.buildLocalWorkspaceIndex`                    | Build Local Workspace Index                                 |                    | `commandPalette`                                             |
| `github.copilot.chat.attachFile`                             | Add File to Chat                                            |                    | `commandPalette` `copilot`                                   |
| `github.copilot.chat.attachSelection`                        | Add Selection to Chat                                       |                    | `commandPalette` `copilot`                                   |
| `github.copilot.chat.explain`                                | Explain                                                     |                    | `copilot`                                                    |
| `github.copilot.chat.explain.palette`                        | Explain                                                     |                    | `commandPalette`                                             |
| `github.copilot.chat.fix`                                    | Fix                                                         |                    | `commandPalette` `copilot`                                   |
| `github.copilot.chat.generate`                               | Generate This                                               |                    | `commandPalette`                                             |
| `github.copilot.chat.generateDocs`                           | Generate Docs                                               |                    | `commandPalette` `copilot`                                   |
| `github.copilot.chat.generateTests`                          | Generate Tests                                              |                    | `commandPalette` `copilot`                                   |
| `github.copilot.chat.review`                                 | Review and Comment                                          |                    | `commandPalette` `copilot`                                   |
| `github.copilot.chat.review.apply`                           | Apply                                                       |                    | `commentsView/commentThread/context` `copilot/reviewComment/additionalActions/apply` |
| `github.copilot.chat.review.applyAndNext`                    | Apply and Go to Next                                        |                    | `copilot/reviewComment/additionalActions/apply`              |
| `github.copilot.chat.review.changes`                         | Copilot Code Review - Uncommitted Changes                   |                    | `scm/title`                                                  |
| `github.copilot.chat.review.continueInChat`                  | View in Chat Panel                                          |                    | `comments/commentThread/title`                               |
| `github.copilot.chat.review.continueInInlineChat`            | Discard and Copy to Inline Chat                             |                    | `copilot/reviewComment/additionalActions/discard`            |
| `github.copilot.chat.review.discard`                         | Discard                                                     |                    | `commentsView/commentThread/context` `copilot/reviewComment/additionalActions/discard` |
| `github.copilot.chat.review.discardAll`                      | Discard All                                                 |                    | `comments/commentThread/title` `commentsView/commentThread/context` |
| `github.copilot.chat.review.discardAndNext`                  | Discard and Go to Next                                      |                    | `copilot/reviewComment/additionalActions/discard`            |
| `github.copilot.chat.review.markHelpful`                     | Helpful                                                     |                    | `comments/comment/title`                                     |
| `github.copilot.chat.review.markUnhelpful`                   | Unhelpful                                                   |                    | `comments/comment/title`                                     |
| `github.copilot.chat.review.next`                            | Next Suggestion                                             |                    | `comments/commentThread/title`                               |
| `github.copilot.chat.review.previous`                        | Previous Suggestion                                         |                    | `comments/commentThread/title`                               |
| `github.copilot.chat.review.stagedChanges`                   | Copilot Code Review - Staged Changes                        |                    | `scm/resourceGroup/context`                                  |
| `github.copilot.chat.review.unstagedChanges`                 | Copilot Code Review - Unstaged Changes                      |                    | `scm/resourceGroup/context`                                  |
| `github.copilot.debug.collectDiagnostics`                    | GitHub Copilot Chat Diagnostics                             |                    | `commandPalette`                                             |
| `github.copilot.debug.generateConfiguration`                 | $(sparkle) Generate Debug Configuration with GitHub Copilot |                    | `commandPalette` `debug/createConfiguration`                 |
| `github.copilot.debug.generateInlineEditTests`               | Generate Inline Edit Tests                                  |                    | `commandPalette` `editor/title`                              |
| `github.copilot.debug.generateSTest`                         | Generate STest From Last Chat Request                       |                    | `commandPalette`                                             |
| `github.copilot.debug.workbenchState`                        | Log Workbench State                                         |                    | `commandPalette`                                             |
| `github.copilot.devcontainer.generateDevContainerConfig`     | Generate Dev Container Configuration with Copilot           |                    |                                                              |
| `github.copilot.git.generateCommitMessage`                   | Generate Commit Message with Copilot                        |                    | `scm/inputBox`                                               |
| `github.copilot.interactiveSession.feedback`                 | Send Chat Feedback                                          |                    | `commandPalette` `view/title`                                |
| `github.copilot.open.walkthrough`                            | Open Walkthrough                                            |                    | `commandPalette`                                             |
| `github.copilot.terminal.explainTerminalLastCommand`         | Explain Last Command (Terminal)                             |                    | `commandPalette`                                             |
| `github.copilot.terminal.explainTerminalSelection`           | Explain This (Terminal)                                     |                    | `commandPalette`                                             |
| `github.copilot.terminal.explainTerminalSelectionContextMenu` | Explain This                                                |                    | `terminal/copilot`                                           |
| `github.copilot.tests.fixTestFailure`                        | Fix Test Failure                                            |                    | `testing/message/context`                                    |
| `github.copilot.tests.fixTestFailure.fromInline`             | Fix Test Failure                                            |                    | `testing/item/context` `testing/item/result`                 |
| `github.copilotChat.signIn`                                  | Sign in to GitHub.com                                       |                    | `commandPalette`                                             |
| `github.copilotChat.signInChoose`                            | Sign in to...                                               |                    | `commandPalette`                                             |
| `github.copilotChat.signInGHE`                               | Sign in to GHE.com                                          |                    | `commandPalette`                                             |
| `inlineChat.start`                                           |                                                             |                    | `copilot`                                                    |
| `inlineChat.startWithCurrentLine`                            |                                                             | Windows+I          |                                                              |
| `workbench.action.terminal.chat.start`                       |                                                             |                    |                                                              |

Github Copilot Enterprise Setup


# "Help! My VSCode/Cursor Lost Its Verse-atility: A Guide to Fixing Verse Linting"

*Is your VSCode/Cursor acting like it's never heard of Verse? Are those comforting red squiggles missing in action? Let's get your development environment back to being as judgy as a Fortnite lobby.*

**![image-20241210101300673](vscode-problems-window-not-working.png)*

## The Symptoms

If you're staring at pristine, squiggle-free code that you KNOW has more issues than a default dancing Jonesy, you're probably experiencing the dreaded Verse linting outage. The key indicators are:

- Empty Problems window (as lonely as Retail Row at 3am)
- No syntax highlighting
- Code that looks perfect (we all know that's suspicious)

## The Diagnosis

The issue usually stems from our Verse Language Server Protocol (verse-lsp) taking an unexpected vacation. Here's how to investigate:

1. **Check the Output Tab** Open VSCode's Output panel (View > Output) and select "VerseExt" from the dropdown. You should see verse-lsp-latest.exe in the logs. If it's missing, it's like trying to build without materials - ain't gonna work.![image-20241210100949284](vscode-output-verseext.png)
2. **Task Manager Reconnaissance** Open Task Manager and look for verse-lsp-latest.exe. If you're using both VSCode AND Cursor (you overachiever, you), you might see multiple instances. That's normal - they're like squadmates, each doing their own thing.

![taskmgr-verse-lsp](taskmgr-verse-lsp.png)

workspace - ![image-20241210102208853](vscode-open-workspace-settings-verse.png)  

## The Cure

Time to hit this bug like a well-placed pickaxe swing. Here's your step-by-step healing potion:

1. ​	**Open Workspace Settings** Press `Ctrl+Shift+P` (or `Cmd+Shift+P` for Mac users) and type "Open Workspace Settings (JSON)". Select it faster than you'd grab a gold SCAR.

![image-20241210100813119](vscode-open-workspace-settings-verse.png)

2. ​	**Configure Your Settings** Your workspace settings should look something like this:

```json
{
  "launch": {
    "configurations": [
      {
        "name": "Verse Debug",
        "type": "verse",
        "request": "attach",
        "debugServer": 1961
      }
    ],
    "version": "0.2.0"
  }
}
```

![image-20241210101130105](vscode-verse-linting-workspace-config.png)

The `debugServer` port (1961) should match your current UEFN version. Think of it like making sure you're on the right game server - you wouldn't want to load into Save the World when you're trying to play Battle Royale!

## The Prevention

To keep your environment healthy and your code properly criticized:

1. Always open your UEFN project through the Epic Games Launcher
2. Make sure you're running the latest version of VSCode/Cursor
3. Keep your Verse extension updated
4. Don't mess with the verse-lsp process (it's more sensitive than a sweat in zero-build mode)

Now you should have proper errors in your code and under your problems Window 

![image-20241210101419870](vscode-problems-window-now-working.png)

## The Plot Thickens: Special Cases & Common Pitfalls

### The OneDrive Dilemma

*If your project folders are living in OneDrive, they're about as useful as a grey pistol in the final circle.*

Since UEFN version 31.20, there's actually a warning about this, but here's the deal: OneDrive and UEFN go together like Peely and a banana slicer. The remote storage access is about 10x slower than your local SSD, which can cause our verse-lsp to throw in the towel.

**Correct Project Paths by OS:**

- Windows 11:
  - ❌ `C:\Users\YourName\OneDrive\Documents\UnrealEngine` (Will break faster than a zero-build sweaty's building habits)
  - ✅ `C:\Users\YourName\Documents\UnrealEngine` (This is the way)
- Windows 10:
  - ✅ `C:\Users\YourName\source\repos\UnrealEngine`

### The Fresh Start Approach

Sometimes your VSCode project needs a reset like a fresh match. If you've created your .verse files outside of UEFN (you rebel, you), the verse server might be giving you the cold shoulder. Here's the proper way:

1. Launch UEFN first (yes, order matters, like landing before looting)
2. Create your new project through UEFN
3. Add your verse files through UEFN's interface
4. Use the "Verse" button in UEFN to launch VSCode

This ensures the verse server initializes properly, like making sure your drop zone has actual loot.

### The Extension Checkup

If you're still not seeing those beautiful red squiggles:

1. Check your Verse extension version (currently at `1.0.30426467` or newer)
2. Verify the extension folder exists: `%userprofile%.vscode\extensions\epicgames.verse-1.0.xxxxx`
3. If things look sus, try this nuclear option:
   - Delete the entire extension folder
   - Reinstall using the `.vsix` file
   - Restart VSCode (and maybe do a little dance)

### The Pipeline Problem

Sometimes the communication pipeline between UEFN and VSCode breaks down worse than team communication in Fill matches. If this happens:

1. Check the Output tab for "VerseExt" messages
2. Verify verse-lsp.exe is running in Task Manager
3. If either is missing, try the old reliable:
   - Close VSCode
   - Close UEFN
   - Reopen UEFN
   - Launch VSCode through UEFN's Verse button
   - Cross your fingers (optional but recommended)

Remember, just like knowing the perfect time to pop a shield, timing matters when launching these applications. UEFN first, VSCode second - this is the way.

## Still Having Issues?

If your linting is still ghosting you harder than your random duos partner:

1. Restart VSCode/Cursor
2. Check for any conflicting extensions
3. Verify your UEFN installation
4. Consider a clean reinstall (the programming equivalent of "have you tried turning it off and on again?")

Remember, a properly configured development environment is like a well-organized loadout - it makes everything easier and more effective. Now get back out there and make something amazing! Just don't forget to thank your linter for keeping your code cleaner than a Creative island on day one.

*P.S. If all else fails, you can always blame it on lag. Works every time, 60% of the time.*

VSCode lost it's Verse-atility - Fixing Verse Linting

## The Setup: What Happens in Git, Stays in Git... Or Does It?

You know that feeling when you wake up after spring break, check your phone's photo gallery, and find 1,372 nearly identical selfies from that one party? Yeah, that's basically what happened to our Git repository, except instead of embarrassing photos, we had thousands of automated commits partying in our git log like it was 1999.

Picture this: You're casually reviewing your repo one morning, coffee in hand, when suddenly you discover your automated sync script has been on a commit binge. Every single file sync created its own commit, each one shouting "Sync from Vercel: bizanator.md" like that one friend who keeps telling the same story at different volumes as the night goes on.

That's exactly what happened to us while building BrainDeadTV. Our script wasn't just doing its job - it was living its best life, creating commits like they were going out of style. It was less "continuous integration" and more "continuous intoxication" of our git history.

## The Problem: The Morning After

Our Git history went from this responsible, professional-looking log:

```
* feat: add cool new feature
* fix: resolve edge case
* feat: implement user feedback
```

To looking like a frat party guest list:

```
* Sync from Vercel: bizanator.md
* Sync from Vercel: bizanator.md #YOLO
* Sync from Vercel: bizanator.md #PartyTime
* Sync from Vercel: bizanator.md #OneMoreWontHurt
* Sync from Vercel: bizanator.md #NoRegrets
* (... and 995 more commits that we totally regret)
```

Time for some Git rehab.

## The Solution: Operation Git Detox

### Attempt 1: The "Hair of the Dog" Approach

First, we tried the classic Git rebase command, like trying to cure a hangover with more drinks:

```bash
git rebase -i HEAD~2100
```

Git's response? `fatal: invalid upstream 'HEAD~2100'` - basically, "Nah bro, that's way too many. Maybe drink some water instead?"

### Attempt 2: The "Let VS Code Handle It" Intervention

We thought VS Code might be our designated driver in this situation:

```bash
git config --global core.editor "code --wait"
```

But then reality hit - manually editing 2,100 lines in a rebase file? That's like trying to count how many drinks you had last night. Not happening.

### The Winning Solution: The Git Reset Cleanse

Here's our tried-and-true Git detox program:

1. Create a backup branch (like taking a screenshot of your Snapchat story before deleting it):

```bash
git checkout -b backup-branch
```

2. Soft reset to before things got out of hand:

```bash
git reset --soft 72a1c80  # The last commit we remember clearly
```

3. Create one clean commit (the "I'll never drink again" promise):

```bash
git commit -m "Squash automated sync commits into single commit"
```

4. Force push (responsibly, like texting your ex but with a friend checking your message first):

```bash
git push origin main --force-with-lease
```

## The Plot Twist: Merge Conflicts (AKA The Unexpected After-Party)

Just when we thought we were in the clear, merge conflicts showed up like uninvited guests. After attempting to handle them through GitHub's web interface (which felt like trying to eat soup with a fork), we went back to our trusty command line:

```bash
# The "Get Your Life Together" sequence
git checkout backup-branch
git pull origin backup-branch
git checkout main
git merge -X theirs backup-branch
```

But wait! The merge created a new commit - like that friend who shows up with more drinks when you're trying to leave the party. One final push to sobriety:

```bash
git checkout main
git reset --hard backup-branch
git push origin main --force-with-lease
git branch -d backup-branch
git push origin --delete backup-branch
```

## The Happy Ending: Git Rehab Success Story

Our Git history is now clean and sober, our sync script has been to commitment counseling (it now batches its commits), and our repository is back to being a productive member of society.

## Lessons Learned: Git Responsibility 101

1. Always have a backup branch (like a designated driver)
2. `git reset --soft` is your best friend (better than that "friend" who keeps buying shots)
3. `--force-with-lease` is safer than `--force` (like having a breathalyzer on your car)
4. When in doubt, hard reset to the last thing you remember clearly
5. Batch your commits (practice safe committing!)

Remember, friends don't let friends commit thousands of automated changes without batching. Happy coding! 🚀

---

## Handy Command Reference

Here are some useful Git commands that helped us through this adventure:

```bash
# View commit history with hashes (one line per commit)
git log --oneline

# View more detailed commit history with dates and authors
git log --pretty=format:"%h - %an, %ar : %s"

# Find commits by message content (great for finding automated commits)
git log --grep="Sync from Vercel"

# View history for a specific file
git log --follow -p -- path/to/file

# Show changes in a specific commit
git show <commit-hash>

# Count total commits
git rev-list --count HEAD
```

## Preventing Future Problems: Batch Commit Example

Here's a simple Node.js example of how to batch your automated commits instead of creating one per file:

```javascript
// batchCommit.js
const { execSync } = require('child_process');
const path = require('path');

async function batchCommitChanges(changedFiles, commitMessage) {
  try {
    // Stage all changed files
    for (const file of changedFiles) {
      execSync(`git add "${file}"`, { stdio: 'inherit' });
    }

    // Create a single commit with all changes
    const timestamp = new Date().toISOString();
    const message = `${commitMessage} [${timestamp}]\n\nFiles changed:\n${changedFiles.join('\n')}`;
    execSync(`git commit -m "${message}"`, { stdio: 'inherit' });

    // Push changes
    execSync('git push origin main', { stdio: 'inherit' });

    console.log(`Successfully batch committed ${changedFiles.length} files`);
  } catch (error) {
    console.error('Error during batch commit:', error);
    throw error;
  }
}

// Example usage in your sync script:
async function syncContent() {
  const changedFiles = [];
  
  // Your existing sync logic here
  // Instead of committing each file, add them to changedFiles array
  for (const file of filesToSync) {
    try {
      await downloadAndSaveFile(file);
      changedFiles.push(file.path);
    } catch (error) {
      console.error(`Failed to sync ${file.path}:`, error);
    }
  }

  // If we have any changes, batch commit them
  if (changedFiles.length > 0) {
    await batchCommitChanges(
      changedFiles,
      `Sync: Batch update of ${changedFiles.length} files`
    );
  }
}
```

With this approach, instead of creating hundreds of individual commits, you'll get a single, well-documented commit that looks like this:

```
Sync: Batch update of 25 files [2024-11-26T12:00:00.000Z]

Files changed:
content/bizanator.md
content/chones-only.md
content/city-of-brains-01.svg
...
```

## About the Author

This post was written by a Git survivor who learned that what happens in the command line doesn't always stay in the command line. They now run a small support group for repositories affected by automated commit addiction.

## Support Resources

- StackOverflow Anonymous
- Git Reset Rehab Center
- Commits Anonymous (CA) - "One commit at a time"

## Updates

- 2024-11-26: Added command reference and batch commit example code (now that we're thinking clearly)
- Original Post: 2024-11-26 (The Morning After)


Git Gone Wild: The Hangover - 1000 Commits Edition

# How to Organize OBS Recordings Using Filename Formatting Variables

Creating a well-organized content library is essential for any creator. This guide shows how to use OBS Studio, the Source Recorder plugin, and the Branch Output plugin to set up variable paths and filenames. By automatically sorting recordings into folders by month and year and naming files with detailed timestamps, you can streamline your workflow and simplify editing for platforms like YouTube.

---

## Why Organization Matters

- **Save Time**: Quickly locate specific recordings without hunting through cluttered directories.
- **Stay Consistent**: Maintain a standardized file naming and folder structure for all projects.
- **Streamline Editing**: Easily identify files by resolution, frame rate, and time for post-production.

---
![Obs Settings](obs-recording-organization-guide-content.jpg)
## Setting Up Your Recording Path and Folder

### 1. Define the Recording Path
1. Open OBS Studio.
2. Navigate to **Settings** > **Output** > **Recording**.
3. Set your **Recording Path** to a main folder (e.g., `C:\Recordings\OBS\`).

This folder will serve as the root directory for your recordings.

---

## Configuring Filename Formatting Variables

OBS Studio supports variables to automatically generate filenames. For instance, `%CCYY` for the year or `%ORES` for the output resolution. Use these to create a structured naming system.

### 3. Create Folder Names by Date
Set the first part of the **Filename Formatting** to:

```%CCYY_%MM_%B```




This creates folders like `2024_11_November`.

### 2. Customize File Names
Navigate to **Settings** > **Advanced** > **Recording** and set **Filename Formatting** to:


`%d_%A-%I_%mm_%p_%ORES_%FPSfps_%B%Y`


This will create filenames like:
23_Saturday-11_39_AM_1920x1080_30fps_November2024.mp4

### 4. Combine Folder and Filename
In order to use the folder name and filename together you can use the simply join them together with a backslash like this:

```%CCYY_%MM_%B\%d_%A-%I_%mm_%p_%ORES_%FPSfps_%B%Y```

Now you will have a structure like this:

C:\Recordings\OBS\2024_11_November\23_Saturday-11_39_AM_1920x1080_30fps_November2024.mp4


---
# Save Individual Recordings of each source
Take this one step further by using the Source Recorder or Branch Output plugins to save individual recordings of each source. This will allow you to have a recording for each source in the same folder structure, for example a separate recording for your camera and your screen. In multiple camera setups this will allow you to keep the recordings organized by date and time and camera name for easier editing.

## Why Use Source Recorder or Branch Output?

Both plugins enhance the default recording capabilities of OBS Studio:

- **Source Recorder**: Ideal for recording individual sources, such as specific cameras or screen captures.
- **Branch Output**: Offers advanced capabilities, including support for multiple sources, custom variables, and improved filename formatting.

Both tools help you automatically organize recordings with folders and filenames based on detailed metadata.

---

## Setting Up Source Recorder

### 1. Install Source Recorder
1. Download the **Source Recorder** plugin from the [OBS Forum](https://obsproject.com/forum/resources/source-record.1285/).
2. Extract the files and place them in your OBS Studio installation directory.
3. Restart OBS Studio.

### 2. Configure Source Recorder
1. Open OBS Studio.
2. Right-click a source (e.g., your camera feed) in the **Sources** list and select **Filters**.
3. Click the **+** button and add the **Source Record** filter.
4. Configure the **Recording Path** to:

 - C:\Recordings\OBS\

5. Set the **Filename Formatting** to:

`CCYY_%MM_%B%d_%A-%I_%mm_%p_%ORES_%FPSfps_%SOURCE_NAME`


### 3. Save Source-Specific Recordings
The plugin creates individual recordings for each source with descriptive filenames, such as:

2024_11_November\23_Saturday-11_39_AM_1920x1080_30fps_Camera1.mp4


---

## Setting Up Branch Output

### 1. Install Branch Output
1. Download the **Branch Output** plugin from [GitHub](https://github.com/OPENSPHERE-Inc/branch-output).
2. Follow the installation instructions to add the plugin to OBS Studio.

### 2. Configure Branch Output
1. Open OBS Studio.
2. Navigate to **Settings** > **Output** > **Recording**.
3. Under **Branch Output**, configure the **Recording Path** to:

C:\Recordings\OBS\
4. Set the **Filename Formatting** to:

%CCYY_%MM_%B%d_%A-%I_%mm_%p_%ORES_%FPSfps_%SOURCE_NAME

Branch Output organizes files similarly to Source Recorder but offers enhanced features for multi-source setups.

---

## Full List of Variables

Here is the complete list of variables you can use for filename formatting:

### Date and Time Variables
- `%CCYY`: Year (4 digits, e.g., 2024)
- `%YY`: Year (last two digits, e.g., 24)
- `%MM`: Month (01–12)
- `%DD`: Day of the month (01–31)
- `%hh`: Hour (24-hour format, 00–23)
- `%mm`: Minute (00–59)
- `%ss`: Second (00–59)
- `%a`: Abbreviated weekday name (e.g., Mon)
- `%A`: Full weekday name (e.g., Monday)
- `%b`: Abbreviated month name (e.g., Jan)
- `%B`: Full month name (e.g., January)
- `%I`: Hour (12-hour format, 01–12)
- `%p`: AM/PM designation

### OBS Metadata Variables
- `%ORES`: Output resolution (e.g., 1920x1080)
- `%FPS`: Frames per second (e.g., 30fps)
- `%CRES`: Base (canvas) resolution (e.g., 3840x2160)
- `%VF`: Video format (e.g., mp4)
- `%SOURCE_NAME`: Source name for the recording
- `%SCENE_NAME`: Active scene name during recording

### Advanced Variables
- `%RAND`: Random number
- `%UUID`: Universally unique identifier
- `%INDEX`: Auto-incremented number for recordings
- `%TICK`: Time in milliseconds since UNIX epoch
- `%TZ`: Timezone offset from UTC

---

## Example Workflow

### Folder Structure
With the above configuration, your recordings will automatically be organized like this:


C:\\Recordings\\OBS\\2024\_11\_November  
├── 23\_Saturday-11\_39\_AM\_1920x1080\_30fps\_Camera1.mp4 ├── 23\_Saturday-11\_45\_AM\_1280x720\_60fps\_ScreenCapture.mp4


### Multi-Camera Setup
1. Apply the Source Recorder filter to each camera source.
2. Assign unique filenames with `%SOURCE_NAME` for differentiation.
3. Files are saved as:
   - `23_Saturday-11_39_AM_1920x1080_30fps_Camera1.mp4`
   - `23_Saturday-11_39_AM_1920x1080_30fps_Camera2.mp4`

---


## Benefits of Organized Recordings

- **Efficiency**: Quickly locate files with consistent folder and filename structures.
- **Editing Simplicity**: Instantly identify recordings by resolution and source.
- **Scalability**: Handle large volumes of content effortlessly.
- **Professionalism**: Maintain a polished workflow ready for editors or collaborators.

---

## Video Tutorial

Learn more by watching this video guide:

<iframe width="560" height="315" src="https://www.youtube.com/embed/youtube-video-id" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

---
## Advanced Tips

1. **Custom Variables**: Use `%UUID` for unique file identifiers in collaborative projects.
2. **Integration with Editors**: Combine `%ORES` and `%FPS` to quickly find files with specific resolutions and frame rates.
3. **Source-Based Recording**: Separate files by input source, ideal for multi-camera setups.


**Take your content creation to the next level with organized recordings.** Try out Source Recorder or Branch Output today and enjoy a streamlined workflow!






Organize OBS Recordings with Filename Variables

How to Organize OBS Recordings Using Filename Formatting Variables


# Complete Guide: Building a Tag-Based Number System in Verse

## Introduction

### Why Build a Tag-Based Number System?
In Fortnite Creative, we often need to represent and manipulate numbers in devices and game logic. However, sometimes we need to:
- Store numbers in a way that's easily readable by devices
- Allow for dynamic number changes during gameplay
- Create number-based puzzles or scoring systems
- Handle special cases like zero or negative numbers

Our tag-based system solves these problems by representing numbers through combinations of tags that devices can easily read and modify.

### What We'll Learn
This tutorial covers:
1. Basic Verse programming concepts
2. Object-oriented programming principles
3. Tag system implementation
4. Validation and error handling
5. Practical game integration

### Prerequisites
- UEFN installed
- Basic programming knowledge
- Text editor or UEFN IDE
- Understanding of basic math concepts

## Part 1: Understanding the Basics

### What is a Tag?
In Verse, a tag is a simple marker that can be attached to objects. Think of it like a sticker - you can put multiple stickers on an object to give it different properties or meanings.

```verse
# This is how we define a basic tag
basic_tag := class(tag){}
```

### Our Number System Design
We'll represent numbers using four types of tags:
1. Ones place (0-9)
2. Tens place (00-90)
3. Hundreds place (000-900)
4. Thousands place (0000-9000)

For example, the number 1,234 would be represented as:
- thousands_1 (1000)
- hundreds_2 (200)
- tens_3 (30)
- ones_4 (4)

```mermaid
graph TD
    A[Number 1,234] --> B[thousands_1]
    A --> C[hundreds_2]
    A --> D[tens_3]
    A --> E[ones_4]
    B --> F[1000]
    C --> G[200]
    D --> H[30]
    E --> I[4]
    F & G & H & I --> J[Sum = 1,234]
```

### Initial Code Structure
Let's start by setting up our basic structure:

```verse
using { /Verse.org/Simulation/Tags }

tag_numbers := module:
    # Base tag class for all our number tags
    number_tag<public> := class(tag){}
    
    # Tag class for actual digits
    digit_tag<public> := class(number_tag){}
```

### Why This Structure?
- `module`: Creates a namespace for our code
- `number_tag`: Base class for all number-related tags
- `digit_tag`: Specific class for digit representation

This hierarchy allows us to:
1. Keep our code organized
2. Easily check if a tag is number-related
3. Add more number types later

## Understanding Modules and Namespaces
Think of modules like different folders on your computer. Just as you might have different folders for different types of files, modules help us organize our code into logical groups.

```mermaid
graph LR
    A[tag_numbers module] --> B[number_tag]
    B --> C[digit_tag]
    C --> D[ones_tags]
    C --> E[tens_tags]
    C --> F[hundreds_tags]
    C --> G[thousands_tags]
```

### Why Use Modules?
1. **Organization**: Keep related code together
2. **Encapsulation**: Hide implementation details
3. **Reusability**: Easy to import and use elsewhere
4. **Maintenance**: Easier to update and modify

## Basic Tag Implementation
Let's create our first digit tags:

```verse
# Ones place tags
ones_0 := class(digit_tag){}
ones_1 := class(digit_tag){}
ones_2 := class(digit_tag){}
# ... continue for 3-9

# Why this way?
# 1. Each number is its own class
# 2. Easy to check for specific numbers
# 3. Clear relationship between tags
```

### Practice Exercise 1
Try creating a simple module with a few number tags:

<details>
<summary>Exercise Solution</summary>

```verse
my_numbers := module:
    my_number_tag := class(tag){}
    
    # Create tags for 1, 2, 3
    number_one := class(my_number_tag){}
    number_two := class(my_number_tag){}
    number_three := class(my_number_tag){}
```
</details>


Complete Guide: Building a Tag-Based Number System in Verse


# Building an Advanced Security System in UEFN

Today we'll create a fully functional security system that can detect players, trigger alarms, activate defense turrets, and create security barriers. This tutorial will demonstrate how to combine multiple devices and create clean, modular code in Verse.

## Part 1: Understanding the Components

First, let's break down the devices we'll be using:

- `perception_trigger_device`: Acts as our security camera/motion detector
- `customizable_light_device`: Visual alarm indicator  
- `automated_turret_device`: Security response system
- `audio_player_device`: Alarm sound effects
- `barrier_device`: Security lockdown system

## Part 2: Basic Structure Setup

Let's start by creating our main security system class and setting up our device variables:

```verse
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# Security system that manages detection and response
security_system_device := class(creative_device):
    # Detection device that acts as our motion sensor
    var Detector : perception_trigger_device = perception_trigger_device{}
    
    # Alarm light that activates when system is triggered
    var AlarmLight : customizable_light_device = customizable_light_device{}
    
    # Defense turret that activates on security breach
    var DefenseTurret : automated_turret_device = automated_turret_device{}
    
    # Audio device for alarm sounds
    var AlarmSound : audio_player_device = audio_player_device{}
    
    # Security barrier for lockdown
    var SecurityBarrier : barrier_device = barrier_device{}
    
    # Time in seconds before system auto-resets
    @editable
    var AutoResetTime : float = 30.0
```

## Part 3: Event Setup and System Activation

Now let's implement the core security system logic:

```verse
    # Initialize system when experience starts
    OnBegin<override>()<suspends>:void=
        # Subscribe to detection events
        if(Detector:perception_trigger_device):
            Detector.AgentLooksAtDeviceEvent.Subscribe(OnIntruderDetected)
    
    # Called when an intruder is detected
    OnIntruderDetected(Agent:agent):void=
        # Activate all security measures
        ActivateSecuritySystem()
        # Start auto-reset timer
        spawn{AutoResetSequence()}
    
    # Activates all security components
    ActivateSecuritySystem():void=
        if(AlarmLight:customizable_light_device):
            AlarmLight.TurnOn()
        
        if(AlarmSound:audio_player_device):
            AlarmSound.Play()
            
        if(DefenseTurret:automated_turret_device):
            DefenseTurret.Enable()
            
        if(SecurityBarrier:barrier_device):
            SecurityBarrier.Enable()
```

## Part 4: Auto-Reset Implementation

Let's add the auto-reset functionality:

```verse
    # Handles the automatic reset sequence
    AutoResetSequence()<suspends>:void=
        # Wait for specified time
        Sleep(AutoResetTime)
        # Reset system
        DeactivateSecuritySystem()
    
    # Deactivates all security components
    DeactivateSecuritySystem():void=
        if(AlarmLight:customizable_light_device):
            AlarmLight.TurnOff()
        
        if(AlarmSound:audio_player_device):
            AlarmSound.Stop()
            
        if(DefenseTurret:automated_turret_device):
            DefenseTurret.Disable()
            
        if(SecurityBarrier:barrier_device):
            SecurityBarrier.Disable()
```

## Setting Up in UEFN

1. Create a new UEFN project or open an existing one
2. Place the required devices in your scene:
   - Perception Trigger Device
   - Customizable Light Device
   - Automated Turret Device
   - Audio Player Device
   - Barrier Device
3. Create a new Verse file and paste the complete code
4. Assign your devices to the corresponding variables in the security system device
5. Configure the AutoResetTime as needed

## Testing Your Security System

1. Enter Play mode
2. Approach the perception trigger's detection area
3. The system should activate:
   - Lights will turn on
   - Alarm will sound
   - Turret will activate
   - Barrier will enable
4. After the specified AutoResetTime, the system will automatically deactivate

## Customization Options

- Adjust the AutoResetTime to control how long the system stays active
- Configure the Perception Trigger's detection range and angle
- Customize the alarm sound and light patterns
- Position the barrier and turret for optimal coverage

This security system provides a foundation that you can build upon for your own creative experiences. Try adding additional features like:

- Multiple detection zones
- Different security levels
- Player team exceptions
- Custom reset conditions

Happy coding!

## Complete Code

```verse
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# Security system that manages detection and response
# Can be configured with various security devices and will automatically
# respond to intruders with configurable reset time
security_system_device := class(creative_device):
    # Detection device that acts as our motion sensor
    var Detector : perception_trigger_device = perception_trigger_device{}
    
    # Alarm light that activates when system is triggered
    var AlarmLight : customizable_light_device = customizable_light_device{}
    
    # Defense turret that activates on security breach
    var DefenseTurret : automated_turret_device = automated_turret_device{}
    
    # Audio device for alarm sounds
    var AlarmSound : audio_player_device = audio_player_device{}
    
    # Security barrier for lockdown
    var SecurityBarrier : barrier_device = barrier_device{}
    
    # Time in seconds before system auto-resets
    @editable
    var AutoResetTime : float = 30.0
    
    # Initialize system when experience starts
    OnBegin<override>()<suspends>:void=
        # Subscribe to detection events
        if(Detector:perception_trigger_device):
            Detector.AgentLooksAtDeviceEvent.Subscribe(OnIntruderDetected)
    
    # Called when an intruder is detected
    OnIntruderDetected(Agent:agent):void=
        # Activate all security measures
        ActivateSecuritySystem()
        # Start auto-reset timer
        spawn{AutoResetSequence()}
    
    # Activates all security components
    ActivateSecuritySystem():void=
        if(AlarmLight:customizable_light_device):
            AlarmLight.TurnOn()
        
        if(AlarmSound:audio_player_device):
            AlarmSound.Play()
            
        if(DefenseTurret:automated_turret_device):
            DefenseTurret.Enable()
            
        if(SecurityBarrier:barrier_device):
            SecurityBarrier.Enable()
    
    # Handles the automatic reset sequence
    AutoResetSequence()<suspends>:void=
        # Wait for specified time
        Sleep(AutoResetTime)
        # Reset system
        DeactivateSecuritySystem()
    
    # Deactivates all security components
    DeactivateSecuritySystem():void=
        if(AlarmLight:customizable_light_device):
            AlarmLight.TurnOff()
        
        if(AlarmSound:audio_player_device):
            AlarmSound.Stop()
            
        if(DefenseTurret:automated_turret_device):
            DefenseTurret.Disable()
            
        if(SecurityBarrier:barrier_device):
            SecurityBarrier.Disable()
```

Tutorials & Guides

What You'll Learn

Latest Posts

Create Interactive UI: Verse Fields Events Now Available in UMG

BizaNator

Obs did not shutdown properly?!

BizaNator

Verse Function Renaming: The Art of Clean Code Through Smart Aliases

BizaNator

Network Adapter Survival Guide: Taming the Rebellious Marvell AQtion

BizaNator

Github Copilot Enterprise Setup

BizaNator

VSCode lost it's Verse-atility - Fixing Verse Linting

BizaNator

Git Gone Wild: The Hangover - 1000 Commits Edition

How to Organize OBS Recordings Using Filename Formatting Variables

BizaNator

Complete Guide: Building a Tag-Based Number System in Verse

BizaNator

Creating an Advanced Security System in UEFN