This project looks pretty cool, it sounds like its got some useful features too. I think flexibility is always a win.
OOP = object orientated programming. Basically the method of programming C# forces you into. Once you get used to OOP, it's actually really useful.
People just tend to use acronyms in general. It's just a quicker method of communicating. I don't think you're gonna escape it.
Quote: "That sentence doesn't make literary sense. It's like an Americanisation of the English language. I hate it when the Americans do that."
It makes perfect sense to me. You kinda need to learn C# to understand it's concepts. The 3D Buzz Hyperion tutorials I think as a great start for learning C#, because it actually helps you put visual imagery to the concept of C# and its object orientated programming.
To understand it clearly in to Dark Basic Pro terms:
I'm sure you've used user defined types in Dark Basic Pro, like this:
type Transform
x as float
y as float
z as float
endtype
type Object
number as integer
filename as string
rotation as transform
scale as transform
position as transform
endtype
And you might have: player.filename = "media/player.x"
or
player.position.x = 300 : player.position.y = 0 : player.position.z = -234
You might used those variables for updating something on the player object. Classes are similar, but can do a lot more and are more complex. You might use a class like you might an individual .dba file in Dark Basic. Have, "player.dba" or "control.dba", you could have "player.cs" or "control.cs" and contain classes of the same name. Imagine being able to stick functions inside of a user defined type. So you could have
player.lookat(30, 0 , 20)
Instead of having a function called 'lookat(player, 30, 0, 20)'
And because everything is an object, it can be declared like a variable.
To get a better idea, these 2 pieces of code do the same thing, one is C# (using Unity) and the other is Dark Basic Pro.
using UnityEngine;
using System.Collections;
public static class Scene
{
public static bool WithinDist(float dist, GameObject con1, GameObject con2)
{
var pos1 = con1.transform.position;
var pos2 = con2.transform.position;
var posx = pos1.x - pos2.x;
var posy = pos1.y - pos2.y;
var posz = pos1.z - pos2.z;
if (posx < dist && posx > -dist && posy < dist && posy > -dist && posz < dist && posz > -dist)
{
return true;
}
else
return false;
}
}function WithinDist(Object1, object2, distance)
check = 0
NPCx = Object position x(Object1)
NPCy = Object position y(Object1)
NPCz = object position z(Object1)
PlayerX = Object position x(Object2)
PlayerY = object position y(Object2)
PlayerZ = object position z(Object2)
Posx = NPCx - PlayerX
Posy = NPCy - PlayerY
Posz = NPCz - PlayerZ
dis = distance
if posx < dis and posx > -dis and posy < dis and posy > -dis and posz < dis and posz > -dis then check = 1
endfunction check
In DBP I have to use a variable to point to an object, but in C# I can just use that object like I would with a variable. So if I wanted to use that particular method. I could go into something like, "game.cs" and type:
if (Scene.WithinDist(Player, NPC, 15))
To create a condition if the Player and NPC are within 15 units of each other. Or in DBP:
if WithinDist(player, NPC, 15) = 1 then...
Of course you might have noticed my class was a 'public static class'. Which is: "you can access me anyhere, but there's only one of me". If you want to declare classes as you would with a variable, which you might do if you've got a class for storing character data and you've got more than one character, then just delete 'static'. You'd declare it as you would with an integer or string.
So I think using 'object orientated programming' can actually be very useful. At least I find it is.
Basically all that he's saying is, you can make your own classes for the entity.cs source to read. So you can extend its functionality.
