With recent events happening I figured I’d give game development a shot and have a cool space game idea. My problem is I’m not sure how to start considering I’m brand new and cant find any videos that would help with my specific game. I want it to be in space and have objects come towards you that you have to dodge, like the game “red hot”, or that cool scene in the matrix with Neo in slow mo dodging bullets any tutorials or help you guys know of? Thank you in advance 
I just tried typing ‘ue4 space game tutorital’ into youtube, and dissapeared under a torrent of answers.
Maybe take a look at some stuff and find something in the right ball park for you. There is also, of course:
I’d recommend looking into a series that might be similar to what you want or have similar concepts. Ryan Laley and CodeLikeMe are two channels I’ve learned a lot from.
I’d say the best way to start would be:
- Learn your way around the UE4 editor and what it can do for you.
- Learn the basics of what assets are and their types (static meshes, skeletal meshes, materials, textures, blueprints…).
- Quickly get up to speed on the core UE4 blueprint classes (Game Instance, Game Mode, Player Controller, Camera Manager…).
- Quickly get up to speed on the basic concepts of blueprint scripting.
- Download a good example project to start with and just explore what it has and what it does:
i) Look at what assets it has in the Content Browser, open some of them up and get an idea for what sort of data they have associated with them.
ii) Open a game level and look at the basic actors it has in the World Outliner and look at the variables they have associated with them in their Details panel.
iii) Open some of its core blueprints (3 above) and try to roughly follow what they do…
(1) https://docs.unrealengine.com/en-US/…mpaign=uelearn
(5) From “Unreal Launcher > Unreal Engine > Learn > scroll down to Gameplay Concepts/Games” download and open up one of the example projects.
Hope this helps a bit…
Below is a quick intro crib sheet I put together for someone when doing an engine evaluation. Its not perfect but a good place to start:
Main Editor
The main editor contains several windows (panels) that allow you to access the different parts of an open project. It also has a set of modes that you can select to edit different aspects of an open level.
Panels
[TABLE=“border: 0, cellpadding: 0, cellspacing: 0”]
Main Editor (Panels)
Menu
Gives access to the standard application menu bar on the left and extras menu on the right (including console command box, and source control status).
Toolbar
Provides quick access to the commonly used UE4 tools. Buttons shown depend on active mode or current blueprint type.
Viewport
The map visualisation window. Shows the graphical representation of the level world and the objects populating it. Used for all direct mouse based addition, movement, and translation of world objects. Also used for landscape sculpting and painting in Landscape mode.
Modes
Window containing buttons to switch between the primary UE4 editor modes. Each mode changes the primary behaviour of the level editor (see below).
Content Browser
Primary area for viewing, opening, creating, importing, and organising assets. Contains static and skeletal meshes, materials, textures, particles, blueprints, and other assets. Also used to manually place assets in a level, and materials onto already placed actors.
World Outliner
Lists all actors in the open level/map (scene) in a hierarchical tree view. Individual actors can be selected from this window. Also contains an information drop down menu to create, display, and select levels, layers, and id names.
Details
Contains the properties (the public/editable ones) and transformation edit boxes for the currently selected actor. Also contains the actors publicly available information, functions, and utilities.
Notes:
- Any of these windows can be closed by clicking the x button on their tab and reopened from “Menu > Windows".
- The panel “tabs” themselves can be hidden by right clicking on them and selecting hide, or shown again by clicking the small yellow triangle corner fold.
Modes
With the Modes panel open, several editor modes can be chosen from. Unless sculpting or painting a landscape, or placing foliage, “Place” mode is the main mode used:
[TABLE=“border: 0, cellpadding: 0, cellspacing: 0”]
Main Editor (Modes)
**Place **
For placing actors in a scene.
Paint
For painting vertex colours/texture on static mesh actors directly in viewport.
Landscape
For creating and editing Landscape terrains in a level.
Foliage
For painting instanced foliage.
Geometry
For modifying brushes to geometry.
Notes:
- To see advanced help on any mode button, hold “ctrl + alt” while moused over the button.
Editors
UE4 supplies several other editors for modifying and creating assets. These editors are automatically opened as a new tab when double clicking on an asset in the Content Browser. Some of the main editors include: Mesh Editor, Material Editor, Texture Editor, Blueprint Editor, Animation Editor, Particle Systems Editor.
Content Browser
The Content Browser (CB) shows all folders and assets belonging to the project. It is the interface for creating, importing, viewing, and opening to edit the project assets. The CB can: Create, Import, View, Organize, Modify, Rename, Move, Copy, and View References of assets.
Asset types are shown by a colour bar underneath each asset image and in the pop up window when hovering over the asset.
World Outliner
The “World Outliner” lists all actors included in the current level. In “Play” and “Simulate” modes it also lists all dynamically spawned actors. It includes a “Search Box” that will list actors including partial string matches.
Overview - Application Classes
A project will contain the following main core blueprint classes. To use your own custom version of these classes, go to “Project Settings > Maps & Modes > Default Modes” and set drop downs to your own defined classes:
Game Instance
The Game Instance (GI) class is instanced when the game application is started. The same GI instance stays persistently for the duration of the application running, and holds persistent data when setting up a game and switching between game modes (which cause Player Controllers, Game Mode, Game State, and Levels to be deleted and re-instanced, losing data).
The GI handles:
- Opening, closing, and showing the main menus and navigation between them.
- Starting and ending stand-alone and networked game sessions.
- Checking that the main game classes have initialised during game start-up.
Game Mode
The Game Mode (GM) class is only instanced on the server (hosting client). In a non-networked game the players machine is still seen as the server and the player as the hosting client upon it. A new GM is instanced each time a new map is loaded or a new network session started.
The GM handles networked game setup:
- Receives a login event from each client when their PLC is instanced (remote or local).
- Handshaking between server and clients for each step of game start-up.
Game State
The Game State (GS) is an engine defined class for holding application state data. Not sure how to use at the moment.
Player Control
A Player Controller (PLC) exists for each human player (one on each client machine). In a networked game, the server (host client) also instances a PLC handle (stub) for each remote client player that is used as the mailbox for communication between the server and remote clients.
The PLC (not including the server stubs) handles:
- All player UI input (player mouse and keyboard events).
- Passing camera control input to the players camera controller.
- Defining and interacting with the players character pawn and animation blueprint.
Player State
The Player State (PS) is an engine defined class for holding state data for this player.
Character
A Character blueprint (CHAR) (aka Pawn) exists for each character.
The CHAR handles:
- Defining the skeletal mesh to be used for this character and its animation blueprint.
- Receiving and handling player input from the PLC for the character to react to.
Character Anim
A Character Animation blueprint (CAN) instance exists for each CHAR.
The CAN handles:
- Running the animation for the given character.
- Defining the animation graph that specifies a characters animations and transitions.
- Being updated by and updating the CHAR when animations start and finish.
Camera Manager
A Camera Manager (CAM) instance exists for each PLC.
The CAM handles:
- Everything to do with Camera location, rotation, etc.
Level Blueprint
The Level Blueprint (BL) for the level/map that is currently loaded. An instance of the BL exists on each machine and is instanced when the level map is loaded on that machine. Handles passing any map specific data to the Game Instance and informing the Game Controller of any map trigger events (opened from Main Editor Toolbar > Blueprints > Open Level Blueprint).
The BL handles:
- Informing the GI when it has finished loading.
- Sending to the GI all start-up map data required by the player (eg start locations).
- Any level wide interactive actor event triggers.
Project Setup
Creating a Level
A project can have as many levels as required. New levels are added from the level editor, and can be created from blank or using a standard template (the blank level is completely empty, and the standard template level includes a small base geometry, a sky-box, and some general lighting).
To add a new level, select “File > New Level > Select desired level type”.
Required components of a new level include:
- A Ground or Floor (based on geometry or a landscape).
- A Camera.
- Light Sources.
- A “Lightmass Importance Volume” encompassing all actors in the level.
- A Skybox for exterior levels.
- A “Player Start” actor to give the start location for a player.
- Possibly one or more characters.
- Possibly a navigation element.
- General object actors to populate the level map.
Setting Input Mappings
You will also need to define how user player input is handled. UE4 defines 2 types of input, “Action Mappings” and “Axis Mappings”. Action mappings are used to define discrete one off events such as fire or jump and will allow functionality to be triggered when that button is pressed or released. Axis mappings are used to define continuous input such as movement or looking using the mouse and will continuously poll these inputs for any change in value each clock tick. To map (bind) a hardware input to an event:
- Open “Main Editor > Menu > Edit > Project Settings > Input”.
- To define a new action or axis mapping, press the “+” button next to “Action/Axis Mappings”, define a name for the input, and add a keyboard, mouse, or other input from the drop-down menu selection. More than one input can be defined for each mapping by pressing “[mapping name] > +”.
- Event nodes will now be available for these inputs (“RC > Input > Action/Axis Event”) in any “Player Controller” or “Character” blueprint event graphs. Whatever is connected to these input event nodes is what will execute when the event input is pressed (see blueprints section).
Notes:
- For axis mappings such as movement that are mapped to key presses, define 2 inputs for the axis. For example, add the “W” key and set its scale to “1” for forwards, then add a second key “S” and set its scale to -1 for backwards.
- Input mappings are also stored and editable in the TBD configuration file .
2 Likes