myrish

package ar223ni_assign2;

import kotlin.random.URandomKt;

import java.util.Arrays;
import java.util.Random;

public class Myran {
    public static void main(String[] args) {
        int[] chessBoard = new int[64];
        /*
        Försöka att visualisera brädan.
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0
        0 0 0 0 0 0 0 0

        Nr 1-8 är alltså "taket"
        9 är första i vänstra väggen och 16 den högra
        17 är andra i vänsta väggen och 24 den högra
        25 är tredje i vänsta väggen och 32 den högra
        33 är fjärde i vänsta väggen och 40 den högra
        41 är femte i vänsta väggen och 48 den högra
        49 är sjätte i vänsta väggen och 56 den högra
        57 -> 64 är "golvet"

        1 2 3 4 5 6 7 8
        9 0 0 0 0 0 0 16
        17 0 0 0 0 0 0 24
        25 0 0 0 0 0 0 32
        33 0 0 0 0 0 0 40
        41 0 0 0 0 0 0 48
        49 0 0 0 0 0 0 56
        57 58 59 60 61 62 63 64

        Nu vet vi alltså vilka nummer som är begränsade. tex. står jag på 4 kan jag inte röra mig uppåt.
        Ett steg åt vänster är -1 i arrayen
        Ett steg åt höger är +1 i arrayen
        Ett steg upp är -8 i arrayen
        ett steg neråt är +8 i arrayen

        En nolle är en oupptäkt plats, 1 är en ruta du tidigare rört och 2 är myrans nuvarande plats
         */

        /*
        Fick inte uppgiften att fungera men förstår i runda slag hur jag ska gå till väga
        Haft mycket annat plugg att göra och tiden tog helt enkelt slut
         */

        //Huvud logiken är att välja ett nummer mellan 1-4
        //där 1 är vänster, 2 uppåt, 3 höger & 4 neråt
        int max = 4;
        int min = 1;
        int movement = 0;
        int antLocation;
        int steps = 0;
        int[] forbiddenLeft = {1,9,17,25,33,41,49,57};
        int[] forbiddenRight = {8,16,24,32,40,48,48,56};
        int[] forbiddenTop = {1,2,3,4,5,6,7,8};
        int[] forbiddenBottom = {57,58,59,60,61,62,63,64};
        int prevLocation;
        int totalSteps = 0;

        Random rand = new Random();
        movement = rand.nextInt(max - min) + min;
        antLocation = rand.nextInt(63) +1;
        //Fyll brädan med 0or
        for (int i = 0; i < 64; i++) {
            chessBoard[i] = 0;
        }
        //Sätt ut myran och markerar som 2
        chessBoard[antLocation] = 2;

        while(Arrays.asList(chessBoard).contains(0)){
            if(movement == 1){
                //Gå till vänster
              if(Arrays.asList(forbiddenLeft).contains(antLocation)){
                  chessBoard[antLocation] = chessBoard[antLocation];
              }
              else{
                  //Spara gamla pos
                  prevLocation = antLocation;
                  //Uppdatera myrpositionen till ett steg vänster
                  antLocation = antLocation -1;
                  //Om du hamnar utanför efter att du har försökt att flytta.
                  if(Arrays.asList(forbiddenLeft).contains(antLocation)){
                      //kan inte röra sig
                      chessBoard[prevLocation] = 2;
                  }
                  else{
                      //Kan röra sig
                      chessBoard[antLocation] = 2;
                      chessBoard[prevLocation] = 1;
                      totalSteps++;
                  }
                }
            }
            else if(movement == 2){
                //Gå upp
                if(Arrays.asList(forbiddenTop).contains(antLocation)){
                    chessBoard[antLocation] = chessBoard[antLocation];
                }
                else{
                    prevLocation = antLocation;
                    antLocation = antLocation -8;
                    if(Arrays.asList(forbiddenRight).contains(antLocation)){
                        //kan inte röra sig
                        chessBoard[prevLocation] = 2;
                    }
                    chessBoard[antLocation] = 2;
                    chessBoard[prevLocation] = 1;
                    totalSteps++;
                }
            }
            else if(movement == 3){
                //Gå till höger
                if(Arrays.asList(forbiddenRight).contains(antLocation)){
                    chessBoard[antLocation] = chessBoard[antLocation];
                }
                else{
                    prevLocation = antLocation;
                    antLocation = antLocation +1;
                    if(Arrays.asList(forbiddenBottom).contains(antLocation)){
                        //kan inte röra sig
                        chessBoard[prevLocation] = 2;
                    }
                    chessBoard[antLocation] = 2;
                    chessBoard[prevLocation] = 1;
                    totalSteps++;
                }
            }
            else if(movement == 4){
                //Gå ner
                if(Arrays.asList(forbiddenBottom).contains(antLocation)){
                    chessBoard[antLocation] = chessBoard[antLocation];
                }
                else{
                    prevLocation = antLocation;
                    antLocation = antLocation +8;
                    if(Arrays.asList(forbiddenBottom).contains(antLocation)){
                        //kan inte röra sig
                        chessBoard[prevLocation] = 2;
                    }
                    chessBoard[antLocation] = 2;
                    chessBoard[prevLocation] = 1;
                    totalSteps++;
                }
            }
            movement = rand.nextInt(max - min) + min;
        }
        System.out.println("Antal steg i simulering : " + totalSteps);
    }
}