What are you making? - TTLG Forums

WingedKagouti on 12/12/2016 at 11:38

Quote Posted by Renzatic

Okay, so what I'm doing in the line:

Vector3 spawnPosition = new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);

..is I'm first naming a new Vector3 instance, then defining it as a new instance within the class, complete with parameters and behaviors for it, right?

If that's the case, why wouldn't I tag it as a private instance under the class header? It seems it'd be a bit easier and neater to do it that way.

It depends on the actual situation and how you use that vector (or other variable). But it will usually be a bad idea.

A variable declared as part of the class will always take up memory as long as there's an instance of that class, while a variable declared inside a method will only have memory allocated while the method is executed. If it's the only method that uses that variable, there's no need to allocate memory to it on a permanent basis. And if another method uses it, you can't be certain that the second method won't be called while the first method is still executing. Which may result in the variable being overwritten with a completely new value before getting used for its purpose in the first method, potentially leading to very weird behaviour.

It's basically an inefficient and unsafe practice to use a class property as a disposable variable.

You may want to look into Stack vs Heap for more information about how C# handles memory.

Renzatic on 12/12/2016 at 19:04

Huh. I never considered memory usage or performance concerns.

Based on that, I guess it makes more sense to slap the Vector3 in the above example in its own method, rather than defining it at the top, and activating it in Start or Update. Since it's a part of an enemy spawning loop, that Vector3 only needs to be called up every 10 seconds or so. Keeping it running all the time is kind a waste, I guess. Better to call it up when it's needed, then drop it when it's not.

Man, there's a ton of little things I need to keep in mind while doing all this.

Nameless Voice on 12/12/2016 at 20:25

If it's only needed every ten seconds, then it's probably in an if block already, in which case it will only be allocated inside that block.

Having sections of code that you repeat in multiple places (e.g. startup and update) moved away into a separate function is always a good idea, but mostly because it's much easier to maintain that way.

Pyrian on 12/12/2016 at 20:55

Quote Posted by Renzatic

I'm not exactly sure when or where the "new" command should be used.

Let's back up a step and talk about references. If I write "Object myObj;", I don't actually GET an Object at all. I'm declaring a reference to an Object, and that reference starts off as "null", meaning that it's not referring to an actual Object. Now I can write "myObj = new Object()" and in this statement I'm creating a new instance of Object and assigning a reference to it in "myObj". I could further write "Object yourObj = myObj;". There's no "new" statement there. Instead what I have is two references to the SAME object. In practice, any changes to myObj will show up in yourObj and vice versa.

Funny thing about languages like C# is that they abstract away so much of the memory management that I do kind of wonder why they even bother keeping "new" around. It can only be used immediately before a constructor, and a constructor can only be used with "new", so it's almost cruft, though it does serve to mark when a call is constructing an object rather than referencing a local function (which might very well construct and return a new object - indeed one of my major beefs with Unity is that their documentation almost never specifies whether a Property returns a reference to in-engine data or a copy of said data).

Sorry.

The "new" keyword marks the fact that heap memory is being allocated for a new instance of a class - an object. In C# you're not supposed to have to worry about that memory being deallocated when you're done with it; the "garbage collector" will handle it. (Usually; you do need to make sure you don't have any references to it left when you're done.)

Quote Posted by Renzatic

Vector3 spawnPosition = new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);

Now for added confusion, Unity's Vector classes are "scalars" rather than normal objects, which means that everything I just wrote isn't even true for them, and instead they act more like "int"s. Using the exact same example as above, if you create a vector and assign another vector to it, changing the first vector WON'T change the second.

Given this behavior, using "new" with Vector classes seems wasteful, but as far as I can tell (and I've run tests) it's actually the most efficient way to assign a value to an uninitialized Vector. Like, seriously, "Vector3 MyVect = new Vector3(1.0f, 1.0f, 1.0f);" runs measurably faster than "Vector3 MyVect = Vector3.one". I'm guessing the compiler optimizes away the throwaway vector object but still follows the reference to a constant at runtime. (Actually that seems to be a theme with C#, or at least the version Unity is using, one of the best ways to optimize C# code seems to be to minimize reference usage, a technique that does very little in C++ or SQL.)

Neb on 12/12/2016 at 21:34

Foolishly, I bought a graphics tablet with no art skills and the intention of learning to paint textures. I kinda got side-tracked and painted my first still life from a photo reference.

Inline Image:

http://i.imgur.com/wRUcDpL.jpg

Over Christmas I'm going to mock up a little scene in UE4, and paint and model everything myself.

Yakoob on 12/12/2016 at 22:06

Go go Renz learning the intricacies of coding ;p I'd pitch in but the other guys pretty much covered your questions so far :] But on that...

Quote Posted by Renzatic

Huh. I never considered memory usage or performance concerns.

Modern Indie Dev summed up :P

Quote Posted by qolelis

In Firefox, only the image for the newsbits shows up, not the text (the PostIt notes were also empty, except the one from my spouse). In Chrome and Edge it works fine (I've noticed in other areas too how Firefox seems to be falling behind lately). I tried restarting Firefox in safe mode (with all extensions disabled), but then I got mostly a black screen with only the stamps visible.

forgot to respond - weird! I use Google Fonts so I wonder if that's the problem.

Renzatic on 12/12/2016 at 22:41

Quote Posted by Pyrian

Okay, here's the way I see it. Defining an object under the class header doesn't create the object, rather it, like you said, creates a reference, or a nickname to the object. Like if I were to implement two rigidbodies in a script, it'd read like...

Code:

public class GameController : MonoBehaviour
{
private Rigidbody = rb1;
private Rigidbody = rb2;

void Start ()
{
rb1 = GetComponent <Rigidbody>;
rb2 = GetComponent <Rigidbody>;
}
}

Now all this code will do is activate two rigidbody components on whatever I assign the script to. It doesn't do anything with them, just that they're in there, and can now be referenced and interacted with. Kinda useless, but good for illustration.

The way I take it as, the private marked objects under the class header do nothing other than inform the script that I'm GOING to have 2 Rigidbody component in there. They're private classes, only meant to be accessible to anything within the class they're grouped under, and that their names will be rb1 and rb2. It's in the Start method where I actually call up and assign the components, to be fired off as soon as the script executes (which in this case, would be at the start of the game).

This part's pretty easy to understand. It's basically C# for dipshits like me. Straightfoward, logical, and not at all complicated when you come to understand the syntax and reasoning behind it.

Now if you want to get complicated, this is my annotations for a loop within a loop I had to do to spawn enemy waves for the Space Shooter tutorial. I feel like I have about an 80% grasp of what it's doing exactly, though I'm still a bit iffy on some things.

Code:

IEnumerator SpawnWaves ()
{
yield return new WaitForSeconds (startWait);
while (true)
{
for (int i = 0; i < hazardCount; i++)
{
Vector3 spawnPosition = new Vector3 (Random.Range (-spawnValues.x, spawnValues.x),
spawnValues.y, spawnValues.z);
Quaternion spawnRotation = Quaternion.identity;
Instantiate (hazard, spawnPosition, spawnRotation);
yield return new WaitForSeconds (spawnWait);
}
yield return new WaitForSeconds (waveWait);

if (gameOver)
{
restartText.text = "Press 'R' To Restart";
restart = true;
break;
}
}
}

// The coroutine referenced in Start, named SpawnWaves.

// Yield return new WaitFoSeconds (startWait);

// Yield is a coroutine specific keyword (I believe), telling the following script
// to wait to execute until the conditions to the right are met. Here, it's pausing
// the script on the first start to give the player some breathing room before the game
// begins. Return tells it to stop execution until WaitForSeconds times down, as defined
// by the startWait integer opened to be defined in the editor.

// while (true)

// While is a keyword that starts a loop, the (True) is a conditional, which sets the
// condition for when the loop activates and deactivates. With the line above considered,
// once the startWait instance counts down to 0, the condition for the while loop becomes
// true, activating the script below.

// for (int i = 0; i < hazardCount; i++)

// The keyword "for" activates another loop within the coroutine, which runs FOR a set number of
// instructions as specified below.

// the rest of the code means interger i is currently 0, if i is less than the hazardCount instance
// (defined from within Unity), then add another (i++ means current interger count +1) until it
// reaches the number set in hazardCount.

// Vector3 spawnPosition = new Vector3 (Random.Range (-spawnValues.x, spawnValues.x), spawnValues.y, spawnValues.z);

// Sets up Vector3 instance named spawnPosition, which uses a random range generator to
// first define a wide, random area where to spawn the hazards within the game space on x
// (no farther left than the negative value, no farther right than the positive), and where
// to spawn them on positions y and z.

// Quaternion spawnRotation = Quaternion.identity;

// This line of code sets up random rotations for our hazards. A quaternion is a measurement
// for rotation on 4 axes, and the name for this quat instance is spawnRotation.

// Quaternion.identify locks the quat rotation to itself on a local axis, preventing an object
// from spinning out of your playing field. Here, it keeps the hazards tumbling about, but still
// moving downwards towards the player on the Z axis.

// Instantiate (hazard, spawnPosition, spawnRotation);

// Instantiate makes an instance of an object. Here, it creates an instance of hazard, and applies
// the position and rotation instances set in the lines above to the object. Or..
// Make (this object, randomly placed within these constraints, tumbling like this)

// yield return new WaitForSeconds (spawnWait);

// About the same as the code above. Basically "hold up, Wait for the number of seconds
// specified in the spawnWait (defined in Unity), then rerun the For loop.

// if (gameOver)
// {
// restartText.text = "Press 'R' To Restart";
// restart = true;
// break;
// }

// pretty self explanatory. if (conditions for gameOver are met)
// then display text string "Press R to restart"
// and the conditions for a restart are met (hitting R)
// then end the entire loop.

// Restarting begins it all again, rerunning the loop from scratch.

Renzatic on 12/12/2016 at 22:43

Quote Posted by Neb

Foolishly, I bought a graphics tablet with no art skills and the intention of learning to paint textures. I kinda got side-tracked and painted my first still life from a photo reference.

...

Over Christmas I'm going to mock up a little scene in UE4, and paint and model everything myself.

You painted that without any prior art experience? Damn, man. I'm jealous.

Pyrian on 12/12/2016 at 23:04

Looks pretty good.

Some people argue that you should never use an infinite loop with a break statement, but I think it simplifies things a lot in certain cases. This is not one of those cases. You should probably just put "while (!gameOver)" and remove the break statement altogether.

Speaking of removing things, the spawnRotation variable looks kind of pointless. You could just put Quaternion.identity directly into the Instatiate. BTW, Quaternion.identity really just means "not rotated" in this context. Meanwhile, your description states that you're getting random rotations out of this, which you're not, so... I'm not quite sure what you're doing, there. You could use something like "Quaternion.Euler(0.0f, 0.0f, Random.Range(-90.0f, 90.0f))"; again, that can be dropped straight into the Instantiate or replace the Quaternion.identity.

"yield return <expression>" is IMO best described as a special type of return statement. Return means that the function ends and execution returns to the calling function, and that's exactly what happens here. What makes coroutines with yield special is that the function starts up again roughly when the given expression indicates (Unity checks yield expressions once per frame), and the function starts up right where it left off. So the yield is both an exit point and a re-entry point. "WaitForSeconds" is a simple object with a specially defined interface that returns false until the specified amount of time has passed; you can easily write custom functions to directly control when coroutines stay dormant.

Renzatic on 12/12/2016 at 23:28

That Quaternion.Identify is probably the one thing that most stumped me when I was looking up keywords for reference.

The Unity page said about what you did.

"This quaternion corresponds to "no rotation" - the object is perfectly aligned with the world or parent axes."

I took it to mean that you always want the asteroids in the game to tumble towards the player from the top of the screen, entirely constrained to a 2D plane. You don't want the quaternion value to determine a starting angle beyond what's already been set. It shouldn't go towards or away from the camera on spawn, or at an XZ angle. You just want it to control the rotation of the object itself on its own local axes as moves downwards on Z on the global, which is what .Identify does here.

And yeah, keying Quaternion.Identify as spawnRotation does seem kinda pointless now that I'm starting to get more of a feel for it. I guess the tutorial wanted to nail home the idea that you could assign short names to any specific functions or groups of functions as a convenient shorthand.