Objektorientierte Programmierung

Überblick
Namespaces
Unity-Documentation Research
Funktionen
Parameter
Rückgabewerte

Namespaces
Namespace Vitruvius
class Student
public int semester;
Student myStudent;
Vitruvius.Student myStudent;
using Vitruvius;
Student myStudent;
Die Klasse Student ist nicht zu finden, weil sie sich im NS Vitruvius befindet
Explizite Defintion zur Nutzung der Bibiliothek
Using vereint den Namespace mit der aktuellen Ebene
? Ohne Namespace-Angabe nutzbar

Namespaces
Namespace Vitruvius
class Student
public int semester;
class Student
public int semester;
Student myStudent;
Vitruvius.Student myStudent2;
using Vitruvius;
Student myStudent2;
Bezieht sich auf die selbst definierte Klasse
Explizite Defintion zur Nutzung der Bibiliothek
Führt zu einer Unklarheit, welche Klasse gemeint ist

Verschachtelte Namespaces
Namespace Vitruvius
class Student
Vitruvius.GameDesign.Unternehmenspr uProjekt;
using Vitruvius.GameDesign;
using Vitruvius.ModeDesign;
Unternehmenspr uProjekt;
Kleidung jacke;
Explizite Variablen - Definition
Using vereint den Namespace mit der aktuellen Ebene
? Ohne Namespace-Angabe nutzbar
Namespace GameDesign
Namespace ModeDesign
class Unternehmenspr
class Kleidung

Namespaces
Namespace Vitruvius
Namespace ExterneBib
class Student
public int semester;
class Student
public int klassenStufe;
Student myStudent;
Vitruvius.Student myStudent;
ExterneBib.Student myStudent2;
using Vitruvius;
Student myStudent;
ExterneBib.Student myStudent2;
Explizite Definition
„using“ des häufig benutzten Namespaces
Explizit für selten benutzt
Die Klasse Student ist nicht zu finden

Documentation Research
Suchen nach Funktion oder Variable einer Klasse
? Unity-Documentation
? Internet-Research, Foren
Beispiel: UnityEngine.UI.Text.text

Google: „Unity Text“

Google: „Unity Text“
Class in UnityEngine.UI

Google: „Unity Text“
string value the Text displays
Click

Google: „Unity Text“
private Text text
private UnityEngine.UI.Text text
using UnityEngine.UI

Google: „Unity Text“
text.text = „Press space key“;
Text.fontSize = 48;
Text.alignment = TextAnchor.MiddleCenter;

MyFunction
void
public
{
Inhalt/ Befehle, jeweils mit Semikolon
}
( )
Protection
keyword
Rückgabewert
(void, wenn ohne Rückgabe)
Freiwählbarer Name
Eindeutig
Konvention: vorn Groß
Parameter
( ), wenn keine
KEIN SEMIKOLON!
Die Funktion wird beschrieben, aber nicht ausgeführt, kein Speicher vorbereitet ? Kein Befehl
;
Funktionsdefinition

void MyFunction( )
{
DoStuff();
DoSomeMoreStuff();
return;
ThisStuffWillNeverBeDone();
}
Return Funktion
Jede Funktion kann durch einen simplen (leeren) return-Befehl beendet werden.

Ein errechneter oder ausgelesener Wert wird als Ergebnis, wie eine Variable zurückgegeben
Komplexe Funktionen, die ein Ergebnis bereitstellen, einmal definieren und oft verwenden
Meist mit Parameter
void MyFunction( )
{
string aktuelleZeit = AktuelleZeitAlsText();
DateTime geburtsdatum;
int alter = ErrechneAlter( geburtsdatum );
}
string AktuelleZeitAlsText()
int ErrechneAlter
( DateTime gebDatum )
Rückgabewert

Definieren dieser Funktionsart
Datentyp des Rückgabewerts definieren
void MyFunction()
{
int eineZahl = GibFuenf( );
Debug.Log ( eineZahl ) ;
}
int GibFuenf( )
{
return 5;
}
Return-Befehl muss vorhanden sein!
Funktion mit Rückgabewert
Funktion wird zur Laufzeit durch Rückgabewert ersetzt.
{
int eineZahl = 5;
Debug.Log ( eineZahl ) ;
}

Definieren dieser Funktionsart
void GreifeGegnerAn()
{
schadenGesamt = grundwert + Waffenschaden();
schadenGesamt = schadenGesamt * SchadenMultiplikatorDurchBuff();
Gegner.ReceiveDamage( schadenGesamt );
}
int Waffenschaden( )
{
int schaden = waffe.schaden + waffe.verzauberung + staerke;
return schaden;
}
Funktion mit Rückgabewert
Datentyp
des Rückgabe-Werts
Rückgabe-
Befehl
void = leer
(Keine Rückgabe)

void MyFunction()
class MyComponent
public int myGlobalNumber;
public int myNumber;
myGlobalNumber = 10;
myNumber = 55; void MyFunction2()
public int myNumber;
myGlobalNumber = 1000;
myNumber = myNumber + 30;
Werden auf derselben Ebene wie Funktionen definiert
Erscheinen im Inspector
Werden bis zum Szenenwechsel gespeichert
Werden innerhalb von Funktionen definiert
Erscheinen NICHT im Inspector
Werden nach der Funktion gelöscht
Funktionsvariablen
Klassenvariablen
Funktionsvariablen

FunktionsVariablen
werden außerhalb von Funktionen definiert
Sie sind von allen Funktionen ansprechbar (intern und extern)
Sie werden mit der Instanz gespeichert
werden innerhalb einer Funktion definiert
Sie existieren nur innerhalb dieser Funktion
Inhalt/Speicher wird nach dem letzten Befehl wieder gelöscht
KlassenVariablen
Klassen/Funktionsvariablen

void MyFunction()
class MyComponent
public int myGlobalNumber = 55;
public int myNumber = 100000;
public string meinText = „BAM“ ;
Variablen können übrigens schon bei der Definition
mit Daten gefüllt werden
Funktionsvariablen

void SuperFunction()
class MyComponent
public int myGlobalNumber;
public int myNumber = 5;
myNumber = 1000;
myGlobalNumber = myGlobalNumber + myNumber;
void AwesomeFunction()
public int myNumber;
myGlobalNumber = myGlobalNumber + myNumber;
myGlobalNumber = 20;
SuperFunction();
AwesomeFunction();
SuperFunction();
Funktionsvariablen
Wie groß ist „myGlobalNumber“ am Ende?

Ermöglichen Funktionen ohne globale Variablen situationsspezifische Aufgaben zu erfüllen
Funktion: Parameter
Ohne Variablenbenutzung, kann die Funktion 2 nur immer gleiche Befehle ausführen
int x = Stuff();
MachEtwas();
EngineGo();
Hardware = x;
MachEtwas();
EngineGo();
int x = Stuff();
Funktion2();
Hardware = x;

Ermöglichen Funktionen ohne globale Variablen situationsspezifische Aufgaben zu erfüllen
Funktion: Parameter
Für die Variablennutzung müssten Variablen angelegt werden, die für jeden erreichbar sind
int x = Stuff();
globVar = x;
MachEtwas();
EngineGo();
Hardware = x;
MachEtwas();
EngineGo();
Hardware = globVar;
int x = Stuff();
globVar = x;
Funktion2();
globaleVariable

Ermöglichen Funktionen ohne globale Variablen situationsspezifische Aufgaben zu erfüllen
Funktion: Parameter
In anderen Objekten müssten zunächst Variablen gesetzt und dann die entsprechende Funktion ausgeführt werden
? Diese Variable müsste für jeden zugänglich sein
Char1
GreifeAn
Char2
erlSchaden
ErleideSchaden
Char1.erlittenerSchaden = schaden;
Char1.ErleideSchaden();

parameter
Ermöglichen Funktionen ohne globale Variablen situationsspezifische Aufgaben zu erfüllen
Funktion: Parameter
Der Wert der Variable wird übergeben, ohne zusätzlichen Befehl
Wie bei Funktionsvariablen, wird der Parameter nach der Funktion gelöscht.
int x = Stuff();
Funktion2(x);
MachEtwas();
EngineGo();
Hardware = parameter;

public int ergebnis = 55;
Erlauben es, Daten als Funktionsvariablen in die Funktion mitzugeben
void AddiereZuErgebnis( int myParameter )
{
ergebnis = ergebnis + myParameter ;
}
void MyFunction ( )
{
AddiereZuErgebnis( 526 );
}
Funktion: Parameter

Funktionsvariablen, die von außen gesetzt werden
public class Debug
{
public void Log( string text )
{
DisplayInConsole( text ) ;
}
}
Debug.Log( „Das ist ein Test“ );
Parameter

Ermöglichen das Auslagern eines Vorgangs in eine andere Funktion
Erhöhen so Lesbarkeit und senken die Veränderungszeit
public void ReceiveDamage( int damage )
{
text = damage;
text.animationStyle = 1; // normaler Schaden
text.StarteAnimation();
leben = leben – damage;
if( leben <= 0 )
{
leben = 0;
StarteTodesAnimation();
ZeigeGameOverScreen();
LassGegnerLachen();
}
}
Parameter

Ermöglichen das Auslagern eines Vorgangs in eine andere Funktion
Erhöhen so Lesbarkeit und senken die Veränderungszeit
public void ReceiveDamage( int damage )
{
text = damage;
text.animationStyle = 1; // normaler Schaden
text.StarteAnimation();
leben = leben – damage;
}
public void DisplayDamage( int damage)
{
text = damage;
text.animationStyle = 1; // normaler Schaden
text.StarteAnimation();
}
Parameter
public void ReceiveDamage( int damage )
{
DisplayDamage( damage );
leben = leben – damage;
}
public void DisplayDamage( int damage)
{
text = damage;
text.animationStyle = 1; // normaler Schaden
text.StarteAnimation();
}

Ermöglichen das Auslagern eines Vorgangs in eine andere Funktion
Parameter
public void ReceiveDamage( int damage )
{
DisplayDamage( damage );
leben = leben – damage;
if( leben <= 0 )
{
leben = 0;
StarteTodesAnimation();
ZeigeGameOverScreen();
LassGegnerLachen();
}
}

Ermöglichen das Auslagern eines Vorgangs in eine andere Funktion
Parameter
public void ReceiveDamage( int damage )
{
DisplayDamage( damage );
leben = leben – damage;
}
public void AffectDamageOnLive( int damage )
{
leben = leben – damage;
if( leben <= 0 )
{
leben = 0;
StarteTodesAnimation();
ZeigeGameOverScreen();
LassGegnerLachen();
}
}

Ermöglichen das Auslagern eines Vorgangs in eine andere Funktion
Parameter
public void ReceiveDamage( int damage )
{
DisplayDamage( damage );
AffectDamageOnLive( damage );
}
public void AffectDamageOnLive( int damage )
{
leben = leben – damage;
if( leben <= 0 )
{
leben = 0;
StarteTodesAnimation();
ZeigeGameOverScreen();
LassGegnerLachen();
}
}

Charakter
Leben
Greife an
Erleide Schaden
Char1
Leben
Greife an
Erleide Schaden
Char2
Leben
Greife an
Erleide Schaden
Char2
?
Charakter
?
Angriff
Angriff
Angriff

public int leben;
public int angriff;
public void GreifeAn( Character targetChar)
{
targetChar.ErleideSchaden( angriff );
}
public void ErleideSchaden( int schaden )
{
leben = leben – schaden;
}
Charakter
Leben
Greife an
Erleide Schaden
Charakter
?
Angriff
Objekt-Wechsel

public int leben;
public int angriff;
public int level;
public void GreifeAn( Character targetChar )
{ int schaden = (angriff * 4) * (level / 2);
targetChar.ErleideSchaden( schaden );
}
Charakter
Leben
Greife an
Erleide Schaden
Charakter
?
Angriff

Parameter + Rückgabewert
Charakter
Lebensp.
GreifeAn
Ausrüstung
Lebensp.
Schlafe

public void GreifeAn( Charakter gegner )
{
int schaden = waffe.staerke + waffe.verzauberung + staerke;
schaden = schaden * level;
int verteidigung = gegner.vert + gegner.schild.vert;
verteidigung = verteidigung * gegner.level;
schaden = schaden – verteidigung;
gegner.ReceiveDamage( schaden );
}
Parameter + Rückgabewert

public void GreifeAn( Charakter gegner )
{
int schaden = CalculatedDamage( );
int verteidigung = CalculatedDefense( gegner );
schaden = schaden – verteidigung;
gegner.ReceiveDamage( schaden );
}
Parameter + Rückgabewert