Enums for the four directions

Question

I have walls that I can spawn. They wll move in one of four directions, up, down, right or left. Now I can set, wether the wall is thin, wide, long or short, but the problem is:

Nearly everything I do with the walls depends on wether they move up, down, left or right and because of this I use my direction enum extremely often and have to pass it the current state of the wall everytime.

import java.util.Random;

import com.AndroidTest.game.Constants;
import com.AndroidTest.game.GameWorld.GameWorld;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.BodyDef.BodyType;
import com.badlogic.gdx.physics.box2d.PolygonShape;

public class Wall {
    public enum Direction {
        UP {
            @Override
            public Vector2 getPosition(Random rand, Size size, Length length) {
                return new Vector2(rand.nextFloat()*(Constants.WORLD_WIDTH-size.value)+size.value/2, -length.valueVert);
            }

            @Override
            public float getWidth(Size size, Length length) {
                return size.value/2;
            }

            @Override
            public float getHeight(Size size, Length length) {
                return length.valueVert;
            }

            @Override
            public Vector2 getLinearVelocity(float speed) {
                return new Vector2(0f, speed);
            }

            @Override
            public boolean getDeath(Body body, Size size, Length length) {
                return (body.getPosition().y >= Constants.WORLD_HEIGHT+getHeight(size, length)) ? true : false;
            }
        },
        DOWN {
            @Override
            public Vector2 getPosition(Random rand, Size size, Length length) {
                return new Vector2(rand.nextFloat()*(Constants.WORLD_WIDTH-size.value)+size.value/2, Constants.WORLD_HEIGHT+length.valueVert);
            }

            @Override
            public float getWidth(Size size, Length length) {
                return size.value/2;
            }

            @Override
            public float getHeight(Size size, Length length) {
                return length.valueVert;
            }

            @Override
            public Vector2 getLinearVelocity(float speed) {
                return new Vector2(0f, -speed);
            }

            @Override
            public boolean getDeath(Body body, Size size, Length length) {
                return (body.getPosition().y <= -getHeight(size, length)) ? true : false;
            }
        },
        RIGHT {
            @Override
            public Vector2 getPosition(Random rand, Size size, Length length) {
                return new Vector2(-length.valueHori, rand.nextFloat()*(Constants.WORLD_HEIGHT-size.value)+size.value/2);
            }

            @Override
            public float getWidth(Size size, Length length) {
                return length.valueHori;
            }

            @Override
            public float getHeight(Size size, Length length) {
                return size.value/2;
            }

            @Override
            public Vector2 getLinearVelocity(float speed) {
                return new Vector2(speed, 0f);
            }

            @Override
            public boolean getDeath(Body body, Size size, Length length) {
                return (body.getPosition().x >= Constants.WORLD_WIDTH+getHeight(size, length)) ? true : false;
            }
        },
        LEFT {
            @Override
            public Vector2 getPosition(Random rand, Size size, Length length) {
                return new Vector2(Constants.WORLD_WIDTH+length.valueHori, rand.nextFloat()*(Constants.WORLD_HEIGHT-size.value)+size.value/2);
            }

            @Override
            public float getWidth(Size size, Length length) {
                return length.valueHori;
            }

            @Override
            public float getHeight(Size size, Length length) {
                return size.value/2;
            }

            @Override
            public Vector2 getLinearVelocity(float speed) {
                return new Vector2(-speed, 0f);
            }

            @Override
            public boolean getDeath(Body body, Size size, Length length) {
                return (body.getPosition().x <= -getHeight(size, length)) ? true : false;
            }
        };

        public abstract Vector2 getPosition(Random rand, Size size, Length length);
        public abstract Vector2 getLinearVelocity(float speed);
        public abstract float getWidth(Size size, Length length);
        public abstract float getHeight(Size size, Length length);
        public abstract boolean getDeath(Body body, Size size, Length length);

        public static Direction getRandomDirection() {
            Random rand = new Random();
             return values()[rand.nextInt(values().length)];
        }
    }

    public enum Length {
        THIN(1f, 1f),
        SHORT(Constants.WORLD_WIDTH/8, Constants.WORLD_HEIGHT/8),
        MEDIUM(Constants.WORLD_WIDTH/4, Constants.WORLD_HEIGHT/4),
        LONG(Constants.WORLD_WIDTH/2, Constants.WORLD_HEIGHT/2);

        public final float valueHori, valueVert;

        private Length(float valueHori, float valueVert) {
            this.valueHori = valueHori;
            this.valueVert = valueVert;
        }
    }

    public enum Size {
        TINY(1f),
        SMALL(5f),
        MEDIUM(10f),
        BIG(15f);

        public final float value;

        private Size(float value) {
            this.value = value;
        }
    }

    public Direction direction;
    public Size size;
    public Length length;
    public float speed;
    public Body body;

    public Wall(GameWorld gameWorld, Size size, Length length) {
        this.direction = Direction.getRandomDirection();
        this.size = size;
        this.length = length;
        this.speed = 20f;
        initWall(gameWorld, direction, size, length);
    }

    public Wall(GameWorld gameWorld, Direction direction, Size size, Length length) {
        this.direction = direction;
        this.size = size;
        this.length = length;
        this.speed = 20f;
        initWall(gameWorld, direction, size, length);
    }

    private void initWall(GameWorld gameWorld, Direction direction, Size size, Length length) {
        BodyDef bodyDef = new BodyDef();
        bodyDef.type = BodyType.KinematicBody;
        bodyDef.position.set(new Vector2(2, 15));  

        PolygonShape box = new PolygonShape();
        Random rand = new Random();

        box.setAsBox(direction.getWidth(size, length), direction.getHeight(size, length));
        bodyDef.position.set(direction.getPosition(rand, size, length));
        body = gameWorld.world.createBody(bodyDef);
        body.setLinearVelocity(direction.getLinearVelocity(speed));

        body.createFixture(box, 0.0f); 
        box.dispose();
    }
}

Answer 1

1. Missing model

You are missing a model or if it is there it is mixed together with the UI. For example: You have an Enum "Size" that internally holds UI information (float) and externally promotes a model fragment (TINY, SMALL, ...).

I would force myself to write the "game" without any UI first so I have the essence decoupled.

So the first step for me would be to separate those fragments.

2. Idea to distribute responsibilities of Direction

Your Direction Enum owns responsibilities that it shouldn't. My suggestion is to represent the directions for 2D navigation as tuples of the factors -1, 0 and 1.

public enum Direction {

    UP(0, -1), DOWN(0, 1), LEFT(-1, 0), RIGHT(1, 0);

    private Direction(float x, float y) {
        this.x = x;
        this.y = y;
    }

    private float x;
    private float y;

    public float getX() {
        return x;
    }
    public float getY() {
        return y;
    }

}

For example to calculate the linear velocity now only ONE method is necessary:

public Vector2 getLinearVelocity(float speed, Direction direction) {
    return new Vector2(speed * direction.getX(), speed * direction.getY());
}

The trick is to use the factor 0 to wipe out the summands not needed and to keep the important summands with -1 or 1. For the other methods I think it will be much more effort. But it's worth a try.

Answer 2

Since size, length, and body are public, you can just pass the Wall to the Direction instead. Also, Direction has so much functionality that it might as well be a class rather than an enum. In fact, it would be even better if it's an interface:

import java.util.Random;

import com.AndroidTest.game.Constants;
import com.AndroidTest.game.GameWorld.GameWorld;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.BodyDef.BodyType;
import com.badlogic.gdx.physics.box2d.PolygonShape;

/*
 * Replaces the Wall.Direction enum.
 *
 * The Wall is passed as a parameter to avoid a circular
 * dependency between Wall and Direction.
 */
public interface Direction {
    Vector2 getPosition(Wall wall, Random rand);
    float getWidth(Wall wall);
    float getHeight(Wall wall);
    Vector2 getLinearVelocity(float speed);
    boolean getDeath(Wall wall);
}
/*
 * A Direction implementation.
 */
public class UpDirection {
    public Vector2 getPosition(Wall wall, Random rand) {
        return new Vector2(rand.nextFloat()*(Constants.WORLD_WIDTH-wall.size.value)+wall.size.value/2, -wall.length.valueVert);
    }

    float getWidth(Wall wall) {
        return wall.size.value/2;
    }

    float getHeight(Wall wall) {
        return wall.length.valueVert;
    }

    Vector2 getLinearVelocity(float speed) {
        return new Vector2(0f, speed);
    }

    boolean getDeath(Wall wall) {
        return (wall.body.getPosition().y >= Constants.WORLD_HEIGHT+getHeight(wall)) ? true : false;
    }
}

/*
 * The remaining three Direction implementations go here.
 */

/*
 * Direction should not know about it's implementations,
 * so this factory is used instead to randomly create a Direction instance.
 */
public class DirectionFactory {
    public static Direction getRandomDirection() {
        Random rand = new Random();

        switch(rand.nextInt(4)) {
            case 0: 
                return new UpDirection()
                break;
            case 0: 
                return new DownDirection()
                break;
            case 0: 
                return new RightDirection()
                break;
            default: 
                return new LeftDirection()
                break;
        }
    }
}

public class Wall {   

    public enum Length {
        THIN(1f, 1f),
        SHORT(Constants.WORLD_WIDTH/8, Constants.WORLD_HEIGHT/8),
        MEDIUM(Constants.WORLD_WIDTH/4, Constants.WORLD_HEIGHT/4),
        LONG(Constants.WORLD_WIDTH/2, Constants.WORLD_HEIGHT/2);

        public final float valueHori, valueVert;

        private Length(float valueHori, float valueVert) {
            this.valueHori = valueHori;
            this.valueVert = valueVert;
        }
    }

    public enum Size {
        TINY(1f),
        SMALL(5f),
        MEDIUM(10f),
        BIG(15f);

        public final float value;

        private Size(float value) {
            this.value = value;
        }
    }

    public Direction direction;
    public Size size;
    public Length length;
    public float speed;
    public Body body;

    public Wall(GameWorld gameWorld, Size size, Length length) {
        this(gameWorld, DirectionFactory.getRandomDirection(), size, length) // Delegate to the other constructor
    }

    public Wall(GameWorld gameWorld, Direction direction, Size size, Length length) {
        this.direction = direction;
        this.size = size;
        this.length = length;
        this.speed = 20f;
        initWall(gameWorld); // initWall() has access to direction, size, and length.
    }

    private void initWall(GameWorld gameWorld) {
        BodyDef bodyDef = new BodyDef();
        bodyDef.type = BodyType.KinematicBody;
        bodyDef.position.set(new Vector2(2, 15));  

        PolygonShape box = new PolygonShape();
        Random rand = new Random();

        box.setAsBox(direction.getWidth(this), direction.getHeight(this)); // Pass Wall (this) to Direction.
        bodyDef.position.set(direction.getPosition(wall, rand)); // Here too.
        body = gameWorld.world.createBody(bodyDef);
        body.setLinearVelocity(direction.getLinearVelocity(speed));

        body.createFixture(box, 0.0f); 
        box.dispose();
    }
}

In this example, Direction is an interface with four implementations, (only one of which I coded), one for each of the possible directions. The methods accept a Wall and any other necessary parameters which are not part of the Wall. The implementations can then get size, length, and body from the Wall. Sure, this breaks some object-oriented programming rules, but as the adage says: some rules are meant to be broken :) Note that it still involves passing the current state of the Wall.

Alternatively, you can implement Wall as an abstract class containing void initWall(GameWorld gameWorld) and the equivalent of the Direction methods as abstract methods. Then, you can remove Direction all together and implement four Walls; one for each direction.