# Konzept Controller ( Review )



## LouCyphre (24. Nov 2022)

Hallo,

ich habe mich jetzt für ein Konzept für die Steuerung einer Spielfigur in einem kleinen Spiel entschieden und ich würde gern wissen, was ihr davon haltet.

Es beinhaltet im großen und ganzen ein Interface und zwei Klassen.

*PlayerController *implementiert das Interface und prägt die Methoden aus und *Player *hat quasi einen Controller im Bauch und verwendet darüber die Methoden.
Was denkt ihr? Außerdem erbt Player noch von der abstrakten Klasse *GameObject, *die 3 Methoden hält, die quasi jedes Objekt im Spiel inne haben soll. Hier jetzt nur _update() _gezeigt.

Danke für etwaige Antworten.


```
public interface IController {


    boolean isRequestingUp();

    boolean isRequestingDown();

    boolean isRequestingLeft();

    boolean isRequestingRight();
```


```
public class PlayerController implements IController{


   private Input input;


    public PlayerController(Input input) {

        this.input = input;

    }


    @Override

    public boolean isRequestingUp() {

        return input.isPressed(KeyEvent.VK_UP);

    }


    @Override

    public boolean isRequestingDown() {

        return input.isPressed(KeyEvent.VK_DOWN);

    }


    @Override

    public boolean isRequestingLeft() {

        return input.isPressed(KeyEvent.VK_LEFT);

    }


    @Override

    public boolean isRequestingRight() {

        return input.isPressed(KeyEvent.VK_RIGHT);

    }
```


```
public class Player extends GameObject{


    private IController controller;


    public Player(IController controller) {

        super();

        this.controller = controller;

    }


    @Override

    public void update() {

        int deltaX = 0;

        int deltaY = 0;


        if(controller.isRequestingUp()){

            deltaY--;

        }

        if(controller.isRequestingDown()){

            deltaY++;

        }

        if(controller.isRequestingLeft()){

            deltaX--;

        }

        if(controller.isRequestingRight()){

            deltaX++;

        }

        position = new Position(position.getX() +deltaX,position.getY() +deltaY );

}
```


----------



## yfons123 (24. Nov 2022)

warum soll der spieler wissen wie es funktioniert nach oben oder unten oder links oder rechts zu gehen?

der solls einfach machen "wie auch immer" 
also baust du dir objekte die wissen wie der Job geht und der spieler frägt nach bzw lässt es von diesen objekten machen


----------



## LouCyphre (24. Nov 2022)

yfons123 hat gesagt.:


> warum soll der spieler wissen wie es funktioniert nach oben oder unten oder links oder rechts zu gehen?
> 
> der solls einfach machen "wie auch immer"
> also baust du dir objekte die wissen wie der Job geht und der spieler frägt nach bzw lässt es von diesen objekten machen


okay, da bin ich mit einverstanden.
Allerdings weiß der Spieler ja garnicht wie es geht, sondern nur wie er sich " bewegen " soll, nachdem der PlayerController sagt -> das ist passiert.

Oder seh ich das flasch?


----------



## yfons123 (25. Nov 2022)

```
abstract class MovementProcessor
{
    public void move(Vector3 direction)
}
abstract class InputReceiver
{
    public Vector3 getDirection();
}
public class PlayerController
{
    private InputReceiver inputReceiver;
    private MovementProcessor movementProcessor;
    public PlayerController(InputReceiver inputReceiver, MovementProcessor processor)
    {
        // zu faul zu tippen
    }
    public void Process(float delta)
    {
        movementProcessor.move(inputReceiver.getDirection())
    }
}
```

du willst ungefähr sowas haben
der witz an der sache ist dass dien PlayerController schon fertig ist, und der schinken funktioniert schon fast

ich habe noch nicht mal eine implementation geschrieben wie was bewegt wird, das ist dem PlayerController auch scheiß egal
es ist nur wichtig DASS ihn jemand bewegt.. wie er das tut ist egal

du kannst zb jetzt eine implementation für MovementProcessor schreiben die irgendwas tut
dann denkst du dir "UI SCHEIßE .. wollte ihn doch gar nicht so bewegen"

dann kannst du einfach eine neue implementation shcreiben und diese stattdessen dem spieler geben, der spieler funktioniert deshalb immer noch

der spieler ist nicht abhängig von dem der ihn bewegt, das einzige was er braucht ist IRGENDWEN der ihn bewegt..wie auch immer der das tut


----------



## osion (20. Dez 2022)

Ich würde eine separate Klasse für die Benutzereingabe erstellen, um die Eingabeverarbeitung von der Steuerung der Spielfigur zu trennen.


----------

