HTWG-MONOPOLY

Steffen Gorenflo

Timotheus Ruprecht

MVC - Architektur

GUI

Google Guice

@Inject
public MonopolyFactory(@Named("FieldSize") int fieldSize) { this.fieldSize = fieldSize; }

@Inject
public Controller(IControllerFactory controllerFactory,	IMonopolyDAO database) {
        
        // set dependencies
	this.factory = controllerFactory;
	this.database = database;

        // do other init stuff
		
}

Google Guice

@Override
protected void configure() {
    // define the size of the game
    bindConstant().annotatedWith(Names.named("FieldSize")).to("28");
    // define the main controller of the game
    bind(IController.class).to(de.htwg.monopoly.controller.impl.Controller.class);
    // define the factory for the underlying model
    bind(IControllerFactory.class).to(de.htwg.monopoly.factory.impl.MonopolyFactory.class);

    // hibernate
    bind(IMonopolyDAO.class).to(de.htwg.monopoly.persistence.hibernate.MonopolyHibernateDAO.class);

     // couchdb
    // bind(IMonopolyDAO.class).to(de.htwg.monopoly.persistence.couchdb.MonopolyCouchdbDAO.class);

    // db40
    // bind(IMonopolyDAO.class).to(de.htwg.monopoly.persistence.db4o.MonopolyDb4oDAO.class);
}

Plugin Interface

// define Plugins
Multibinder<MonopolyPlugin> plugins = Multibinder.newSetBinder(binder(), MonopolyPlugin.class);
plugins.addBinding().to(de.htwg.monopoly.plugins.PluginOne.class);
plugins.addBinding().to(de.htwg.monopoly.plugins.PluginTwo.class);

public interface MonopolyPlugin extends IObserver {
	String getName();
	void enable(IController controller);
	void disable();
}

Jenkins

Sonar

Project Lombok

public class PersistencePlayer extends CouchDbDocument{
    @Getter
    @Setter
    private String name;
    @Getter
    @Setter
    private Integer budget;
    @Getter
    @Setter
    private Integer position;
    @Getter
    @Setter
    private Integer prisonRound;
    @Getter
    @Setter
    private Boolean inPrison;
    @Getter
    @Setter
    private Collection<Integer> ownershipPositions;
    @Getter
    @Setter
    private Integer prisonFreeCard;
    @Getter
    @Setter
    private PlayerIcon icon;
}

Project Lombok

@Data
public class PersistencePlayer extends CouchDbDocument{
    private String name;
    private Integer budget;
    private Integer position;
    private Integer prisonRound;
    private Boolean inPrison;
    private Collection<Integer> ownershipPositions;
    private Integer prisonFreeCard;
    private PlayerIcon icon;
}

Maven Repository

Datenbank - Interface

public interface IMonopolyDAO {

    void saveGame(final IMonopolyGame context);

    IMonopolyGame getGameById(final String id);

    void deleteGameById(final String id);

    void updateGame(final IMonopolyGame game);

    List<IMonopolyGame> getAllGames();

    boolean containsGameById(final String id);
}

db4o

public class MonopolyDb4oDAO implements IMonopolyDAO {
    private EmbeddedObjectContainer db;

    public MonopolyDb4oDAO() { 
        db = Db4oEmbedded.openFile(Db4oEmbedded.newConfiguration(), "monopoly.data"); }

    @Override public void saveGame(IMonopolyGame context) { db.store(context); }

    @Override public IMonopolyGame getGameById(final String id) {
        List<IMonopolyGame> games = db.query(new Predicate<IMonopolyGame>() {
            @Override
            public boolean match(IMonopolyGame game) { return (game.getId().equals(id)); }
        if (games.isEmpty()) { return null; }
        return games.get(0);
    }

    @Override public void deleteGameById(String id) { db.delete(getGameById(id)); }

    @Override public List<IMonopolyGame> getAllGames() { return db.query(IMonopolyGame.class); }

    @Override public boolean containsGameById(String id) { ... }

    public void closeDB() { db.close(); }

    @Override public void updateGame(IMonopolyGame game) {
        deleteGameById(game.getId());
        saveGame(game);
    }
}

Hibernate

@Entity
@Table(name = "game")
@Data
public class PersistentGame implements Serializable {
	@Id
	@Column(name = "id")
	private String id;

	@OneToMany(mappedBy = "game")
	@Column(name = "player")
	private List<PersistentPlayer> players;

	private String name;

	private Integer currentPlayerIndex;

	private boolean drawnCardFlag;

	private int diceFlag;

	private String message;

	private int parkingMoney;

	private String phase;

	private	int numberOfFields;
}

couchdb

@Data
public class PersistenceGame 
            extends CouchDbDocument {
    private String name;
    private Collection<PersistencePlayer> players;
    private Integer currentPlayerIndex;
    private PersistencePlayfield playfield;
    private String message;
    private boolean drawnCardFlag;
    private int diceFlag;
}

@Data
public class PersistencePlayer         
                extends CouchDbDocument{
    private String name;
    private Integer budget;
    private Integer position;
    private Integer prisonRound;
    private Boolean inPrison;
    private Collection<Integer> ownershipPositions;
    private Integer prisonFreeCard;
    private PlayerIcon icon;
}

@Data
public class PersistencePlayfield
                extends CouchDbDocument{
    private Integer numberOfFields;
    private String currentPlayer;
    private Integer parkingMoney;
    private String gamePhase;
}

couchdb

// transform from monopoly game object to couchdb object
public PersistenceGame transformToCouchDb(IMonopolyGame game) { ... }

// transform from couchdb object to monopoly game object
public IMonopolyGame transformFromCouchDb(PersistenceGame game) { ... }



// a big constructor
IMonopolyGame monopolyGame = new MonopolyGame(playerController, playfield, question,
                GameStatus.valueOf(game.getPlayfield().getGamePhase()), game.getName(),
                game.getPlayfield().getParkingMoney(), game.getMessage(), game.getDiceFlag(), 
                game.isDrawnCardFlag(), dice, game.getId(), game.getRevision());

couchdb

Performance Profiling

CouchDB

db4o

hibernate

Performance Testing

Anzahl Threads: 10

Anzahl Wiederholungen: 100

Performance Testing

Actor

public class Actor extends UntypedActor {

    public Actor() { }

    @Override
    public void onReceive(Object msg) throws Exception {

        if (msg instanceof ActorMessage && "update" == ((ActorMessage) msg).getMessage()) 
            GameStatus phase = ((ActorMessage) msg).getGameStatus();
            ((ActorMessage) msg).getController().notifyObservers(phase);
        }
    }
}

public class ActorMessage implements Serializable {

    private IController controller;
    private String message;
    private GameStatus status;

    public ActorMessage(String message, IController controller, GameStatus phase) {
	this.controller = controller;
	this.message = message;
	this.status = phase;
    }
}

Fragen?