I'd say it's more powerful and has better performance, however, the drawback of the free version is that shader use is limited (but you are still free to use it commercially) and the Pro version is expensive. There are couple of other limitations, but the only to affect me is the shaders.
I would say learning C# is more complicated than DBP (you also have the option to use Java scripting as well in Unity3D), DBP forces you into procedural programming, whilst Unity3D will force you into object orientated programming, personally I find OOP more flexible, whilst procedural is more straight forward.
In terms of difficulty, once I got my head around OOP and how C# works I wouldn't say it's that much more difficult. It's pretty much a more complicated version of FPSC with a lot more flexibility. You code everything via scripts, the engine is already there and you've got an editor to put everything together.
Unity3D is also a lot more modular and it can be integrated with Visual Studio. You can apply scripts like they're a shader in a 3D modelling program, you can edit variables inside of the editor and if you cater your scripts to work in that kind of environment you essentially cut out work. Once it's coded you don't have to code more, you can jump into the editor and drag and drop entities to build your game and the editor has the ability to compile to multiple platforms such as Mac, PC, Linux (newly added), Flash, Unity webplayer, XBox 360 (with license), PS3 (with license), Android and iOS. Also, there's a whole asset store of addons, some to improve editor functionality, some to help improve how you code the game. One of the addons I used is called Playmaker, which offers visual scripting, it's limited, but combined with my own scripting, it's powerful.
I'll provide you with an example.
Let's say I want each character 'object' to have a series of stats, I can just drag and drop a script called "stats.cs" and it'll apply the logic to any of them I attach it to. Also, if I coded an AI script I could just drag and drop it onto an object in the editor and it'll have that AI.
With the 'stats.cs' script, I can view its variables inside of the editor and make changes for each character object I use it on:
In this you can see the player's name defined, their level and the skills they currently know as well as a few more things. In code that script looks like this:
using UnityEngine;
using System.Collections;
public class PlayerStats : MonoBehaviour
{
[System.Serializable]
public class Animations
{
public string Idle;
public string Attack1;
public string Attack2;
public string Attack3;
public string Cast;
public string Use;
}
[System.Serializable]
public class Stats
{
public string Skill1;
public string Skill2;
public float HP;
public float MaxHP;
public float MP;
public float MaxMP;
public float ATB;
public float MaxATB;
public float Speed;
public float STR;
public float VIT;
public float DEL;
public float MND;
public float DEX;
public float AGI;
public bool Curse;
public bool Nerve;
public bool Blood;
public bool Frantic;
public bool Fear;
public bool Empowerment;
public bool Lucid;
}
[System.Serializable]
public class Skills
{
public string Name;
public bool Got;
}
[System.Serializable]
public class Items
{
public string Name;
public int Quantity;
}
public string Name;
public float Level;
public Skills[] Skill1;
public Skills[] Skill2;
public Items[] Item;
public float HP;
public Stats stats;
public Animations animation;
private GameObject Database;
private PathDatabase Path;
public string path;
// Use this for initialization
void Start()
{
Database = GameObject.FindGameObjectWithTag("Database");
Path = Database.GetComponent<PathDatabase>();
UpdateStats();
stats.HP = stats.MaxHP;
stats.MP = stats.MaxMP;
}
void UpdateStats()
{
for (int x = 0; x < Path.path.Length; x++)
{
if (path == Path.path[x].Name)
{
stats.MaxHP = 100 + Path.path[x].HP * Level;
stats.MaxMP = 100 + Path.path[x].MP * Level;
stats.MaxATB = Path.path[x].ATB;
stats.Speed = Path.path[x].Speed;
stats.Skill1 = Path.path[x].Skill1;
stats.Skill2 = Path.path[x].Skill2;
stats.STR = 5 + Path.path[x].STR * Level;
stats.VIT = 5 + Path.path[x].VIT * Level;
stats.DEL = 5 + Path.path[x].DEL * Level;
stats.DEX = 5 + Path.path[x].DEX * Level;
stats.MND = 5 + Path.path[x].MND * Level;
stats.AGI = 5 + Path.path[x].AGI * Level;
}
}
}
// Update is called once per frame
void Update()
{
UpdateStats();
HP = stats.MaxHP;
}
}
The code in there is fairly basic, it'll look confusing to somebody unfamiliar with C# (or Unity for that matter), but I'm sure you can work out what most of it means, with some differences, like public and private variables. The difference is easy to explain, "public" means it can be accessed outside of this class whereas "private" means it can only be accessed inside of the class. This means all of your public variables will appear in the editor (unless you tell it not to), whereas your private ones won't.
If you used user defined types a lot in DBP, it might be easier for you to start using object orientated programming, essentially a 'class' (which makes up for how OOP works) is just like a UDT, but it can do a lot more, including storing functions. The thing I always loved about DBP was that it was always straight forward and it became quicker to start getting results, hence I still use it to make prototypes of code I want to use elsewhere. What I love about Unity on the other hand is that it makes the rest of the development process easier.
For instance, I actually recorded a video to show Unity3D's modular approach:
[yotube]NJ8wxR5cD5s[/youtube]
As for tuts, I found 3D Buzz to be fantastic.
For getting started with C# (and using the game dev frame of mind) here's a fantastic one on 3D Buzz.
Hyperion Text Adventure Tutorial C# (really helped me visualise OOP)
And for Unity3D, I started with this one:
3rd Perosn Character Controller
Which leads nicely into this one
Unity 3D Platformer
Of course, it all comes down to what you're looking for in a program or personal preference. Awesome games are still coming out of the DBPro community.
