unity tipps

Auf dieser Seite beschäftige ich mich mit Scriptbeispielen.
Siehe dazu auch die Scripting Referenzen von Unity.

Zur Startseite meiner Unity Tipps.

Vector3, der Typ für Position, Rotation, Bewegung
transform, die Positionierung im Raum
time Framerate oder Zeit
Zugriff auf Components und Game Objects
Steuerung Beispiele

Vector3()

Vector3(0, 1, 0) gibt 3 Werte für x, y, z Koordinate zurück. Diese Werte werden in der Regel für Positionen oder Winkel eingesetzt. Außerdem bietet Vector3() einige nützliche Funktionen für verschiedene Bewegungsabläufe.

Vector3() benutzt man im Zusammenhang mit position z.B.:
transform.position = Vector3(0, 20, 0);
Hier wird das Object auf Position x=0, y=20, z =0 gesetzt.

Kurzschreibweisen:

transform.position += Vector3.forward;
entspricht
transform.position += Vector3(0,0,1);
Die Funktion bewegt das Objekt 1 Meter nach vorne von der derzeitigen Position aus gesehen. Vorne ist die Z- Achse.

Kurzschreibweisen für die jeweiligen Achsen:

x Vector3.right
y Vector3.up
z Vector3.forward

Vector3 Funktionen

Lerp

Von bis, Bewegung von einem Transformobjekt zu einem anderen innerhalb einer Sekunde Time.time
oder in einer fließenden Bewegung time.deltaTime * 0.5 .
start und ziel lassen sich im Inspector definieren, indem man jeweils ein Objekt auf die Variable zieht. Das kann beim start auch das Objekt sein, dem das Skript zugewiesen wurde.

var start : Transform;
var end : Transform;

function Update () {
transform.position = Vector3.Lerp(start.position, end.position, Time.deltaTime);
}

MoveTowards

MoveTowards funktioniert ganz ähnlich wie Lerp, allerdings wird hier die Geschwindigkeit beibehalten, während bei Lerp das Objekt zum Ziel hin immer langsamer wird. Ein negativer Wert bewegt das Objekt vom Ziel weg.

var zielDingsbums : Transform;

function Update ()
{
transform.position = Vector3.MoveTowards (transform.position,zielDingsbums.position, 0.2);
}

Distance Hier noch ein weiteres Beispiel, wobei das Objekt sich erst auf das Ziel zubewegt, wenn es in der Nähe ist.

var actor:Transform;

function Update()
{
var dist = Vector3.Distance(actor.position, transform.position);
if(dist < 50)
{
transform.position = Vector3.MoveTowards (transform.position, actor.position, 0.05);
transform.LookAt(actor);
}
}

Im folgenden Script haben wir einen Feind der auf den Player schießt, sofern beide sich zu Nahe kommen. Siehe hierzu auch den Tipp Shoot. Dort wird erklärt, was man noch braucht, damit das Script funktioniert.

var actor;
var bullet:Rigidbody;
var bulletSpeed = 20;
var fireRate = 2;
private var nextFire = 0.0;

function Start()
{
 actor = GameObject.Find("Cube2").transform;
}

function Update()
{
	var dist = Vector3.Distance(actor.position, transform.position);

	if(dist < 50)
	{
		transform.position = Vector3.MoveTowards (transform.position, actor.position, 0.05);
		transform.LookAt(actor);

		if (Time.time > nextFire) 
		{
			nextFire = Time.time + fireRate;
			shoot();
		}
	}
}

Slerp

Auch hier wird ein Objekt von einer zu anderen Position bewegt, jedoch geschieht das hier in Form eines Bogens.

var riseObj: Transform;
var setObj : Transform;

function Update () {
// Die Mitte des Bogens oder die Mitte zwischen den beiden Objekten, center:Vector3
var center:Vector3 = (riseObj.position + setObj.position) * 0.5;
// vertikal (0,1,0) Das Zentrum wird angehoben, spiele mit den Werten
center -= Vector3(0,0.5,2);

// Über dem Bogen relativ zum Zentrum interpolieren
var riseRelCenter = riseObj.position - center;
var setRelCenter = setObj.position - center;
transform.position = Vector3.Slerp(riseRelCenter, setRelCenter, Time.time*0.1);
transform.position += center;
}

Hier ein weiteres Beispiel für eine Slerp Funktion. Über die beiden offset Variablen kann man bestimmen, wie weit sich das Objekt vom derzeitigen Standpunkt bewegen soll.

var xoffset = -100;
var zoffset = 0;

var endPos : Vector3;
var startPos : Vector3;

function Start(){
startPos = transform.position;
endPos = startPos + Vector3(xoffset,0,zoffset);
}

function Update () {
// Mitte der Strecke
var center:Vector3 = (startPos + endPos) * 0.5;
// Vertikaler Bogen, auch andere Werte möglich
center -= Vector3(0,1,0);

// Interpolate over the arc relative to center
var riseRelCenter = startPos - center;
var setRelCenter = endPos - center;
transform.position = Vector3.Slerp(riseRelCenter, setRelCenter, Time.time*0.1);
transform.position += center;
}

Class Functions

Lerp	Linearly interpolates between two vectors.
Slerp	Spherically interpolates between two vectors.
OrthoNormalize	Makes vectors normalized and orthogonal to each other.
MoveTowards	Moves a point current towards target.
RotateTowards	Rotates a vector current towards target.
SmoothDamp	Gradually changes a vector towards a desired goal over time.
Scale	Multiplies two vectors component-wise.
Cross	Cross Product of two vectors.
Reflect	Reflects the vector along the normal.
Dot	Dot Product of two vectors.
Project	Projects a vector onto another vector.
Angle	Returns the angle in degrees between from and to.
Distance	Returns the distance between a and b.
ClampMagnitude	Returns a copy of vector with its magnitude clamped to maxLength.
Min	Returns a vector that is made from the smallest components of two vectors.
Max	Returns a vector that is made from the largest components of two vectors.
operator +	Adds two vectors.
operator -	Subtracts one vector from another.
operator *	Multiplies a vector by a number.
operator /	Divides a vector by a number.
operator ==	Returns true if the vectors are equal.
operator !=	Returns true if vectors different.

transform

position	The position of the transform in world space.
localPosition	Position of the transform relative to the parent transform.
eulerAngles	The rotation as Euler angles in degrees.
localEulerAngles	The rotation as Euler angles in degrees relative to the parent transform's rotation.
right	The red axis of the transform in world space.
up	The green axis of the transform in world space.
forward	The blue axis of the transform in world space.
rotation	The rotation of the transform in world space stored as a Quaternion.
localRotation	The rotation of the transform relative to the parent transform's rotation.
localScale	The scale of the transform relative to the parent.
parent	The parent of the transform.
worldToLocalMatrix	Matrix that transforms a point from world space into local space (Read Only).
localToWorldMatrix	Matrix that transforms a point from local space into world space (Read Only).
root	Returns the topmost transform in the hierarchy.
childCount	The number of children the Transform has.
lossyScale	The global scale of the object (Read Only).

transform.Translate

transform.Translate(Vector3(x,z,y));

möglich ist auch folgende Schreibweise:

transform.Translate(5,0, 0);

Das Objekt bewegt sich 5 Meter von seiner ursprünglichen Position auf der x Achse.

transform.rotate

transform.rotate(Vector3(x,z,y), Space.Self)
Der erste Parameter bestimmt die Rotation nach eulerAngles
Der zweite Parameter relativeTo:Space bestimmt, welches Koordinatensystem die Drehung bestimmt. Das des Objektes Space.Self, oder das der Welt Space.World. Space.Self ist der Standardparameter und kann somit weggelassen werden.

transform.RotateAround

Will man ein Objekt mit einem Radius um eine Achse drehen, kann man RotateAround wählen.

Das Objekt hat eine bestimmte Position, von der aus es startet. Von diesem Startpunkt aus wird ein Punkt definiert, um den sich das Objekt dreht. Der Abstand zu diesem Punkt ist der Radius. Für den Radius gibt es keinen Parameter. Der Punkt, um den gedreht wird, ist der erste Parameter der RotateAround Funktion. Der zweite Parameter vom Typ Vector3 definiert mit 0 oder 1, um welche Achse gedreht werden soll. Vector3(0,1,0) bedeutet, das Objekt wird um die Y-Achse gedreht. Der dritte Parameter definiert den Winkel, um den das Objekt weitergedreht wird. Erfolgt dieser Winkel in einer Schleife, könnte man auch von "Geschwindigkeit" sprechen, allerdings hängt diese nicht nur vom Winkel sondern auch vom Radius ab.

var achse:Vector3;
var xDist = 10;
var degreeSpeed = 10;

function Start(){
achse = transform.position + Vector3(xDist,0,0);
}
function Update() {
// Dreh das object um den Punkt achse, um die y-Achse, zu Grad per Sekunde.
transform.RotateAround (achse, Vector3(0,1,0), degreeSpeed * Time.deltaTime);
}

time

time.deltaTime

Will man den Aufruf einer Aktion nicht anhand der Framerate sonder zeitlich bestimmen, kann man time.deltaTime nutzen. Hier wird die Zeit seit dem letzten update oder fixedupdate Aufruf gespeichert.

Wenn man einen Wert mit time.deltaTime multipliziert, drückt man damit aus, dass der Wert pro Sekunde anstatt pro Frame aktualisiert wird. Im folgenden Beispiel bewegt sich das Objekt 5 Meter pro Sekunde nach oben.

function update ()
{
transform.Translate(0, 5 * time.deltaTime, 0
}

Im folgenden Beispiel wird eine Funktion alle 2 Sekunden aufgerufen:

var fireRate = 2;
private var nextFire = 0.0;

function Update()
{
	if (Time.time > nextFire) 
	{
		nextFire = Time.time + fireRate;
		someFunction();
	}
}

Components

siehe Reference

Components werden GameObjects zugewiesen. So sind auch Scripte Components da sie GameObjects zugewiesen werden. Der Zugriff auf die gebräuchlichsten Components kann über einfache member Variablen erfolgen. Ansonsten kann man grundsätzlich über getComponent auf sie zugreifen. Über die Groß und Kleinschreibung kann man zwischen Klasse und Variable unterscheiden.

transform.Translate(0, 1, 0);
//ist gleiche wie
GetComponent(Transform).Translate(0, 1, 0);

Zugriff auf anderes Script im gleichen Game Object

Auf diese Weise kann man von jedem Script aus Zugriff auf jedes Script Component erhalten, welches im selben GameObject enthalten ist.

// This finds the script called OtherScript in the same game object
// and calls DoSomething on it.

function Update () {
var otherScript: OtherScript = GetComponent(OtherScript);
otherScript.DoSomething();
}

Zugriff auf anderes Script

Irgendwo gibt es ein Script namens other Script

function Update () {
var otherScript: OtherScript = GetComponent(OtherScript);
otherScript.DoSomething();
}

Zugriff auf andere Objekte über Inspector

Wenn man Variablen außerhalb einer Funktion definiert, kann man über den Inspektor andere Objekte zuweisen, indem man sie per drag and drop darauf zieht.

var target : Transform;
function Update () {
target.Translate(0, 1, 0);
}

Zugriff von Script zu Script, welches jeweils mit Objekt verbunden ist, über Inspector

Hier geht es darum, dass es 2 Scripte gibt, die jeweils mit einem anderen Game Objekt verbunden sind. Über den target Slot im Inspector erhält man Zugriff auf das andere Script und dessen Variablen und Funktionen.

Folgendes Beispiel wir haben ein GameObject cube1 damit verbunden ist ein Script namens OtherScript. In dem Script gibt es eine Variable vom Typ String namens foo und eine Gui funktion:

var foo:String;

function OnGUI () {
GUI.Label(Rect(100,100,100,20),foo);
}

Wir haben ein zweites GameObject namens cube2, mit dem ein weiteres Script verbunden ist, welches folgendermaßen aussieht. Wähle cube2 aus und ziehe cube1 auf den target slot im Inspector.

var target:OtherScript;
function Start () {
// Set foo variable of the target object
target.foo = "Lecko Mio";
}

Zugriff auf Child

Wenn Hand ein Child/ Kindelement des Game Objektes ist, dem folgendes Script zugewiesen wurde, kann man so auf das transform Hand zugreifen.

transform.Find("Hand").Translate(0, 1, 0);

Hat man das Objekt gefunden kann man auf die Components zugreifen, die damit verbunden sind.
transform.Find("Hand").GetComponent(OtherScript).foo = "2";

Zugriff auf alle Kindelement mittels for-in Schleife

for (var child : Transform in transform) {
child.Translate(0, 10, 0);
}

Zugriff über name oder tag

Es gibt verschiedene Arten per Code auf ein GameObject zu verweisen: GameObject.FindWithTag und GameObject.FindGameObjectsWithTag. Benutze GameObject.Find um ein Game Object anhand des Namens zu finden.

Benutze den name eines GameObjects
GameObject.Find("Cube").transform;

Benutze den tag eines GameObjects
GameObject.FindWithTag("Cube").transform;

Wähle den tag Button in inspector view. Hier kann man auch einen eigenen Tag erzeugen, indem man "addTag" wählt und dann einen leeren Tag umbenennt. Klicke dazu hinter den Namen des Tags. Achte darauf, dass man tag und nicht layer wählt.

Es gehört zwar nicht zum Thema aber, wenn du in mehreren Funktionen auf die Variable zugreifen willst, achte darauf, dass sie außerhalb der Funktionen definiert ist. Im folgenden Beispiel wurde dem Game Objekt namens Hand ein Script namens OtherScript zugewiesen. Darin gibt es eine Variable namens foo.

var kugel:GameObject;
function Start () {
kugel = GameObject.Find("Hand");
}
function Update(){
kugel.transform.Translate(0,0.1,0);
kugel.GetComponent(OtherScript).foo = "Höhe: "+kugel.transform.position.y;
}

Hier noch ein weiteres Beispiel

function Update ()
{
if (Input.GetButtonDown("Jump"))
{
var newTarget = GameObject.Find("Cube").transform;
GetComponent(Follow).target = newTarget;
}
}

Siehe auch dieses Beispiel

Zugriff über Parameter

Einige Event Nachrichten enthalten detaillierte Informationen über das Event. So übergeben beispielsweise Trigger Events die Collider Componente des kollidierenden Objektes an die Handler Funktion.

Benutze Static Collider ohne Rigidbody für Objekte die sich nicht bewegen.

Folgende Situation. Es gibt einen Cube in dessen Collider Funktion die Option Trigger aktiviert ist (Inspector).
Es gibt einen Player der ein Script mit folgender Funktion bekommen hat. Sobald der Player den Cube berührt bewegt sich dieser auf seiner x Achse ein Stück weiter.

function OnTriggerStay( other : Collider ) {
other.transform.Translate(1,0,0);
}

Hier ein weiteres Beispiel.

Erzeuge einen Cube mit einem Box Collider und einem Rigidbody (Component, Physics,...)
Nehme im Inspector folgende Einstellungen vor:
BoxCollider, isTrigger aktivieren
RigidBody Use Gravity deaktivieren.

Erstelle außerdem einen Player wie hier beschrieben.
Füge ein Script mit folgenden Anweisungen hinzu.

function OnTriggerStay( other : Collider ) {
// wenn der andere collider auch ein rigidbody hat
// füge Antriebskraft hinzu!
if (other.rigidbody)
other.rigidbody.AddForce(0, 1, 0);
}

Teste im Game Modus, sobald dein Player den Cube berührt müsste dieser nach oben schweben.

Alle Scripte eines Typs finden

Will man alle Objekte einer Klasse oder eines Typs finden nutzt man Object.FindObjectsOfType oder wenn man das erste Objekt der Klasse oder des Typs finden will, nutzt man Object.FindObjectOfType. Auch dieses Script ist sehr langsam und sollte daher nicht ständig in einer Update Funktion aufgerufen werden.

function Start () {
// Find the OtherScript which is attached to any game object in the scene.
var other : OtherScript = FindObjectOfType(OtherScript);
other.DoSomething();
}

Steuerungsscripte für Spielfiguren und Fahrzeuge

Hier veröffentliche ich Beispiele für Steuerungen von Spielfiguren oder Maschinen.

Das erste Script steuert ein Objekt, dem kein CharacterController zugewiesen sein sollte. Stattdessen sollte es einen Rigidbody bekommen. Wenn die Rigidbody-Option is Kinematic deaktiviert ist, kann man damit auch auf sich bewegenden Plattformen landen, bei denen "is Kinematic" aktiviert ist. Die Steuerung ist ein bisschen blöde, sobal das Objekt in einer Schieflage ist, aber das kann je nach Spiel ja auch ganz interessant sein. Man kann diese hakeligen Bewegungen abstellen, indem man die Option Rigidbody, Constraints, Freeze Rotation auf allen Achsen aktiviert.

Man kann es mit folgenden Tasten steuern.
Pfeil rauf, vorwärts,
Shift Speed erhöhen
Pfeil links rechts, Drehen
Leertaste lift up

var walkSpeed = 4;
var runSpeed = 2;
var rotationSpeed = 100;

function Update () {
	var speed = Input.GetAxis("Vertical") * walkSpeed;	
	var rotation = Input.GetAxis("Horizontal") * rotationSpeed;
	transform.Rotate(0, rotation * Time.deltaTime, 0, Space.World);
	
	if(Input.GetKey("left shift"))
		speed *= runSpeed;

	if(Input.GetButton ("Jump"))
	{
	var	liftSpeed = 0.5;
	rigidbody.useGravity = false;
	}
	else
	{
		liftSpeed = 0;
		rigidbody.useGravity = true;
	}
		
	transform.Translate(Vector3(0,0,speed*0.1));
	transform.Translate(Vector3(0,liftSpeed,0), Space.World);	
	
}

Das folgende Script sollte einem CharacterController zugewiesen werden. Es stammt aus einem Unity Beispiel und wurde von mir lediglich um eine Jump Funktion erweitert.

var hit = 0;
var speed = 4.0;
var jumpSpeed = 20.0;
var gravity = 20.0;

var smoothSpeed = 10.0;
var smoothDirection = 10.0;

var canJump = true;

private var moveDirection = Vector3.zero;
private var verticalSpeed = 0.0;
private var moveSpeed = 0.0;

private var grounded : boolean = false;
private var jumping : boolean = false;

private var targetAngle = 0.0;

// Require a character controller to be attached to the same game object
@script RequireComponent(CharacterController)

function Awake ()
{
	moveDirection = transform.TransformDirection(Vector3.forward);
}

function UpdateSmoothedMovementDirection ()
{
	
	
	
	var cameraTransform = Camera.main.transform;
	
	// Forward vector relative to the camera along the x-z plane	
	var forward = cameraTransform.TransformDirection(Vector3.forward);
	forward.y = 0;
	forward = forward.normalized;
	// Right vector relative to the camera
	// Always orthogonal to the forward vector
	var right = Vector3(forward.z, 0, -forward.x);

	// Target direction relative to the camera
	var targetDirection = Input.GetAxis("Horizontal") * right + Input.GetAxis("Vertical") * forward;
	
	// We store speed and direction seperately,
	// so that when the character stands still we still have a valid forward direction
	// moveDirection is always normalized, and we only update it if there is user input.
	if (targetDirection != Vector3.zero)
	{
		moveDirection = Vector3.Lerp(moveDirection, targetDirection, smoothDirection * Time.deltaTime);
		moveDirection = moveDirection.normalized;
	}

	// Smooth the speed based on the current target direction
	var curSmooth = smoothSpeed * Time.deltaTime;
	// When in air we accelerate slower
	if (!grounded)
	{
		curSmooth *= 0.5;
	}

//ohne genau zu wissen, was ich hier mache, habe ich eine runSpeed funktion eingebaut

	if(Input.GetKey("left shift"))
		moveSpeed = Mathf.Lerp(moveSpeed, targetDirection.magnitude * speed *3, curSmooth);
	else
		moveSpeed = Mathf.Lerp(moveSpeed, targetDirection.magnitude * speed, curSmooth);
}

function Update() {

	UpdateSmoothedMovementDirection();

	if (grounded) {
		verticalSpeed = 0.0;
		
		// Jump		
		if (canJump && Input.GetButton ("Jump")) {
			verticalSpeed = jumpSpeed;
			jumping = true;
			SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
		}
	}
	// Apply gravity
	verticalSpeed -= gravity * Time.deltaTime;
	
	var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0);
	movement *= Time.deltaTime;
	
	// Move the controller
	var controller : CharacterController = GetComponent(CharacterController);
	var flags = controller.Move(movement);
	grounded = (flags & CollisionFlags.CollidedBelow) != 0;

	// Set rotation to the move direction	
	transform.rotation = Quaternion.LookRotation(moveDirection);
	
	// We are in jump mode but just became grounded
	if (grounded && jumping)
	{
		jumping = false;
		SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
	}
}

function GetSpeed () {

	return moveSpeed;
}

Hier ein einfacheres Script für einen CharacterController

var walkSpeed = 6.0;
var runSpeed = 2;
var rotationSpeed = 200;




function Update () {

var speed = Input.GetAxis("Vertical") * walkSpeed;
if(Input.GetKey("left shift")) speed *= runSpeed;

var CharControl : CharacterController = GetComponent(CharacterController);
var dirForward = transform.TransformDirection(Vector3.forward);
CharControl.SimpleMove(dirForward * speed);


var rotation = Input.GetAxis("Horizontal") * rotationSpeed;
transform.Rotate(0, rotation * Time.deltaTime, 0);



}

Hier ein Script für ein RigidBody

siehe auch Rigidbody
Wenn man ein Rigidbody mit den transform Scripten bewegt, kann es vorkommen, dass die physikalsichen Eigenschaften nicht mehr richtig funktionieren. Außerdem sollte man bei Rigidbody nicht Update sondern FixedUpdate benutzen. Es ist logisch, dass zwischen Rigidbody und transform Positionsbestimmungen unterschieden werden muss, denn wenn man die physikalischen Eigenschaften nutzen will, darf man diese nicht einfach übergehen, indem man dem Objekt sagt es soll sich mit 3 Meter pro Sekunde bewegen. Auf diese Art würde ein Kollision gar nicht richtig funktionieren, da gar nicht genug Zeit da ist, auf die Kräfte und die somit enstandenen Bewegungen zu reagieren. Stattdessen wird ein Rigidbody auf die Art und Weise bewegt, indem man eine Kraft in eine bestimmte Richtung ausübt. forces (Kräfte) torque (Drehmoment)

Man kann auch ein Objekt erzeugen, dass man per transform bewegen kann und andere Rigidbody Objekte sich dazu physikalisch verhalten. So könnte man eine Bahn mit Waggons erstellen, in die man Steine läd. Die Bahn in diesem Fall muss dann ein Rigidbody sein, bei dem die Option "isKinematic" aktiviert ist, während die Steine Rigidbody Objekte sind, bei denen die Option "isKinematic" deaktiviert ist. Die physikalischen Eigenschaften werden geweckt, sobald die Steine die Bahn berühren.

Sehr praktisch ist auch die Option "Contstraints", "Freeze Rotation". Damit kann man bestimmen, dass ein Objekt sich aufgrund von Kollision nicht dreht. Man kann die einzelnen Achsen auswählen.

Hier ein kleines Script für ein Rigidbody, für eine Jump Funktion

function FixedUpdate () 
{
	if (Input.GetButtonDown ("Jump"))
	{
		rigidbody.velocity = Vector3(0,20,0);
	}
}

Mit diesem Script kann man mit den Pfeiltasten die Richtung eines Rigidbodys bestimmen und mit der r und f Taste das Objekt rauf und runter bewegen.

var speed = 30.0;

function FixedUpdate ()
{
	var y;
	if (Input.GetKey ("r"))
	{
		y = 1*Time.deltaTime * speed;
	}else if (Input.GetKey ("f"))
	{
		y = -1*Time.deltaTime * speed;
	}else{
		y=0;
	}
	var x = Input.GetAxis("Horizontal") * Time.deltaTime * speed;
	var z = Input.GetAxis("Vertical") * Time.deltaTime * speed;
	rigidbody.velocity = Vector3(x,y,z);
}

Steuerung in alle Richtungen per Tastatur

var speed = 30.0;
var y;
var z;
var x;
function FixedUpdate ()
{

	if (Input.GetKey ("t"))
	{
			y = 1*Time.deltaTime * speed;
	}
	else if (Input.GetKey ("u"))
	{
			y = -1*Time.deltaTime * speed;
	}
	else
	{
			y=0;
	}

		
	if (Input.GetKey ("z"))
	{
			z = 1*Time.deltaTime * speed;
	}
	else if (Input.GetKey ("h"))
	{
			z = -1*Time.deltaTime * speed;
	}
	else
	{
			z=0;
	}

		
	if (Input.GetKey ("j"))
	{
			x = 1*Time.deltaTime * speed;
	}
	else if (Input.GetKey ("g"))
	{
			x = -1*Time.deltaTime * speed;
	}
	else
	{
			x=0;
	}

	rigidbody.velocity = Vector3(x,y,z);
}

Michael Albers
mail@pastorpixel.de