I'd be more happy if Unity goes toward being more programmer-friendly. Fully code-only projects support, no need to waste a lot of time tinkering in that complex UI, etc...
Source: me. I don't work for Unity. Software engineer and use Unity for a lot of 'traditional development'.
You'd be surprised... there isn't a ton of documentation about it, but most of the engine is pretty well exposed for programmers.
You can punch into the rendering pipeline (down to immediate OpenGL mode if you need to), the compilation pipeline (recompiling on the fly or setting up a custom preprocessor), hook into the assemblies (for, say, an interactive interpreter run in the game), and hook into native binaries in unmanaged code. Naturally you can use any language that can compile into IL, so, you don't even have to use C# or Boo if you don't like it (though you'll want to take a look at Boo... UnityScript interpreter was written in it for a reason! yay, LISP MACROS with dynamic recompilation and loading!)
The editor will, in turn, handle a lot of things for you that are a waste of time to do normally, like visualizing things without having the game running (tweak a shader on the fly), handle all of the recompiling for you in the background, dyanmically load and unload resource files, let you easily browse the scene graph, let you write custom editors (for example, I wrote a converter to convert files of different types so that it happens when those files are added to your resources, instead of converting them on the fly at run-time or with some external half-assed console script), etc. Naturally, you can use your own editor if you're more comfortable (for example, I use Emacs and git and the mono profiler and debugger, rather than Unity and Unity Source Server and Monodevelop, and it works just fine, and I don't spend much time at all in the actual Unity Editor)
And the library itself has all kinds of things that you'd expect to make your life easy: screen graph manipulation, transforms and other 3D math, physics basics like raycasts and bounding box intersections, input handling, camera manipulations, sound and audio handling, event handlers and hooks on all kinds of stuff, color management, network handling and resource streaming, etc.
The tool also comes with a number of pre-written scripts (plus store, of course) to help you out with things you really should never have to re-invent and that a programmer probably doesn't even want to be bothered with, like a first-person or third person controller (complete with physics, camera work, input control and movement, etc.). Or you could go to the Store and pick up, say, a Mini-Map tool for $30 and have it working in about 5 minutes, which, to me, is very programmer friendly (who wants to spend their time reinventing a mini-map?!).
On top of that, your game will be almost entirely cross-platform automatically across a wide array of devices, AND will have native code for those devices for performance-heavy sections. You don't have to waste much time tracking down errors on all kinds of different platforms, which is also very programmer-friendly.
Couple problems: the docs aren't as good as they could be, the Mono version is still a ways back (~2.10ish), compute shaders aren't built-in to OSX yet (though you could do this yourself if you really wanted to), the community is geared around "scripting and drag/drop/click" so getting detailed assistance for very technical matters is sometimes difficult, etc.
All in all though, it's pretty amazing. Now, it will take you awhile to learn all that, to find out where everything is exposed, what you need to hook into, etc., but, once you do, it is actually very programmer friendly.
No idea. I'd hope so... learning it for me was a bit of a pain as all the relevant facts are split across the manual, the reference manual, the scripting manual, the forums, and answers website, some random websites, the google groups, the mono documentation and references and resources, etc.
I mean, it's not really that bad, just that some things that should be easy to look up are hard to find, and some things that are easy to look up and easy to find have to then be translated from "scripting and drag/drop/click" into actual code (particularly frustrating when you're just starting).
You seem knowledgeable so I figure I'd reply here since I keep getting mixed messages on this point: Is it easy to commit your Unity code in a VCS and have teammates work on it with you simultaneously? Some people say yes, some say no.
I have been using git for source control with no issues (haven't tested in a team environment however).
Not sure if you were aware of this already but theres a non-default setting in the Unity preferences for enabling "Version control support" that basically makes Unity save metadata in a text format instead of its standard binary format:
http://docs.unity3d.com/Documentation/Manual/ExternalVersion...
Personally I haven't had a problem using Git. I also haven't done that in a heavy team environment but I've heard good things in general since 3.0ish.
There are a couple things to be aware of regarding how you set up your .gitignore, and now, in 4.3, apparently meta files, but, it's pretty straight-forward, IMO.
I'd ask on the forums and get a current response... a lot of problems with the external VCS were things from back in 2.0ish land, which was quite awhile ago.
You really can't have multiple people working on the same prefabs or the same scene at once. The files are text, so you can merge them, but anything more than just minor changes will not work properly and someone will have to redo their work.
Working on code is fine and your normal guidelines apply to simultaneous work.
I have Unity projects with 3-5 teammates and we don't run into too many problems with scene/prefab merges. Normally each person is working on separate stuff so it would be rare for 2 people to need to touch the same prefab or scene.
If your scenes or prefabs are huge and it becomes a problem then you probably should think about redoing your architecture to keep your scenes and prefabs smaller.
>> I'd be more happy if Unity goes toward being more programmer-friendly. Fully code-only projects support, no need to waste a lot of time tinkering in that complex UI, etc...
I guess you are not really the target audience for Unity if full code-only projects are what you are after. I can't really disagree with you though. I've never used Unity, but I watched the 2D feature video and while I have to see the tooling looks absolutely fantastic, very flexible and powerful, I couldn't shake the feeling that I'd be much more comfortable just doing all that stuff using a code-only IDE and good sprite/animation libraries. There's just so many buttons, sliders, menu's, dialogs and other thingamajigs in that user interface :-S. And then somewhere deep down there you also still have your code tied to all of it. I have to say the video was confusing as anything to me.
I did a fair bit of work in Unity earlier this year. The Unity UI makes a lot more sense once you realise it is built by the objects in the scene. You can code entirely in Visual Studio and just use the Unity window to view the results. But you can also start extending your entities with custom controls and debugging panes and build your own graphical tools. Unity basically makes it incredibly easy to whip up graphical debugging and editing tools for the times when that makes sense but doesn't prevent you from working in whatever IDE you are comfortable with.
For example, I worked on a tool for procedurally deforming enemy meshes to prevent the whole 'attack of the clones' vibe that many games fall into. Rather than use print statements to figure out what was happening in the code, I used Gizmos [1] to draw various important coordinates on whichever mesh section was under the mouse and added handles to let me interactively modify the inputs to the algorithm. I also added debugging output on the side panel that updated in real time as I deformed meshes. In Unity its trivial to build those kinds of custom tools. Debugging the same problems with the usual print statements and compile/restart cycle would have been much slower.
I take issue with a lot of the other design decisions in Unity, but the UI is a massive improvement over most work-flows once you learn how to customise it.
They support all of that. At my last job, we made a huge 3d facebook game written entirely in c#. We compiled independent libraries, copied them into Assets/Plugins and ran the game using the UI. Everything was procedurally generated because, back then, we had some serious issues with missing texture references. The best part is, because compiling c# libraries has nothing to do with Unity (other than including the Unity libs), it can be done using a variety of methods and IDEs.
We started the project without knowing if the compile to flash target would be done when we needed it, so we hedged our bets and kept unity as separate from the game code as possible.
The downside is step through debugging can only be done with UnityVS or MonoDevelop and you don't get the flexibility of using "that complex UI", which I rather enjoyed using as a REPL. Oh, going from code change to compiled to seeing the game on the screen was sloooooooow.
Unity has probably one of the best UIs I've seen. I also use Blender, so I know how complex UI can get. But with Unity, they encapsulate everything into game objects and components. That's it. It really can't get much easier. Even their animation system is sensible and fits nicely with the overall architecture. I was up and running within a few days. In a week I had what could arguably be considered a working game. Watch a few youtube videos and you'll have working cloth, triggers, and particles.
As a programmer, I still have not reached the point of feeling that I lacked control over the game and engine. And I doubt that easily happens with indie developers, as Unity is incredibly well-equipped to deal with small-to-medium sized games.
You'd be throwing out the differentiating strength of Unity though. The whole point is that non technical designers can put stuff together incredibly quickly.
It feels at times a bit dirty to give up control and do things "The Unity Way" but the payoff in productivity from non-programmers on the team makes it worth it.
It's targeted at scripters not professional programmers though. I think in their paradigm professional programmers are focused on creating components for the store and everyone else (level designers, gameplay scripters etc.) just consume components along with some scripting.
As a professional game developer, I can tell you that using Unity was the least pleasant experience I have had (to put it mildly). I don't see it being a tolerable experience for anything more than simplistic games (like a typical casual game). If you were thinking of something like NFS or Unreal or Dues Ex for mobile, it is very painful and you are better off using a decent engine in its place.
Funnily enough, Deus Ex: The Fall for mobile is made with Unity, and the team that built it said it was much, much better experience than the engines they've used in the past. So YMMV.
I've worked on a sports game, a racing game, a 3D virtual world with a lot of mini-games, a flying arcade style game, simple casual games and maybe a few I can't recall. This was just those which I was involved in while using Unity. I can't speak for my ex-employer but I will not choose Unity in a hurry any time soon after that.
I lost at least 20% of my working hours trying to get the project to work again or waiting for it to sync to asset server and would always be half hopeful and half terrified at the time of any updates to Unity. "Did they fix the unresponsive 'cancel' button on the assert server update action?", "Did they make it more stable?", "OMG! Another update! Will my entire project re-import again?" were the kind of things that used to run in my mind.
I'd have to hear strong positive reviews from those I trust to even try Unity again (assuming they back them with good reasons).
Unity is really nice, and if you plan for it, can scale pretty well. It's much more flexible, so it's easier to shoot yourself in the foot, while other engines are less flexible, which can be advantageous at time. Additionally, it's difficult to get it to shine at the higher end in the ways that other engines do. IMO, I think this is more of a problem of bad defaults than any significant lack of features. But the top tier games released by most of the other engine developers have really forced them to tweak the engine in ways that Unity has not.
I doubt that would happen, since the Unity editor is what sets it apart from a plain IDE, especially for 3D designers looking to build games. However, they likely have plans to beef up things on the coding front instead of just relying on third-party tools.
Yep, Futile is great. It's not quite as simple or flexible as a pure 2D engine (like PyGame/SDL), but it lets you make 2D games while taking advantage of Unity's cross-platform engine, GPU acceleration, and any other features you layer on top of it.
You'd be surprised... there isn't a ton of documentation about it, but most of the engine is pretty well exposed for programmers.
You can punch into the rendering pipeline (down to immediate OpenGL mode if you need to), the compilation pipeline (recompiling on the fly or setting up a custom preprocessor), hook into the assemblies (for, say, an interactive interpreter run in the game), and hook into native binaries in unmanaged code. Naturally you can use any language that can compile into IL, so, you don't even have to use C# or Boo if you don't like it (though you'll want to take a look at Boo... UnityScript interpreter was written in it for a reason! yay, LISP MACROS with dynamic recompilation and loading!)
The editor will, in turn, handle a lot of things for you that are a waste of time to do normally, like visualizing things without having the game running (tweak a shader on the fly), handle all of the recompiling for you in the background, dyanmically load and unload resource files, let you easily browse the scene graph, let you write custom editors (for example, I wrote a converter to convert files of different types so that it happens when those files are added to your resources, instead of converting them on the fly at run-time or with some external half-assed console script), etc. Naturally, you can use your own editor if you're more comfortable (for example, I use Emacs and git and the mono profiler and debugger, rather than Unity and Unity Source Server and Monodevelop, and it works just fine, and I don't spend much time at all in the actual Unity Editor)
And the library itself has all kinds of things that you'd expect to make your life easy: screen graph manipulation, transforms and other 3D math, physics basics like raycasts and bounding box intersections, input handling, camera manipulations, sound and audio handling, event handlers and hooks on all kinds of stuff, color management, network handling and resource streaming, etc.
The tool also comes with a number of pre-written scripts (plus store, of course) to help you out with things you really should never have to re-invent and that a programmer probably doesn't even want to be bothered with, like a first-person or third person controller (complete with physics, camera work, input control and movement, etc.). Or you could go to the Store and pick up, say, a Mini-Map tool for $30 and have it working in about 5 minutes, which, to me, is very programmer friendly (who wants to spend their time reinventing a mini-map?!).
On top of that, your game will be almost entirely cross-platform automatically across a wide array of devices, AND will have native code for those devices for performance-heavy sections. You don't have to waste much time tracking down errors on all kinds of different platforms, which is also very programmer-friendly.
Couple problems: the docs aren't as good as they could be, the Mono version is still a ways back (~2.10ish), compute shaders aren't built-in to OSX yet (though you could do this yourself if you really wanted to), the community is geared around "scripting and drag/drop/click" so getting detailed assistance for very technical matters is sometimes difficult, etc.
All in all though, it's pretty amazing. Now, it will take you awhile to learn all that, to find out where everything is exposed, what you need to hook into, etc., but, once you do, it is actually very programmer friendly.