What is the difference between basic blueprints?

Hi Guys.

Sorry to bother with the most answered question in the world, I did a lot of research and read a lot of pages and still i’m not nailing the proper definition or usage for basic blueprints, so I need any advanced user that could response like in a boolean way, if my assumption about this is right, with my examples.

(Please do not share a link with documentation, literaly I already read tons of stuff)

ACTOR:
Use this for any object in the world that you want to spawn and be there just as an item.

Examples:

  • A Chair,
  • A dropped Gun,
  • A three,
  • A basket ball,
  • A bottle that could fall and break,
  • A button that could be pressed or stepped,
  • A box that the user could step

PAWN
Use this for any actor that can be possessed, but does not have a Humanoid (or skeleton) body.

Examples:

  • A car, that should move with the same keys as the user moves once the user is inside (WSAD)
  • A missile that the user could see where is traveling and probably move it, like in Unreal Tournament “Redentor” <3
  • A turret, that is not controlled by an human user, but is controlled by a AI controller.
  • A weapon grapped in the hand of the user (?) (not sure about this one)

CHARACTER
This will probably be your player, is the same as a pawn, but it has the hability to walk or support a skeleton, if you will use a Humanoid style mesh, this is what you need. If you need something alive probably works too.

Examples:

  • First person character. (You will need PlayerController here)
  • Third person character. (You will need PlayerController here)
  • A random dog that runs freely in the field and if he sees you, will bite you. (You will need AI Controller here)
  • A zombie enemy that can walks towards you. (You will need AI Controller here)

PLAYER CONTROLLER
For a simple gametest probably you don’t need this, but for a strong game I detected that this class is very important for the following reassons:

  • Here I will set all information that I want to persist even if the player dies and respawns (like points). If you save that inside a Character, variable will be erased when respawned.

  • Here I will add widgets to the viewPort, because if you set widgets inside CharacterBlueprint, that will cause for each instance of Character on screen, you will add the same widget over and over. Causing to see it multiple times.

  • Another reasson based on widgets, if you do AddWidgetToViewPort inside a character, if you are developing a multiplayer game, other players could add the widget to your viewport… (is this correct?)

  • I shal have only one Player controller active in my game, I could have multiple player controllers to customize several types of habilities per player, but once the game starts, only one player controller will be activated.

GAME MODE

Here you have logic that will exists in server only, NEVER ON CLIENT, so clients will ask to gamemode if they are allowed to do something.

I should use this for:

  • Retrieve a list of users and know if they are live or dead.
  • Know if I can respawn or shall I wait.

It’s correct, but I could also add the following information:

CHARACTER - is replicated, exists on server, exists on other clients, but character can change (polymorph, mount) - so its variables will be lost.

CONTROLLER - is replicated, exists on server, but doesn’t exist on other clients.

PLAYERSTATE - exists for each player, is replicated to everyone - can be used to store variables that you want others to see, like their names.

GAMEMODE - exists only on server.

GAMESTATE - exists everywhere, replicates everywhere. Can be used to replicate things like everyone’s Score.

GAMEINSTANCE - persistent singleton that exists your entire game, from start till finish. Isn’t replicated. Can be used to store links to umg widgets, save things between levels, etc.

WORLDSETTINGS - exists for each map. Can store a minimap in each map for example.

PLAYERSETTINGS - exists only in C++, saves settings into an .ini file.