Learning Playmaker as an experienced programmer

[jamun99]

Are there any learning resources to learn Playmaker for someone who's totally comfortable programming?

And am I correct in thinking that there's some things that can be done faster/more efficiently in Playmaker compared to writing a script from scratch? One of the things I get concerned about with my projects is after a certain point you start accumulating tons and tons of scripts, I feel like a lot of these scripts could've been done in PM instead.

I'm an experienced programmer and can comfortably write anything in C# in Unity, and as I look YouTube and google I find all the Playmaker tutorials are targeted for complete beginners who don't know coding. I'm neither of these.

Is there any resource (preferably in video form as that what works best for me) that can teach me playmaker without wasting time explaining Unity/programming basics? There's some short intro videos here and there but nothing in depth it seems

[Thore]

PlayMaker does Finite State Machines. It's also a visual scripting tool, and states happen to be very useful to create game mechanics, but it's still a Finite State Machine tool. If you know your way with code, you can check adequately advanced resources on how to utilize them for your project: https://en.wikipedia.org/wiki/Finite-state_machine

The actions you place into states are scripts, just very modular ones, and you can write your own custom actions. Since many mechanics use the same few elements over and over again, it can be faster to make use of those modular scripts. Another benefit is that the actions make for a library of example code.

PlayMaker is also good for all those extra bells and whistles that could clutter up code; playing sounds, particles, screen shake in certain states and so on. Ultimately, it's a (slightly) different approach. It can also help to declutter scripts that are filled to the brim with if-statements.

But what it will not do is magically reduce your script components. You might shave off a few scripts, but then you create probably an equal amount of FSMs, if not more. For example, a decent PlayerMovement is one script. But easily half a dozen FSMs. But then, not all code of the FSM runs at the same time. Each is in some state and only executes the code in that state.

My impression is that PlayMaker willl be useful to most people except for good programmers. For those folks, it's rather a matter of taste.

[Broken Stylus]

I would not say you would go faster, but it provides much CLARITY, assuming you know how to avoid building graphs in a spaghetti fashion.

[jeanfabre]

Hi,

-  Your main gain with PlayMaker as a programmer are the finite state machine, and the global event mechanism.

- you also benefit from live debugging sessions, where are always seeing what is being processed, and you can pause, and rewind step by step, even with the values at the time of the step ( when debug flow is enabled).

- You'll gain massive speed in the common simple tasks, like a button to call something, or do something simple, you can get away with so many things with a few clicks... Unity event inspector interface isn't cutting it for many reasons, mainly when you want to add features, you end up with

- No recompilation needed, as you build with PlayMaker, you hit play without any recompilation penalty, it's huge actually, and everytime I have to edit a script, I curse now, and strongly consider making it in PlayMaker and only create scripts when it makes more sense.

It still will make more sense to create regular scripts, where complex algorithm is necessary, or the api is not covered by the official set of actions or the ecosystem set, but if the points above make sense to you, then, the ultimate power comes in creating custom actions for that, you then get the best of both world, you get regular c# script executed within the visual state machine.

 I am a senior developer making a lot of complex projects for client with hardcore, unmisseable deadlines ( like shows and presentation), and PlayMaker is the enabler for me to go fast, iterate fast, and be flexible, usually, I find that pur c# tends to enforce either oop or some hybrid mvc, and that's more difficult to mess with the last week of a big project, with PlayMaker, you go with a de facto more flexible approach, which makes a very significative difference when you need to break you beautifully crafted framework because specs have changed the last minute

Bye,

 Jean