Guest User

Untitled

a guest
Mar 8th, 2012
116
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 9.97 KB | None | 0 0
  1. package sokoban2;
  2.  
  3. import java.io.FileNotFoundException;
  4. import java.io.IOException;
  5. import java.util.ArrayList;
  6. import java.util.Stack;
  7.  
  8.  
  9. public class Level {
  10.  
  11.      //Konstanter
  12.     private final static char PLAYER = '@';
  13.     private final static char PLAYER_ON_TARGET = '+';
  14.     private final static char WALL = '#';
  15.     private final static char BOX = '$';
  16.     private final static char BOX_ON_TARGET= '*';
  17.     private final static char TARGET = '.';
  18.     private final static char EMPTY = ' ';
  19.  
  20.     private char[][] level /*=  {{'#', '#', '#', '#', '#', '#', '#'},
  21.                              {'#', ' ', ' ', ' ', '$', '.', '#'},
  22.                              {'#', '.', '$', ' ', '.', ' ', '#'},
  23.                              {'#', ' ', '@', '$', ' ', ' ', '#'},
  24.                              {'#', ' ', ' ', ' ', ' ', ' ', '#'},
  25.                              {'#', '#', '#', '#', '#', '#', '#'}}*/;
  26.     private int playerX;
  27.     private int playerY;
  28.     private ArrayList<Integer> targetX;
  29.     private ArrayList<Integer> targetY;
  30.    
  31.     // Sokoban del 2 //
  32.     public Stack<Level> undoStack;
  33.     // Sokoban del 2 end //
  34.  
  35.    
  36.     public Level(){
  37.  
  38.         targetX = new ArrayList<Integer>();
  39.         targetY = new ArrayList<Integer>();
  40.     //    undoMoves = new Stack<char[][]>();
  41.         findPlayerLocationAndTargets();
  42.     }
  43.  
  44.    
  45.     //Metode som tar imot string for så å konvertere til en char matrise, finner også spillerens posisjon og målene.
  46.     public Level(String s){
  47.         level = levelFromString(s);
  48.         targetX = new ArrayList<Integer>();
  49.         targetY = new ArrayList<Integer>();
  50.         findPlayerLocationAndTargets();
  51.        
  52.         //Sokoban 2//
  53.         undoStack = new Stack<Level>();
  54.     }
  55.  
  56.     //Metode som tar imot string for så å plassere den i en todimensjonal char matrise. Returnere matrisen.
  57.     public char[][] levelFromString(String s){
  58.  
  59.         int width = s.indexOf('|');
  60.  
  61.         int height = s.length() / width;
  62.         char newLevel[][] = new char[height][width];
  63.         // Hjelpeindex for oppslag i strengen som representerer brettet
  64.         int index = 0;
  65.         for (int i = 0; i < height; i++){
  66.             for(int j = 0; j < width; j++){
  67.                 newLevel[i][j] = s.charAt(index);
  68.                 index++;
  69.             }
  70.  
  71.             index++;
  72.         }
  73.         return newLevel;
  74.     }
  75.  
  76.    
  77.    
  78.    
  79.     //----SOKOBAN PART 2----//
  80.    
  81.     public Level(Level other) {
  82.         level = other.level;
  83.         targetX = other.targetX;
  84.         targetY = other.targetY;
  85.         other.findPlayerLocationAndTargets();
  86.     }
  87.    
  88.    
  89.     /*
  90.     public void updateMoveStack()
  91.     {
  92.         this.undoMoves.add(getLevel().clone());
  93.     }
  94.    */
  95.     /*
  96.     //matrise med y og x posisjon til bokser.  OKOKOKOK
  97.     public int[][] addPosMatrix(char[][] map)
  98.     {
  99.        
  100.         int[][] temp = new int[this.targetX.size()+1][2];
  101.         int z = 1;
  102.        
  103.         //Legger spillerens posisjon øverst i matrisa.
  104.         temp[0][0] = this.getPlayerY();
  105.         temp[0][1] = this.getPlayerX();
  106.        
  107.        
  108.         //Legger så antall flyttbarobjekter sin posisjon inn i matrisa.
  109.         for(int y = 0; y < map.length; y++)
  110.         {
  111.             for(int x = 0; x < map[0].length; x++)
  112.             {
  113.                 if(map[y][x] == BOX){
  114.                     temp[z][0] = y;
  115.                     temp[z++][1] = x;
  116.                 }
  117.             }
  118.         }
  119.        
  120.         return temp;
  121.     }
  122.    
  123.     */
  124.     /*
  125.     public void undoMove(){
  126.         setLevel(this.undoMoves.pop());
  127.     }
  128.    
  129.  
  130.    
  131.    
  132.     public void setLevel(char[][] nyLevel){
  133.         this.level= nyLevel;
  134.     }
  135.     */
  136.     //----SOKOBAN END PART 2----//
  137.  
  138.    
  139.    
  140.     //Get-metode for level.
  141.     public char[][] getLevel(){
  142.         return level;
  143.     }
  144.  
  145.     //Metode som finner spillerens posisjon og målene. Spillerens posisjon blir tilordnet de globale variablene.
  146.     private void findPlayerLocationAndTargets(){
  147.         for (int i = 0; i < level.length; i++) {
  148.             for (int j = 0; j < level[0].length; j++) {
  149.  
  150.                 if (level[i][j] == PLAYER){
  151.                     playerX = j;
  152.                     playerY = i;
  153.                 } else if (level[i][j] == TARGET){
  154.                     targetX.add(j);
  155.                     targetY.add(i);
  156.                 }
  157.             }
  158.         }
  159.     }
  160.  
  161.     //Get-metode for targets y-posisjon.
  162.     public ArrayList<Integer> getTargetY(){
  163.         return targetY;
  164.     }
  165.     //Get-metode for targets x-posisjon.
  166.     public ArrayList<Integer> getTargetX(){
  167.         return targetX;
  168.     }
  169.  
  170.     //Get-metode for spillerens x-posisjon.
  171.     public int getPlayerX(){
  172.         return playerX;
  173.     }
  174.    
  175.     //Get-metode for spillerens y-posisjon.
  176.     public int getPlayerY(){
  177.         return playerY;
  178.     }
  179.  
  180.     //Set-metode for å sette tegn i angitt koordinat.
  181.     public void setField(int y, int x, char c){
  182.         level[y][x] = c;
  183.     }
  184.    
  185.     //Get-metode for å hente char fra ønsket xy-posisjon.
  186.     public char getField(int y, int x){
  187.         return level[y][x];
  188.     }
  189.  
  190.     //Metode som  flytter spiller og samtidig endrer char etter flytt.
  191.     public void playerMoveReplace(int dy, int dx){
  192.  
  193.         char field = level[playerY][playerX];
  194.         switch (field){
  195.         case PLAYER_ON_TARGET:
  196.             setField(playerY, playerX, TARGET);
  197.             break;
  198.         case BOX_ON_TARGET:
  199.             setField(playerY, playerX, PLAYER_ON_TARGET);
  200.             break;
  201.         case PLAYER:
  202.             setField(playerY, playerX, EMPTY);
  203.             break;
  204.         }
  205.  
  206.         playerX += dx;
  207.         playerY += dy;
  208.     }
  209.  
  210.     //Metode som oppdatere spillerens dytt.
  211.     public void playerPushReplace(int dy, int dx){
  212.  
  213.         char field = level[playerY][playerX];
  214.         switch (field){
  215.         case BOX_ON_TARGET:
  216.             setField(playerY, playerX, PLAYER_ON_TARGET);
  217.             break;
  218.         case BOX:
  219.             setField(playerY, playerX, PLAYER);
  220.             break;
  221.         }
  222.     }
  223.  
  224.     //Metode som oppdatere boksen char ved flytt.
  225.     public void boxMoveReplace(int boxY, int boxX, char c){
  226.         switch (c){
  227.         case TARGET:
  228.             setField(boxY, boxX, BOX_ON_TARGET);
  229.             break;
  230.         case EMPTY:
  231.             setField(boxY, boxX, BOX);
  232.             break;
  233.         }
  234.     }
  235.  
  236.     //Skriver ut level.
  237.     @Override
  238.     public String toString(){
  239.         String printString = "";
  240.         for (int i = 0; i < level.length; i++) {
  241.             for (int j = 0; j < level[0].length; j++){
  242.                 printString += level[i][j];
  243.             }
  244.             printString += "\n";
  245.         }
  246.         return printString;
  247.     }
  248.  
  249.  
  250.     //Sjekker om alle boksene er på målet.
  251.     public boolean checkVictory(){
  252.         for (int i = 0; i < getTargetX().size(); i++){
  253.             if (level[getTargetY().get(i)][getTargetX().get(i)] != BOX_ON_TARGET){
  254.                 return false;
  255.             }
  256.         }
  257.         return true;
  258.     }
  259.  
  260.     //Boolean metode som sjekker om planlagt move er gyldig ved hjelp av validatePush-metoden.
  261.     public boolean validateMove(int dx, int dy){
  262.         try {
  263.             int tempX = getPlayerX() + dx;
  264.             int tempY = getPlayerY() + dy;
  265.             // Checks array index out of bounds
  266.             // Further check block-move / wall-collision etc
  267.             char newPos = getField(tempY, tempX);
  268.             // If new player position is on a box
  269.             if (newPos == BOX || newPos == BOX_ON_TARGET){
  270.                 return validatePush(dx, dy);
  271.  
  272.             } else if (newPos == WALL){
  273.                 return false;
  274.             } else return true;
  275.  
  276.         } catch (ArrayIndexOutOfBoundsException e) {
  277.             // Returns false if user tries to exit level bounds
  278.             // Invalid move due to end of map
  279.             return false;
  280.         } catch (Exception e) {
  281.             System.out.println("UNKNOWN EXCEPTION, MOAR DEBUGGING!");
  282.             return false;
  283.         }
  284.     }
  285.  
  286.     //Boolean metode som validerer om tenkt trekk er gyldig, hjelpemetode til validateMove.
  287.     public boolean validatePush(int dx, int dy) {
  288.  
  289.         int tX = getPlayerX() + dx*2;
  290.         int tY = getPlayerY() + dy*2;
  291.         char newBoxPos = getField(tY, tX);
  292.         if (newBoxPos != WALL && newBoxPos != BOX && newBoxPos != BOX_ON_TARGET){
  293.             // Set change the box image on map
  294.             // If box was in correct position
  295.             return true;
  296.         } else {
  297.             // Invalid move due to box collision
  298.             return false;
  299.         }
  300.     }
  301.  
  302.  
  303.  
  304.     //Metode for flytting av spiller.
  305.     public void movePlayer(int dx, int dy){
  306.         if (validateMove(dx, dy)){
  307.  
  308.             // Temp-verdier for ny posisjon til spiller
  309.             int tX = playerX + dx;
  310.             int tY = playerY + dy;
  311.  
  312.  
  313.             char newPos = getField(tY, tX);
  314.  
  315.  
  316.             switch (newPos){
  317.  
  318.             case BOX_ON_TARGET:
  319.  
  320.                 pushBox(dy,dx);
  321.                 playerMoveReplace(dy,dx);
  322.                 playerPushReplace(dy,dx);
  323.                 return;
  324.  
  325.             case BOX:
  326.  
  327.                 pushBox(dy,dx);
  328.                 playerMoveReplace(dy,dx);
  329.                 playerPushReplace(dy,dx);
  330.                 return;
  331.  
  332.             case EMPTY:
  333.  
  334.                 setField(tY, tX, PLAYER);
  335.                 playerMoveReplace(dy,dx);
  336.                 return;
  337.  
  338.             case TARGET:
  339.                 // Flytter til et tomt target-felt
  340.                 setField(tY, tX, PLAYER_ON_TARGET);
  341.                 playerMoveReplace(dy, dx);
  342.                 return;
  343.  
  344.             default:
  345.                 System.out.println("Feilmelding.");
  346.                 return;
  347.             }
  348.         }
  349.     }
  350.  
  351.  
  352.     //Metode for flytting av boks.
  353.     public void pushBox(int dy, int dx){
  354.         // Position of box after push
  355.         int newBoxX = playerX + dx*2;
  356.         int newBoxY = playerY + dy*2;
  357.         // Current element at new position
  358.         char c = getField(newBoxY, newBoxX);
  359.         // Updates the char for element on new position
  360.         boxMoveReplace(newBoxY, newBoxX, c);
  361.     }
  362. }
Advertisement
Add Comment
Please, Sign In to add comment