emoflon / emoflon-ibex-examples Goto Github PK

package org.moflon.tutorial.sokobangamegui.rules;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

import SokobanLanguage.Board;
import SokobanLanguage.Field;
import SokobanLanguage.Figure;
import SokobanLanguage.Sokoban;
import SokobanRules.SokobanValidator;
import SokobanRules.api.SokobanRulesAPI;
import SokobanRules.api.matches.MoveSokobanUpMatch;
import SokobanRules.api.matches.PushBlockUpMatch;

public class SokobanRules
{
   private String allsWell = "Everything seems to be ok...";

   private SokobanRulesAPI api;

   // Keep track of all currently possible moves
   private Map<Field, Supplier<Result>> possibleMoves;

   public SokobanRules(Board board)
   {
      this.api = new SokobanValidator(board).initAPI();

      possibleMoves = new HashMap<>();

      api.moveSokobanUp().subscribeAppearing(m -> registerMoveSokobanUpMatch(m));
      api.moveSokobanUp().subscribeDisappearing(m -> unregisterSokobanMoveUpMatch(m));

      api.pushBlockUp().subscribeAppearing(m -> registerPushBlockUpMatch(m));
      api.pushBlockUp().subscribeDisappearing(m -> unregisterPushBlockUpMatch(m));
   }

   private void unregisterSokobanMoveUpMatch(MoveSokobanUpMatch m)
   {
      possibleMoves.remove(m.getTo());
   }

   private void registerMoveSokobanUpMatch(MoveSokobanUpMatch m)
   {
      Field targetField = m.getTo();
      registerRuleApplication(targetField, targetField, () -> api.moveSokobanUp().apply());
   }

   private void registerPushBlockUpMatch(PushBlockUpMatch m)
   {
      registerRuleApplication(m.getTo(), m.getNext(), () -> api.pushBlockUp().apply());
   }

   private Supplier<Result> unregisterPushBlockUpMatch(PushBlockUpMatch m)
   {
      return possibleMoves.remove(m.getTo());
   }

   // If the required field ("emptyField") is indeed empty, add the potential rule application
   private void registerRuleApplication(Field targetField, Field emptyField, Runnable applyRule)
   {
      if (!isEmpty(emptyField))
         possibleMoves.put(targetField, () -> {
            applyRule.run();
            return new Result(true, "Go Sokoban!");
         });
   }

   private boolean isEmpty(Field field)
   {
      return api.anOccupiedField().bindField(field).hasMatches();
   }

   public Result move(Figure figure, Field field)
   {

      // Refuse to do anything if the chosen figure is not Sokoban
      if (!(figure instanceof Sokoban))
         return new Result(false, "You can only move Sokoban!");

      if (possibleMoves.containsKey(field))
         return possibleMoves.get(field).get();
      else
         return new Result(false, "Sokoban can't move to " + "[" + field.getRow() + "," + field.getCol() + "]");
   }

   public Result validateBoard(Board board)
   {
      final int blockCount = api.oneBlock().countMatches();
      final int endPositionFieldsCount = api.oneEndField().countMatches();

      if (blockCount == 0)
         return new Result(false, "You must have at least one Block!");

      if (blockCount != endPositionFieldsCount)
         return new Result(false, "Number of blocks needs to equal number of end-position fields.");

      if (api.boulderOnEndField().countMatches() != 0)
         return new Result(false, "An end position is blocked by a boulder.");

      if (api.oneSokoban().countMatches() != 1)
         return new Result(false, "You must have exactly one Sokoban!");

      return new Result(true, allsWell);
   }
}