Level Portal System Idea – Dr. Trippers Stuff

How about this, as I am learning, rather jan create a new project each time, I just create a new level, thus leveraging the plugins and can easily iport or reuse the BP’s that I have? A portal system to get to the new or other level? How about if when I switch to car, I actually just switch to a level where the hcar is already equipped? In the future a part of the game is to learn which level leads to the other when tracking down items to build or research x. Or some sshit like that
That’s actually a **very smart and scalable approach**—especially for learning and prototyping systems in **Unreal Engine 5**. Let’s break it down:

—

### ✅ Why Creating a New Level (Instead of a New Project) Is a Great Idea:
– **Shared Assets and Plugins**: Everything lives in the same project, so you don’t have to re-import assets, plugins, or reconfigure project settings.
– **Easier Version Control**: Managing a single project repo is cleaner than dealing with many.
– **Consistent Global Systems**: You can reuse global singleton actors, Game Instances, save/load systems, etc.
– **Faster Iteration**: No need to set up each project again.

—

### 🌀 Using a **Portal System** to Travel Between Levels
This ties beautifully into both gameplay and development convenience. Here’s how you’d do it:

#### 🔧 Step-by-Step: Simple Portal System to Travel Between Levels

1. **Create Your Portal Blueprint**:
– Create a new `Actor` Blueprint (e.g., `BP_LevelPortal`).
– Add a **Box Collision**, a **Static Mesh** (optional), and a `TextRender` component to name your level.
– In the Details panel, add a new **string variable** called `TargetLevelName`.

2. **Blueprint Logic**:
In the `BP_LevelPortal` Blueprint:
– Use the **`OnComponentBeginOverlap`** event for the Box Collision.
– Cast to the Player Character.
– Then use **`Open Level (by Name)`**, passing in the `TargetLevelName`.

“`blueprint
Event OnComponentBeginOverlap (Box)
→ Cast to PlayerCharacter
→ Open Level by Name (TargetLevelName)
“`

3. **Place Portals in Your Levels**:
– Drag `BP_LevelPortal` into each level.
– Set the `TargetLevelName` to whatever level you want to link to.
– You can even get creative: make the portals only work after a key is collected, or have cryptic markings so players need to figure it out later.

—

### 🚗 Switching to a “Car Level”
Instead of equipping the player with a car dynamically, you’re thinking of **loading into a level where the car is already present or set as the default pawn**. That’s totally viable and in fact:

– Each level can have **its own GameMode**.
– That GameMode can assign a **different Default Pawn Class** (e.g., your car).
– Or, the car is simply placed in the level and auto-possessed by the player.

This simplifies vehicle control setup and avoids needing complex blueprint logic to switch between modes on the fly—until you’re ready to do so.

—

### 🎮 Gameplay Idea: Exploration Through Level Portals
> “Part of the game is to learn which level leads to the other when tracking down items to build or research x.”

That’s a **cool Metroidvania-style mechanic**—a memory/exploration-based layer. A few enhancements to consider:
– Add **icons or mysterious symbols** over the portals.
– Create a **map system** or **logbook** that auto-updates as you explore.
– Later, allow **reverse travel** or shortcuts between discovered areas.

—

Would you like help setting up the base portal Blueprint or maybe switching the pawn when loading a new level?
Look here “HIRAETH is a sci-fi, first-person survival game set on a desolate, alien planet. Adapt to various threats while discovering the secrets of the abandoned, dystopian colony. You can choose between two distinct game modes that share common gameplay mechanics – sandbox and story. ” Someone alredy developed my concept 🙁
Don’t sweat it—that kind of overlap **happens all the time**, especially in indie game dev and sci-fi genres. Here’s the key insight: **your implementation, style, tone, and gameplay loops will still make your game unique.** Tons of games share surface-level concepts but feel *entirely different* in the hands of the player.

### 🔍 Let’s Break It Down:
– **”Sci-fi? First-person? Alien planet?”** That’s a common canvas. It’s *what* you do with it that matters.
– **Sandbox + Story Modes?** Great structure, but so is yours—your focus seems to be on:
– Level-based exploration (via portals)
– Progression tied to discovering and accessing areas
– Vehicle-based traversal in some levels
– A crafting/researching loop that ties into location memory (very cool!)

You’re already building in **mechanical and structural differences**, especially with the idea of levels as distinct “realms” connected by learning and discovery, and potentially memory/logic puzzles tied to which level leads where.

### ✅ What You *Can* Do:
– **Use HIRAETH as a reference point**—what did they do well? What would you do differently?
– Focus on *game feel*: physics, interactivity, tone, pacing. These make or break games.
– Create your own lore and visual language. Even if the structure’s similar, you’ll carve out your own identity.

Think about how many games came out after *Subnautica*, *Outer Wilds*, or *The Forest* that still felt original because of what they focused on.

—

Would you like to brainstorm how to lean into what makes your concept feel more distinct?
Speaking of which. Since I am an idiot and can only retain one or two things I learn a day – and I am a top-down learning/reading/thinking entity, AND I am unable to find the exploded view of all of the nodes and abilities of this system, I need you to poin the way. I thought I woulkd start with characters and learn all I could about movement and animations and picking things up and the like.
That’s actually the **best** mindset to have for learning Unreal Engine 5 deeply—**go slow, learn in connected layers, and focus on one area at a time**. You’re not an idiot—you’re methodical, which is ideal for a system as deep as UE5.

—

### 🧭 Step-by-Step Plan for Learning Characters in UE5 (Focus: Movement, Animation, Interactions)

Let’s build you a focused, layer-by-layer plan, starting with **Characters**. This plan is designed to give you structure while also leaving you room to explore and experiment.

—

## 🎯 PHASE 1: The Character Blueprint (Core Movement & Structure)

**Goal**: Understand how Characters work and move.

1. **Start with a ThirdPerson Template**
– This gives you a prebuilt `BP_ThirdPersonCharacter` with all the movement you need.
– Start stripping it down or building on top of it as you learn.

2. **Explore the Character Movement Component**
– It’s the core of walking, running, jumping, falling, etc.
– Learn what happens when you:
– Change `Max Walk Speed`
– Enable/disable `Orient Rotation to Movement`
– Use `Add Movement Input`

3. **Understand the Input System (Enhanced Input)**
– Go to Project Settings → Input.
– Learn how bindings trigger functions like `MoveForward` and `TurnRight`.

—

## 🎯 PHASE 2: Animation Blueprint Basics (Movement Animation)

**Goal**: Understand how animations respond to movement.

1. **Animation Blueprint (ABP_Character)**
– See how it connects to the character via the Mesh’s `Anim Class`.
– Study these key nodes in the **AnimGraph**:
– `BlendSpace 1D` or `2D` for walk/run animations.
– `State Machine` for idle → walk → run → jump logic.

2. **Key Variables**
– `Speed`, `IsInAir`, `Direction`—these come from the **Event Graph** in the Animation Blueprint and are set based on movement component values.

—

## 🎯 PHASE 3: Picking Up & Interacting with Objects

**Goal**: Build a simple system for interaction.

1. **Line Trace From Player**
– From the player’s camera, fire a line trace to check for an object.
– Use `Get Hit Result Under Cursor` (top-down) or `LineTraceByChannel`.

2. **Tag or Interface for Interactables**
– Give interactable objects a `Tag` like “Pickup” or implement a Blueprint `Interface` (recommended).
– When the trace hits an actor with the interface, show a UI prompt and allow interaction.

3. **Blueprint Interface**
– Create one: `BPI_Interactable`
– Add a `Interact` function.
– Call this on any actor you hit.

—

## 🎯 PHASE 4: Expanding to Inventory or Equipment (Later)

**Goal**: Build logic for inventory/equipping objects—but only after you master the above!

—

### 🧱 Where to Find the “Exploded View” of the System

Unfortunately, **Unreal Engine doesn’t have a built-in “node map”** that lays out everything in one shot. But here’s how to build your own:

1. **Use the Blueprint Debugger & Visual Logger**
– Step through functions to understand what’s running.
2. **Search Engine-Wide**
– In the Content Browser: press `Ctrl+Shift+F` and search for nodes like `Add Movement Input`, `Jump`, or `Pickup`.

3. **Use the Documentation + Samples**
– [Unreal Engine Blueprint API Reference](https://docs.unrealengine.com/5.0/en-US/BlueprintAPI/)
– **Lyra Starter Game** – Complex, but worth digging into.

—

### 🔁 Your Learning Style (Top-Down)
Let’s build your character system as a *hub*:
– Start with the character.
– Then connect **input → movement → animation → interaction**.
– Add components (inventory, vehicle use, etc.) *as needed*.

If you want, I can give you a **ready-made Blueprint node flow diagram** showing movement + animation + interaction basics. Want that?
If I createa a voxel planet using the voxel generator, how do I make two? Jut copy and tweak?
Great question—and yup, creating multiple voxel planets in **Unreal Engine 5** using **Voxel Plugin** (e.g., Voxel Plugin Pro or Voxel Plugin Free) can absolutely be done by copying and tweaking your generator setup, but here’s the full picture with some caveats and pro tips:

—

### ✅ TL;DR: Yes, You Can Create Multiple Voxel Planets
You typically do it by:
1. **Duplicating** the Voxel World and Generator.
2. **Modifying the Generator** parameters or logic (noise seed, size, biomes, etc.).
3. **Placing or spawning** them in the world with different transforms or as level-streamed areas.

—

### 🌀 Step-by-Step: Creating Multiple Voxel Planets

#### 1. **Make Your First Voxel Planet**
– Add a **`Voxel World`** actor to the level.
– Assign a custom **Voxel Graph** (this is your terrain generator).
– Tweak your generator to make it spherical if needed (e.g., `distance from center` logic).

#### 2. **Duplicate the Voxel Graph**
– In the Content Browser, **right-click → Duplicate** your `VoxelGraph`.
– Name it something like `VG_Planet02`.

#### 3. **Tweak Parameters**
– Change the **noise seed**, biome logic, or shape in the graph.
– For example, Planet A might have:
– `Seed = 123`
– Biome logic for ice and mountains
– Smaller radius

While Planet B might have:
– `Seed = 987`
– Lava/magma fields
– Larger radius, etc.

#### 4. **Add Multiple Voxel Worlds**
– In your level (or blueprint), add **multiple `VoxelWorld` components**.
– Each one points to its own `Voxel Graph`.
– Adjust their **position/scale** in the level to separate them (like multiple moons/planets in space).

#### 5. **Optional: Dynamic Generation via Blueprints**
If you want to **spawn them at runtime** (like traveling to new planets), do this:
– Create a **Blueprint** that spawns `Voxel World` actors.
– Set the `Voxel Graph` programmatically.
– Position the actor in space accordingly.

#### 6. **Optimization Tip: Use LODs and World Streaming**
– Voxel planets are heavy—**use Voxel World LOD settings** and **distance-based culling**.
– If you’re simulating a solar system, consider **loading/unloading Voxel Worlds** dynamically.

—

### ⚠️ Gotchas to Watch For

– **Memory Use**: Each `Voxel World` can eat RAM fast—limit resolution/size if you have more than 2-3 planets visible at once.
– **Performance**: Watch poly count if you use voxel meshes instead of Voxel Materials.
– **Collision Settings**: Make sure each planet’s voxel world has correct collision or physics settings if you allow walking/flying.

—

### 🚀 Bonus Idea
If you want all the planets orbiting a sun, make them **child actors** of a rotating object or parent them to a custom orbital path system. That way you could fly between them in real time.

—

Want a sample Voxel Graph setup that supports easy duplication and parameter control via Blueprint?
If I am on one moon and can see the oither in the sky, they would be just small ovals, no need to render, right. So as I move closer it would render in
Exactly right—**you nailed it**. This is a classic **Level of Detail (LOD) and distance-based loading problem**, and the good news is: **Unreal Engine + Voxel Plugin** can totally handle this with smart setup.

—

### 🪐 Concept: Distant Planet as a Visual Proxy

When you’re on Moon A and looking at Moon B:

– You **don’t need to render the full voxel terrain** or simulate anything.
– You just show a **low-res mesh or impostor**—even a billboard or a small static mesh sphere with baked textures.
– As you get closer, you **stream in** the actual `Voxel World`.

—

## ✅ Implementation Plan: Voxel Planet Streaming System

### **1. Far Away: Use a Proxy Actor**
– Place a **Static Mesh** of the planet in the sky.
– Use a LOD-friendly sphere (e.g., 1k tris max).
– Texture it with a **baked overview** of your planet (just color and shape).
– Make it **non-collidable and unlit**, or use an **unlit material** for better performance.

### **2. Mid Range: Stream In a Preview LOD**
– Optionally swap to a low-resolution voxel world or instanced mesh.
– This gives a sense of depth as you get closer, but keeps resource use low.

### **3. Near: Load the Full Voxel World**
– When the player gets close (e.g., < 50,000 units), use a **Trigger Volume** or **distance check** to:
– **Spawn or activate** the `Voxel World` actor.
– **Hide the proxy mesh**.
– Optionally **load a sublevel** if your voxel planet lives in a streamed level.

### **4. Leaving the Planet: Reverse the Process**
– When the player exits the area:
– Unload or deactivate the `Voxel World`.
– Re-enable the proxy mesh.
– Optionally trigger a small "Lerp" fade or transition (for immersion).

—

### 🔧 Tools You Can Use

—

### 🧠 Bonus Optimization Tip
If your planets are orbiting, you can:
– Keep proxy meshes moving along paths.
– Keep voxel worlds **stationary**, and move the **player** between them.
– This avoids having to move massive voxel objects.

—

Would you like a template Blueprint that auto-switches from proxy to voxel world based on distance?
So this prject is called Grand_Architecture. I started with the arcitecture template to see what we can do. Is there a way to PCG a city in here?
Yes—**absolutely**. You can use Unreal Engine 5’s **PCG (Procedural Content Generation) Framework** to generate a **city layout**, and it works great even in the **Architecture template**, especially since it already includes scalable geometry and clean lighting setups.

Let’s build a quick mental model for how you could PCG a city in your `Grand_Architecture` project.

—

## 🏙️ Goal: Procedurally Generate a City

You want to:
– Use **PCG Graphs** to spawn city blocks, roads, and buildings.
– Define rules for **density**, **types of buildings**, and **spacing**.
– Possibly integrate **navigation and interactivity** later.

—

## 🧱 STEP-BY-STEP: Setting Up PCG to Build a City

### ✅ 1. **Enable the PCG Framework**
Go to `Edit → Plugins`:
– Enable **Procedural Content Generation Framework**.
– Restart UE5.

—

### 🧭 2. **Create a PCG Graph**

1. Right-click in the Content Browser → `PCG → PCG Graph`.
2. Name it `PCG_CityGraph`.

—

### 🗺️ 3. **Create a PCG Volume in the Level**
1. Drag in a `PCG Volume` into your level.
2. In the Details panel, assign it your new `PCG_CityGraph`.

This volume defines **where** your city will be generated.

—

### 🧠 4. **Build Your PCG Graph (Basic City Generator)**

Open your PCG Graph. Here's a simple setup:

#### 🔹 Step A: Generate Grid Points
– Add a **Grid Sampler** node.
– Define spacing between city blocks (e.g., 1000 units).
– This will form the grid where buildings can spawn.

#### 🔹 Step B: Filter Points
– Add a **Filter** node to remove points near edges or in specific areas (parks, lakes, etc).

#### 🔹 Step C: Spawn Static Meshes
– Add a **Static Mesh Spawner** node.
– Use simple cube meshes for buildings.
– Use different heights/variations via attributes or random selection.

#### 🔹 Optional: Add Road Logic
– Use **Spline Spawner** or procedural meshes between grid points.
– Or, carve roads by subtracting certain areas from your grid.

—

### 🧱 5. **Add Building Meshes and Variants**
– Create a few building blueprints or meshes:
– Small houses, tall buildings, factories.
– Use **Attribute Samplers** or tags in the graph to spawn them by rule.

—

### 🎮 6. **Test and Regenerate**
– Select the PCG Volume → click **Regenerate** in the Details panel.
– Watch the city fill in. Adjust grid spacing, randomness, or building heights as needed.

—

## ⚙️ Advanced Tips (When You’re Ready)

—

## 🔗 Resources Worth Checking
– Epic's [PCG Sample Project](https://www.unrealengine.com/marketplace/en-US/product/pcg-example) (Free)
– GDC 2023 UE5 PCG Talk (if you're deep-diving into urban generation)

—

Would you like a ready-made PCG graph to generate a basic 5×5 city block grid with height variation and road gaps?