Nodes coordinates changing on their own?

[mike Vigor]

So I'm working on a game which has to mimic a space ship with aliens and humans on board and the humans have to escape from the aliens and the aliens have to try to eat the humans. Aliens and humans players get to move around the space ship my means of a piece with their player numbers written on it!
The space ship is made up of cells, called sectors, which I did build with a hexagon, every sector has a name and a coordinate and if a player moves into another cell/sector it's present cell/sector should be updated.
For a reason or so it seems there is a rearrangement of the coordinates of the cells/sectors after a player moves...this error is soo difficult to explain so I did create a miniature project of the original one with every minimal feature necessary to mimic perfectly the original one and I'm going to posts all the classes here so that any one who wants to help me solve the situation can can load it and build it and try it and see the problem I'm talking about...unfortunately I think this is the only way I can really get help solving the problem
so here are the classes..
the problem/error I'm having is made clear on line 104 in the piece class where there is some printing to console to make it clear that the coordinates/nodes id being printed to the console is very different from that being seen in the gui /screen

//MAIN

package efa;

import javafx.application.Application;
import javafx.collections.ObservableList;

import java.util.*;


import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.stage.Stage;

import javafx.scene.*;
import javafx.scene.shape.*;


public class Main extends Application 
{
	private static final int rootHeight = 1000;
	private static final int rootWidth = 1000;
	public Scene scene ;
	static Ship map ;
	static int nOfplayers;
	private int humanCounts;
	private ArrayList<Player> players = new ArrayList<> ();
	static Group tileGroup = new Group ();
	HBox hbox = new HBox ();
	Game game; 
	
	private Parent createContent()
	{   
		StackPane root = new StackPane();
		BorderPane borderpane = new BorderPane();
		root.setPrefSize(rootHeight,rootWidth);
		//root.getStyleClass().add("root");
		root.setId("root");
		hbox.setPadding(new Insets(15, 12, 15, 12));
	    hbox.setSpacing(10);
	    hbox.setStyle("-fx-background-color: #00FFFF;");
	 
	    
	    Main.map = new Fermi(); 
	    Main.nOfplayers = 2 ;
	    		
	    		 for(Integer y = 0; y < Main.map.yCoord; y++)
	    		 {
	    			 for(Integer x = 0; x < Main.map.xCoord; x++)
	    			 { 
	    				 if( Main.map.returnSector(y,x) != null )
	    				 { 
	    				  tileGroup.getChildren().add(Main.map.returnSector(y, x));
	    				 }
	    			 }
	    		 }		
	    
	    borderpane.setTop(hbox);
	    borderpane.setCenter(tileGroup);
        root.getChildren().addAll( borderpane);
        game = Game.getGame(nOfplayers);
	    return root;
	}   
	
	
    public static void main(String[] args)
    {
        launch(args);
    }
    
    @Override
    public void start(Stage stage) 
    {
    	scene = new Scene(createContent());
		stage.setScene(scene);
		//scene.getStylesheets().add(Main.class.getResource("/application.css").toExternalForm());
		stage.setTitle("EscapeFromTheAliens");
		stage.show();       
    }
}

//GAME CLASS

package efa;

import static efa.Main.map;

import java.util.ArrayList;
import javafx.concurrent.Task;
import javafx.scene.control.ProgressBar;

public class Game  extends Task <Void>
{
  private int noOfPlayers;
  private int humanCounts = 0;
  protected static ArrayList <Player> players = new ArrayList< > ();

  protected static int playerturn;
  private static Game singleGame = null;
  
   private Game (int nOfPlayers)
   {
	   this.noOfPlayers = nOfPlayers;
	
		  for(int n = 0; n != this.noOfPlayers; n++)
		  {
			  if ( (n % 2) == 0)
			  {  
				  Player player = new Player(PlayerCharacter.HUMAN);
			      for(int y = 0; y < Ship.yCoord; y++)
			      {
			    	  for(int x = 0; x < Ship.xCoord; x++)
			    	  {
			    		  if((map.rigidFrame[y][x] != null) && map.rigidFrame[y][x].getSectorName().equals(map.gethumanstartsector()))
			    		  {
			    			 Sector human = new Sector();
			    			 human = map.rigidFrame[y][x] ;  				    
			    			 player.setPiece("human", n);
                             player.getPiece().centerOne(human);	
                             player.getPiece().setAlive(true);
			    		  }
			    	  }
			      }
			      player.setName(n+1);
			      player.setCurrentSector(map.gethumanstartsector());
			      players.add(player);
			  }
			  else
			  {
			   Player player = new Player(PlayerCharacter.ALIEN);
			   for(int y = 0; y < Ship.yCoord; y++)
			      {
			    	  for(int x = 0; x < Ship.xCoord; x++)
			    	  {
			    		  if(( map.rigidFrame[y][x] != null) &&  map.rigidFrame[y][x].getSectorName().equals(map.getalienstartsector()))
			    		  {   
			    			  Sector alien = new Sector();
			    			  alien = map.rigidFrame[y][x] ;  
			       			  player.setPiece("alien", n);
			    			  player.getPiece().centerOne(alien);	
			    			  player.getPiece().setAlive(true);
			    		  }
			    	  }
			      }
			   player.setName(n+1);
			   player.setCurrentSector(map.getalienstartsector());
			   players.add(player);
			  }
		  }

		  for(Player p : players)
		  {
			  if(p.getCharacter().equals("human"))
				  
			  this.humanCounts++;
		  }
   }
   
   public static Game getGame(int no)
   {
  	 if(singleGame == null)
  	 {
  		 singleGame = new Game(no);
  	 }
  	 return singleGame;
  	 
   }
   
   @Override
   protected Void call()  throws InterruptedException
   {   
  	
  	  Void ret = null;
  	  ProgressBar bar = new ProgressBar();
  	  return null;
  	  //complete game logic and rules will come here..
   }	  
}

//SHIP ABSTRACT CLASS

package efa;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;

public abstract class Ship 
{
	  static  final String alphabets []= {"A","B","C","D","E","F","G" ,"H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W"};
	  static  final ArrayList <String> upHex  = new ArrayList<>(Arrays.asList("A","C","E","G","I","K","M","O","Q","S","U","W","V"));
	  static  final Integer yCoord = 15;
	  static final Integer xCoord = 23;
	  static String alienstartCoordinate ;
	  static  String humanstartCoordinate ;
	  static HashMap <String, Sector> findSector = new HashMap<> ();
	  
	  final Sector rigidFrame [][]= new Sector [yCoord][xCoord];
	
	  
	  abstract Sector returnSector(int y, int x);
	  abstract String getalienstartsector();
	  abstract String gethumanstartsector();
	 // abstract ArrayList<String> getSurronding(Sector sector);
	  abstract Sector returnSector(String sectorname);
}

//FERMI spaceship class

ckage efa;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Fermi extends Ship
{
	private ArrayList<Sector> sectors;
    private   List <String> dangerousCoordinate  = new ArrayList<>(Arrays.asList("I7","I9","I12","J3","K4","K13","L3","L4","M2","M4","N3","N7","N12","O10","P11"));
    private List <String> escapeCoordinate =new ArrayList<>(Arrays.asList("J1","J5","N1","N5"));
    private List <String> secureCoordinate = new ArrayList<>(Arrays.asList("H10","H11","I6","I10","J4","J7","J8","J10","J11",
    		            "J12","K2","K3","K8","K11","L5","L6","L7","L8","L11","L12","M3","M8","M11","M13","N4","N8","N10","N11",
    		            "O6","O7","O9","O12","P10"   ));
 	
	public Fermi()
	{ 
		Ship.alienstartCoordinate="L9";
	    Ship.humanstartCoordinate="L10";
   
        ArrayList<String>allcoord = new ArrayList<>();
  		
		for(String s : this.dangerousCoordinate) allcoord.add(s);
		for(String s : this.escapeCoordinate) allcoord.add(s);		
		for(String s : this.secureCoordinate) allcoord.add(s);
		allcoord.add(Ship.alienstartCoordinate);
		allcoord.add(Ship.humanstartCoordinate);
		
		for(Integer y = 0; y < yCoord; y++)
		{
			for(int x = 0; x < xCoord; x++)
			{
			 Sector sector = new Sector(alphabets[x].concat(y.toString()), x, y);	
			 sector.setLetter(alphabets[x]);
			 sector.setNumber(y);
			 
			 if(!allcoord.contains(sector.getSectorName()))
			 {	 
			    rigidFrame[y][x] = null;
			 }
			 else rigidFrame[y][x]=sector;
			}
		}	
			for(Integer y = 0; y < yCoord; y++)
			{
				for(int x = 0; x < xCoord; x++)
				{   
					Sector sector = rigidFrame[y][x];
					if(sector != null && this.dangerousCoordinate.contains(sector.getSectorName()) )
					{		
						sector.setColor("dangerous");
						sector.setSectorType(SectorType.DANGEROUS);
					    findSector.put(sector.getSectorName(), sector);
				    }
				}
			}
			
			for(Integer y = 0; y < yCoord; y++)
			{
				for(int x = 0; x < xCoord; x++)
				{   
					Sector sector = rigidFrame[y][x];
					if(sector != null && 
							Ship.alienstartCoordinate.contains
							(sector.getSectorName()))
					{		
						sector.setColor("alien");
						sector.setSectorType(SectorType.ALIENSTART);
					    findSector.put(sector.getSectorName(), sector );
				    }
				}
			}
		   
			for(Integer y = 0; y < yCoord; y++)
			{
				for(int x = 0; x < xCoord; x++)
				{   
					Sector sector = rigidFrame[y][x];
					if(sector != null && Ship.humanstartCoordinate.contains(sector.getSectorName()))
					{	
						sector.setSectorType(SectorType.HUMANSTART);
						sector.setColor("human");
					    findSector.put(sector.getSectorName(), sector );
				    }
			   }       
			}
			
			for(Integer y = 0; y < yCoord; y++)
			{
				for(int x = 0; x < xCoord; x++)
				{   
					Sector sector = rigidFrame[y][x];
					if(sector != null && this.escapeCoordinate.contains(sector.getSectorName()))
					{	
						sector.setSectorType(SectorType.ESCAPE);
						sector.setColor("escape");
					    findSector.put(sector.getSectorName(), sector );
				    }
				} 
			}
			
			for(Integer y = 0; y < yCoord; y++)
			{
				for(int x = 0; x < xCoord; x++)
				{   
					Sector sector = rigidFrame[y][x];
					if(sector != null && this.secureCoordinate.contains(sector.getSectorName()))
					{	
						sector.setSectorType(SectorType.SECURE);
						sector.setColor("secure");
					    findSector.put(sector.getSectorName(), sector );
					}    
				}
			}
    }

    Sector returnSector(int y, int x)
    {
	 return this.rigidFrame[y][x];
    }
    
	String getalienstartsector()
	{
		return Ship.alienstartCoordinate;
	}
	
	String gethumanstartsector()
	{
		return Ship.humanstartCoordinate;
	}
	

	
	Sector returnSector(String sectorname)
	{
		Sector sector = new Sector();
		
		if(Ship.findSector.containsKey(sectorname))
		{
		  sector = findSector.get(sectorname);
		}
		return sector;
	}
}    

PLAYER CLASS

package efa;


import static efa.Main.map;
import static efa.Main.tileGroup;

import java.util.*;

public class Player 
{
 private PlayerCharacter character;
 private String currentSector;
 private Sector currSector;
 private String nextSector;
 private String chkSector;
 private ArrayList<String> message = new ArrayList<>();
 private Boolean alive ;
 private boolean attacked;
 private String playerName ;
 private Piece piece;
 
 
  Player (PlayerCharacter type)
  {
	  character = type;
	  if(type.equals(PlayerCharacter.ALIEN) )
	  {
		//set currentSector to alien starting point  
	  }
	  else if(type.equals(PlayerCharacter.HUMAN))
	  {
		//set currentSector to human sector starting point
	  }
	  alive = true ;
	  
    
	  
 }
	 String getPlayerName()
	 {
		 return playerName;
	 }
	 
     PlayerCharacter getCharacter()
     {
    	 return character;
     }
     
     void setPiece (String type, int num)
     {
    	  piece = new Piece(this.character, num+1);
    	  playerName = piece.getPieceNumber();
   		  tileGroup.getChildren().add(piece);
     }
     
     Piece getPiece ()
     {
    	 return this.piece ;
     }
     
	 
	 ArrayList<String> getMessages()
	 {
	   return message;
	 }
	 
	 void sendMessage(String msg)
	 {
		 message.add(msg);
	 }
	 
	 void setName(int x)
	 {
		 this.playerName = String.valueOf(x)  ;
	 }
	 
	 String getName()
	 {
	  return this.playerName;	 
	 }
	 
	 
	 
	 String getCurrentSector ()
	 {
		 return this.currentSector;
	 }
	 
	 void setCurrentSector(String name)
	 {
		 this.currentSector = name ;
	 }
	 
	void setCurrSector(Sector s)
	{
		currSector = s;
	}
	
	Sector getCurrSector()
	{
		return currSector;
	}
	  
	void playerAttacked()
	{
		attacked = true ;
	}
	
	boolean getPlayerAttacked ()
	{
		if (attacked)
			return true ;
			else return false ;
	}
}

PIECE CLASS

package efa;

import javafx.event.EventHandler;
import javafx.geometry.Point2D;
import javafx.scene.effect.BlurType;
import javafx.scene.effect.DropShadow;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.*;
import javafx.scene.text.Font;
import javafx.scene.text.Text;

import static efa.Main.map;
import static efa.Sector.hexSize;

import java.util.*;

public class Piece extends StackPane
{
 PlayerCharacter character;
 private double oldSceneX, oldSceneY;
 private double oldTranslateX, oldTranslateY;
 private double newTranslateX, newTranslateY;
 public Circle  ellipse ;
 private Sector sector = new Sector();
 private int count = 0;
 private Text pnumber = new Text();
 private Piece thisPiece = this ;
 
 public Piece(PlayerCharacter type, Integer num)
 {   
	 
     this.character = type;
     DropShadow dropShadow = new DropShadow();
     dropShadow.setBlurType(BlurType.GAUSSIAN);
     dropShadow.setColor(Color.BLACK);
     dropShadow.setOffsetX(5.0);
     dropShadow.setOffsetY(50.0);
     dropShadow.setRadius(20.0);
     
     ellipse = new Circle(hexSize * 0.32);
  
     if(this.character.equals(PlayerCharacter.HUMAN))
     {
    	 ellipse.setFill(Color.GREY) ;
     } 
     else if (this.character.equals(PlayerCharacter.ALIEN))
     {
    	 ellipse.setFill(Color.CHOCOLATE);
     }
     
     
     String number = num.toString();
     String l = "P";
     String n = l + number;
     this.setId(n);
   	 pnumber.setText(n);
   	 pnumber.setFont(Font.font(14));
   	 pnumber.setVisible(true);
   	 pnumber.toFront();
   	 pnumber.setFill(Color.BLACK);
 
     getChildren().addAll(ellipse, pnumber);

 }

 String getPieceNumber()
 {
	 return pnumber.getText();
 }
 
 void countMove()
 {
	count++;
	
 }
 
 int getCount()
 {
	 return count;
 }
 
 void resetCount()
 {
	 count = 0;
 }


 void centerOne(Sector s)
 { 
 	thisPiece.setTranslateX(s.getMidPoint().getX()+2 );//added this offsets to place the piece exactly in center 
 	thisPiece.setTranslateY(s.getMidPoint().getY()+8);//added this offsets to place the piece exactly in center
 	
 	this.sector = s;
 	
 }
 
 void centerS(Sector s)
 {
		thisPiece.setTranslateX(s.getMidPoint().getX());//
	 	thisPiece.setTranslateY(s.getMidPoint().getY());//
	 	
	 	System.out.println("We centered in sector "+s.getSectorName()); //debugging line which makes me see the error...
	 	this.sector = s;
 }
 
 
 public Sector getCurrSector()
 {
	 return sector;
 }
 
 
 void setAlive(boolean alive)
 {   
	 if(alive)
	 {	 
	  thisPiece.setDisable(false);
	  thisPiece.setOnMousePressed(circleOnMousePressedEventHandler);
	  thisPiece.setOnMouseDragged(circleOnMouseDraggedEventHandler); 
	  thisPiece.setOnMouseReleased(circleOnMouseReleasedEventHandler);
	 }
    if(!alive){thisPiece.setDisable(true);}
 }
 
 void backToPreviousPosition()
 {
	 thisPiece.setTranslateX(oldTranslateX);
	 thisPiece.setTranslateY(oldTranslateY);
 }


        EventHandler<MouseEvent> circleOnMousePressedEventHandler =     new EventHandler<MouseEvent>() 
        {

	        @Override
	        public void handle(MouseEvent t) 
	        {
	            oldSceneX = t.getSceneX();
	            oldSceneY = t.getSceneY();
	            oldTranslateX = ((Piece)(t.getSource())).getTranslateX();
	            oldTranslateY = ((Piece)(t.getSource())).getTranslateY();
	        }
	    };
	    
	    EventHandler<MouseEvent> circleOnMouseDraggedEventHandler = new EventHandler<MouseEvent>() 
	    {

	        @Override
	        public void handle(MouseEvent t) 
	        {
	            double offsetX = t.getSceneX() - oldSceneX;
	            double offsetY = t.getSceneY() - oldSceneY;
	            newTranslateX = oldTranslateX + offsetX;
	            newTranslateY = oldTranslateY + offsetY;
	           	          
	            ((Piece)(t.getSource())).setTranslateX(newTranslateX);
	            ((Piece)(t.getSource())).setTranslateY(newTranslateY);
	        
	        }
	    };
	    
	    EventHandler<MouseEvent>circleOnMouseReleasedEventHandler = new EventHandler<MouseEvent>()
	    {   
	    	@Override
		   public void handle(MouseEvent t) 
		   {
	    		 Point2D displacement = new Point2D (newTranslateX, newTranslateY); 
	   	 	     	    	
	    		 Sector outSector = null;
	    		 for(String key : Ship.findSector.keySet())
	            	{             		
	            		if(	Ship.findSector.get(key).sectorContains(displacement) )
	            		{
	               	      outSector = Ship.findSector.get(key);
	            		}
	            	   	
	            	}
	    		 
               if( displacement.distance(oldTranslateX, oldTranslateY) > (hexSize*(1.2)) 
                	|| outSector == null
            	)
            {   
                        
                ((Piece) (t.getSource())).setTranslateX(oldTranslateX);
                ((Piece) (t.getSource())).setTranslateY(oldTranslateY);
               
       		}
            
            
            else if( displacement.distance(oldTranslateX, oldTranslateY)< (hexSize*(1.5)) && outSector != null
            		 && sector.contains(displacement))
            {
            	((Piece) (t.getSource())).setTranslateX(oldTranslateX);
                ((Piece) (t.getSource())).setTranslateY(oldTranslateY);
            }
            else
            {  
            	System.out.println("Old sector Id is "+sector.getId());
            	System.out.println("New sector Id is "+outSector.getId());
            	
            	Point2D nd = new Point2D(newTranslateX, newTranslateY);
		                            			                 
            	for(String key : Ship.findSector.keySet())
            	{             		
            		if(	Ship.findSector.get(key).sectorContains(nd) )
            		{
               		 centerS(Ship.findSector.get(key));
            		 thisPiece.countMove();
            	
            		}            		
            	}  
            }
         
		   }
	    } ;
 
}

enum PLAYERCHARACTER

package efa;

public enum PlayerCharacter 
{
	  HUMAN, ALIEN;
}

SECTOR CLASS

ackage efa;



import javafx.collections.ObservableList;
import javafx.geometry.Point2D;
import javafx.scene.effect.*;
import javafx.scene.effect.DropShadow;
import javafx.scene.layout.*;
import javafx.scene.paint.Color;
import javafx.scene.shape.Polygon;
import javafx.scene.shape.StrokeType;
import javafx.scene.text.Font;
import javafx.scene.text.Text;

public class Sector extends StackPane
{   
	 static  int hexSize = 43;
	 private Polygon hex;
	 private String sectorName;
	 private SectorType sectortype;
	 private String letter;
	 private Integer number;
	 private Text text = new Text ();
	 
	 public Sector(){}
	 
	 public Sector(String name, int x, int y)
	 {   
		 sectorName = name ;
		 this.setId(name);
		 hex = new Polygon();
		 
		 		 hex.getPoints().addAll(new Double[]{
				 10.0, 0.0,      //a
				 20.0, 20.0,  //b
				 48.2, 20.0,   //c
				 58.2, 0.0,    //d
				 48.2, -23.0,   //e
				 20.0, -23.0}); //f
		 
		
		 
		 hex.setFill(Color.AQUAMARINE);
		 hex.setStrokeType(StrokeType.OUTSIDE);
	     hex.setStroke(Color.web("black",1));
	     
	         DropShadow dropShadow = new DropShadow();
	        dropShadow.setBlurType(BlurType.GAUSSIAN);
	        dropShadow.setColor(Color.BLACK);
	        dropShadow.setOffsetX(5.0);
	        dropShadow.setOffsetY(10.0);
	        dropShadow.setRadius(20.0);
	        
	        Reflection reflection = new Reflection();
	        reflection.setFraction(0.7);
	        
	        Bloom bloom = new Bloom();
	        //bloom.setThreshold(0.1);
	        
	        Light.Distant light = new Light.Distant();
	        light.setAzimuth(-135.0);

	        Lighting lighting = new Lighting();
	        lighting.setLight(light);
	        lighting.setSurfaceScale(50.0);
	        
		 hex.setEffect(dropShadow);
		 hex.setEffect(lighting);
		 
		// Hex.setEffect(reflection);
		 //Hex.setEffect(bloom);
		 text.setText(name);
		 text.setFont(Font.font(12));
		 text.setVisible(true);
		 text.setFill(Color.BLACK);
		 text.setEffect(bloom);
		 
		 getChildren().addAll(hex, text);
		 
		 if(x == 0 || x % 2 == 0)
		 {	 
		 setTranslateX((x) * (hexSize)-(0.10*hexSize*x)); 
		 
		 setTranslateY((y-3) * hexSize); 
		 }
		 else
		 {
			setTranslateX((x) * hexSize-(0.10*hexSize*x));
			setTranslateY(((y-3) * hexSize) + 0.5*hexSize);
		 }
	}
	 
	 
	 void setSectorName(String name)
	 {
		 this.sectorName = name;
	 }
	 
	 void setSectorType(SectorType type)
	 {
		 sectortype = type;
	 }
	 
	 SectorType getSectorType()
	 {
		 return sectortype;
	 }
	 
	 void setText(String text)
	 {
		this.text.setText(text); 
	 }
	 
	 String getSectorName()
	 {
		 return this.sectorName;
	 }
	 
	 void setNumber(int no)
	 {
		 this.number = no;
	 }
	 
	 int getNumber()
	 {
		 return this.number;
	 }
	 
	 void setLetter(String l)
	 {
		 this.letter = l;
	 }
	 
	 Polygon getHex()
	 {
		 return this.hex;
	 }
	 
	 String getLetter()
	 {
		 return this.letter;
	 }
	 
	 void setColor(String type)
	 {
		 if(type.equals("off"))
		 {
			 this.hex.setFill(Color.TRANSPARENT);
			 this.text.setVisible(false);
			 this.hex.setStroke(Color.TRANSPARENT);
			 
		 }
		 else if(type.equals("dangerous"))
		   {
			 this.hex.setFill(Color.RED);
			 text.setVisible(true);
	        }
			 else if(type.equals("secure"))
				 this.hex.setFill(Color.BLUE);
			 else if(type.equals("alien"))
				 this.hex.setFill(Color.YELLOW);
			 else if (type.equals("human"))
				 this.hex.setFill(Color.CYAN);
			 else if(type.equals("escape"))
			 {
			 this.hex.setFill(Color.GREEN);
			 this.text.setVisible(false);
			 }
	 }
	 
	 Point2D getMidPoint()
	 {
		 ObservableList <Double> points =  this.hex.getPoints();
		 double x1 = points.get(0)+this.getLayoutX();
		 double y1 = points.get(1)+this.getLayoutY();
		 
		 double x2 = points.get(6)+this.getLayoutX();
		 double y2 = points.get(7)+this.getLayoutY();
		 
		 Point2D pt = this.hex.localToScene(x1, y1);
		 
		 Point2D mid = pt.midpoint(pt);
		 
		 return mid;
		 
	 }
	 
	 boolean sectorContains(Point2D point)
	 { 
		 Point2D pt = this.hex.sceneToLocal(point);
		 
		 if(hex.contains(pt) )
			 return true;
	     else return false;
		 	 
	 }
}

enum SECTORTYPE

package efa;

public enum SectorType 
{
	 DANGEROUS, SECURE, ESCAPE, HUMANSTART, ALIENSTART;
}

[mike Vigor]

I really do think unless one loads all the classes in an ide and actually runs this code, one may not understand the problem/error i'm talking about by just looking with his/her eyes..
so please just do that thanks

[Knute Snortum]

I pasted the classes into an IDE and ran the Main class, but I'm not sure what I'm seeing or what I'm supposed to see.  I'm assuming P1 and P2 are player one and two, and I can move them by dragging them to adjacent sectors, but I don't know what the problem is.  Sometimes  the piece moves where I drag it and sometime not, but I don't see any pattern to it.

I think you need to explain what the desired output is and what the problem is.

[mike Vigor]

Knute Snortum wrote:I pasted the classes into an IDE and ran the Main class, but I'm not sure what I'm seeing or what I'm supposed to see.  I'm assuming P1 and P2 are player one and two, and I can move them by dragging them to adjacent sectors, but I don't know what the problem is.  Sometimes  the piece moves where I drag it and sometime not, but I don't see any pattern to it.

I think you need to explain what the desired output is and what the problem is.

Thank you for trying to help...if you watch the pieces, they should always be in a sector, so in the example you have in the ide, moving a piece into a sector, that sector Id or sector name should be printed on the console, but if you look on the console, the sector name being printed on the console is different from the sector in which the piece finds itself and every sector has its name written on it in the gui so you can see with your eyes, AND INFACT, you notice sometimes the pieces dont move into the sectors, and sometimes the pieces move into empty spaces, ALL THESE should not be happening...and I'm asking if someone can help me solve this...

[Knute Snortum]

Fermi is a Ship, and Ship has static xCoord and yCoord.  Why are these two coordinates static?