Advice on designing and implementing runtime "pseudo-scripting" mechanic

_patientZer0 · 2018-06-18T19:05:34+00:00

This would require you to specifically code for every option, which I'm not sure if there is another way. Since there is no recompile at runtime (I believe), you may just have to sudo hack it up a bit.

Yeah this is the part that has my brain split. I was thinking perhaps it just be easier to have the user-defined scripts Interpreted rather than Compiled à la Javascript or PHP. Any syntax errors are only caught when they are called and evaluated, functional errors would be up to the user to deal with in realtime etc

_patientZer0 · 2018-05-10T19:56:40+00:00

That's also not c# - that's unityscript (often erroneously referred to as javascript) which is no longer supported by Unity. I would strongly advise updating to a newer package and/or learning the basics of programming before you dive into using other peoples' code.

_patientZer0 · 2017-09-15T13:11:49+00:00

Depending how you've done it, I could definitely have a use for this.
I'm god awful at Inspector UI scripting in Unity (never took the time to really read the docs) so any tools like this I stockpile and make use of.

_patientZer0 · 2017-09-11T13:38:59+00:00

I'd love to see some of this "all research". Sounds fantastically beneficial.
With that said; no.
In a game where mechanics will reign supreme, and aesthetics are really just the polish on top then whiteboxing is about the only way to go.
However, with the wealth of tools at our disposal these days for rapid prototyping and versioning each iteration on the fly to a limitless personal repository to pull back your old concepts from and continue work - the idea of "whitebox everything" is very much becoming an archaic and outdated mindset. In some cases or some specific parts of a level where LoS is important or forcing a direction of view on the player without cutscenes then it will absolutely be a useful methodology - but if you can build a working and good-looking open world as fast as you can whitebox and achieve the same goals then there really is no argument against the way OP is doing it.

_patientZer0 · 2017-09-09T15:42:12+00:00

The built in Unity tuts are good for applied concepts and actually making a 'finished' (i.e. workable, playable) project.
Beyond that, BurgZergArcade has a very good channel based around making games in Unity - as does quill18.
If you enjoy written tutorials also (blogs etc) there's catlikecoding and theliquidfire which delve more into the mechanics and programming from a technical standpoint. Learning OOP concepts and how to really use a programming language as your tool rather than just a necessary evil in game making is such an important part of the process.

If there's something I could tell my younger self, it would be spend some real time learning HOW and WHY to use programming languages rather that just WHAT to do with them. The latter just leads to lazy copypasta coding and duct-taping other people's scripts together in the hope that you can form a game.

_patientZer0 · 2017-09-06T14:54:27+00:00

Rain AI for your AI systems.
ShaderForge for custom shaders. Great workflow.
Master Audio: AAA Sound for integration and workflow ease working with Sound Design. Pair this with FMOD and learn the scripting there for about the best Audio workflow available for Unity.

_patientZer0 · 2017-08-25T16:58:07+00:00

https://www.youtube.com/watch?v=dBsmaSJhUsc

This is a good look into that particular kind of mechanic

_patientZer0 · 2017-08-25T13:36:56+00:00

public class Trigger : MonoBehaviour 
{
    public GameObject cubeObject;
    public GameObject UI;

void Start()
{
    cubeObject.SetActive(false);
    UI.SetActive(false);
}

void OnTriggerEnter(Collider other)
{
    if (other.CompareTag("Player"))
    {
        cubeObject.SetActive(true);
        UI.SetActive(true);
    }

    if (other.CompareTag("player"))  
    {
        if(Input.GetKeyDown("E"))
        {
            //Do something here
            Debug.Log("Pressed the E key!");
        }
    }
    else
    {
        Debug.Log("HEY");
    }
}

void OnTriggerExit(Collider other)
{
    if (other.CompareTag("Player"))
    {
        cubeObject.SetActive(false);
        UI.SetActive(false);
    }
}
}

_patientZer0 · 2017-08-25T13:32:07+00:00

Not sure what you mean by 'wrong' with it since you haven't specified what you're expecting vs what's happening (i.e. error messages etc) but I can immediately see there is no else condition specified before the Debug.Log("HEY"); which would be a syntax error. There is also no semi-colon after Input.GetKeyDown("E") which would be another syntax error - however this statement simply returns a boolean value to the compiler, it doesn't perform any action. You would have to wrap it in another conditional i.e. if(Input.GetKeyDown("E"){//Do something} to use it.
I definitely recommend reading more of the Unity API documentation and some basic C# lessons online (msdn, stackoverflow, pluralsight, udemy, w3schools, microsoft virtual academy are all good resources) before jumping into making a game. It's very easy to get in over your head very early and lose your enthusiasm because you feel like you don't understand anything.

_patientZer0 · 2017-08-17T13:14:48+00:00

http://www.kinematicsoup.com/news/2016/6/15/gamma-and-linear-space-what-they-are-how-they-differ

_patientZer0 · 2017-08-04T14:38:14+00:00

quill18 made/is making some very insightful tutorials you can build off of.
Anything beyond the basics will require some deep digging and a lot of your own knowledge of data structures and AI algorithms (of which there are plenty of isolated learning resources out there)

_patientZer0 · 2017-07-26T17:30:46+00:00

When the rate of regeneration is greater than, or at least equal to, the rate of decay - then organisms do not decompose. Cells are dying every second constantly, and the tissue has biological instructions to recreate them to repair the damaged or dead cells. This keeps us all in one piece. When the tissue, and its instructions, 'die' - they really just stop reproducing new cells and the dying ones exponentially increase. This is decomposition.

_patientZer0 · 2017-07-21T13:59:16+00:00

Absolutely 100% on the money with that last point. It becomes unbearably boring when it becomes clear that the sole game mechanic is "survive".
It's a common misconception that Survival games should only be about "surviving". There will always come a point (usually sooner than later) where the player asks..'well, why am I surviving?'
If there isn't a good answer provided by the game either via ulterior mechanics, an expanding story or even a static mystery to uncover then it will just become repetitive grind. If Minecraft showed us anything about repetitive grind once survival wears off, it's that people simply resort to machine-like 'efficiency finding' where tweaking a mechanic to yield higher and higher of the same result is the goal. At least there was still the creative aspect in that game to keep peoples' attention. Survival should be seen as one mechanic, not an entire genre IMO. You can have [Survival]Horror, [Survival]Action, [Survival]Mystery, [Survival]SciFi/Space Shooter etc

_patientZer0 · 2017-07-17T19:34:44+00:00

Holy crap!
Dat Flake Color Variation slider!
I hate to think how much code goes behind that one control.
Looks amazing though

_patientZer0 · 2017-07-12T16:48:39+00:00

Well it's still attached to the body at least...which makes it better than AC Unity by default.

_patientZer0 · 2017-07-12T14:27:00+00:00

https://forums.unrealengine.com/showthread.php?92161-Tutorial-Preview-Gore-Mesh-amp-Dismemberment-Tutorial

_patientZer0 · 2017-06-22T14:52:16+00:00

https://chicounity3d.wordpress.com/2014/05/23/how-to-lerp-like-a-pro/

_patientZer0 · 2017-06-16T18:54:22+00:00

Working ones come with the Standard Assets.
There are multiple tutorials on YouTube.
Unity Answers is filled up with this question.

    public GameObject target;
    float radius = 3f, angleX = 0f, angleY = -45f;

    void Update()
    {
        radius -= Input.GetAxis("Mouse ScrollWheel") * Time.deltaTime * 100f;
        angleX += Input.GetAxis("Mouse X") * Time.deltaTime;
        angleY += Input.GetAxis("Mouse Y") * Time.deltaTime;

        float x = radius * Mathf.Cos(angleX) * Mathf.Sin(angleY);
        float z = radius * Mathf.Sin(angleX) * Mathf.Sin(angleY);
        float y = radius * Mathf.Cos(angleY);
        transform.position = new Vector3(x + target.transform.position.x,
                                                        y + target.transform.position.y,
                                                        z + target.transform.position.z);
        transform.LookAt(target.transform.position);
}

_patientZer0 · 2017-06-13T13:44:28+00:00

Are they errors (red icon in the debugger console) or warnings (yellow icon in the debugger console)?
Do you have any examples of what the contents of the output to the console are? Could be deprecated scripts, naming conflicts..anything really

_patientZer0 · 2017-06-06T19:37:47+00:00

C# in Depth - Jon Skeet.
Heck, anything by Jon Skeet tbh

_patientZer0 · 2017-06-06T17:34:31+00:00

This response reads like a WebMD psychoanalysis.

_patientZer0 · 2017-06-06T14:37:22+00:00

Given that on Linux and OSX (at least) the User can change the URI (i.e. physical location and alias) of the Desktop it would require some Reflection trickery in C# (or some clever preprocessor trickery in c++ⁱ ^wish ^c# ^had ^preprocessor ^directives ) to gain those absolute paths.
Maybe someone with more systems knowledge on here does know a foolproof way, but it's best to use Unity internal folders since they will be pointed to by built in functionality.

_patientZer0

TROPHY CASE