groupcontroler.java

模拟电梯运行的情况。该模拟软件能根据用户的要求同时生成N部电梯和M各楼层。能满足不同楼层对电梯的请求。

		 }
		
		 for(int i=1;i<=numOfFloor;i++){
			 if(group[t].stop[i]==1||group[t].upStop[i]==1||group[t].downStop[i]==1){
				 group[t].lowestCall=i;
				 break;
			 }else{
				 group[t].lowestCall=0;
			 }
		 }	
		 
		 setState(t,0);
	}
	
	
	
	
	
    void testStop(int callLift,int floor){
    	int t=callLift;
    	if(group[t].stop[floor]==1){
    		group[t].cageTimer.stop();
    		group[t].stop[floor]=0;
    		group[t].innerBtn.stopButton[floor].setForeground(Color.BLACK);
    		
    		if(group[t].state==GODOWN&&downCalls[floor]==1){
    			group[t].downStop[floor]=0;
    			
    			cancelAllDownstop(floor);
    			downCalls[floor]=0;
    			researchAll(t);
    			
    			
    			setDownButtonBlack(floor);
    			
    		}
    		
    		if(group[t].state==GOUP&&upCalls[floor]==1){
  			group[t].upStop[floor]=0;
    			
    			cancelAllUpstop(floor);
  		        upCalls[floor]=0;
  		        researchAll(t);
  		        
  		        
  		        
    			
    			setUpButtonBlack(floor);
    		}
    		group[t].gateTimer.start();
    		group[t].ifOpen=true;
    	}
    		
    	
    	else if(group[t].state==GODOWN&&downCalls[floor]==1){
    		group[t].cageTimer.stop();
    		group[t].downStop[floor]=0;
    		outBtn.DOWN[floor].setForeground(Color.BLACK);
    		setDownButtonBlack(floor);
    		
			cancelAllDownstop(floor);
		    downCalls[floor]=0;
		    researchAll(t);
    		
    		group[t].gateTimer.start();
    		group[t].ifOpen=true;
    	}	
    	
    	
         else if(group[t].state==GOUP&&upCalls[floor]==1){
   		group[t].cageTimer.stop();
    		group[t].upStop[floor]=0;
    		outBtn.UP[floor].setForeground(Color.BLACK);
    		setUpButtonBlack(floor);
    		
    		
  		cancelAllUpstop(floor);
		    upCalls[floor]=0;
		    researchAll(t);
    		
    		group[t].gateTimer.start();
    		group[t].ifOpen=true;
		}else if(group[t].state==GOUP&&floor==group[t].toppestCall){
    		
			
			
			if(downCalls[floor]==1&&group[t].upStop[floor]==0){
 			
    			group[t].cageTimer.stop();
    			group[t].downStop[floor]=0;
        		
        		setDownButtonBlack(floor);
        		group[t].state=GODOWN;
        		group[t].liftState.liftInfo3.setText("运动方向：↓");
        		group[t].gateTimer.start();
    			group[t].ifOpen=true;
    			
    			
  			   cancelAllDownstop(floor);
    		    downCalls[floor]=0;
    		    researchAll(t);
    			
    		}		
    	}else if(group[t].state==GODOWN&&floor==group[t].lowestCall){
    		
    		
    		if(upCalls[floor]==1&&group[t].downStop[floor]==0){
    		
    		
   			group[t].cageTimer.stop();
    			
    			
     			cancelAllUpstop(floor);
    		    upCalls[floor]=0;
    		    researchAll(t);
    			
    			
        		
        		setUpButtonBlack(floor);
        		group[t].state=GOUP;
        		group[t].liftState.liftInfo3.setText("运动方向：↑");
        		group[t].gateTimer.start();
    			group[t].ifOpen=true;
    		}		
    	}else if(floor==numOfFloor||floor==1){
    		group[t].state=FREE;
    		group[t].gateTimer.start();
    		group[t].ifOpen=true;  	
    	}	
    }
    
    
    //多电梯调度
    //＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃
    // 进行全面搜索最合适的电梯  callLift是发出up请求的电梯,upRequest是up请求的楼层
    public  void upChoose(int upCallFloor){
		  int success=0;
		  
		  setUpButtonRed(upCallFloor);
		 
		  selecctMinDiatance(upCallFloor);
		  
		  for(int i=1;i<=numOfLift;i++){
			  success=upChooseForOne(minOrder[i],upCallFloor);
			  if(success==1){
				  upAlloateFail[upCallFloor]=0;
				  searchToppestLowest(minOrder[i]);
				  break;
			  }
		  }
		  if(success==0){
			  for(int i=1;i<=numOfLift;i++){
				  if(group[minOrder[i]].state==FREE){
					  upAlloateFail[upCallFloor]=0;
					  success=1;
					  group[minOrder[i]].upStop[upCallFloor]=1;
					  searchToppestLowest(minOrder[i]);
					  break;
				  }
			  }
		  }
		  if(success==0)
			  upAlloateFail[upCallFloor]=1;
	}
    
    
    
    //// 进行全面搜索最合适的电梯  callLift是发出down请求的电梯,downCallFloor是down请求的楼层
    public  void downChoose(int downCallFloor){
		  int success=0;
		  setDownButtonRed(downCallFloor);
		  selecctMinDiatance(downCallFloor);
		  for(int i=1;i<=numOfLift;i++){
			  success=downChooseForOne(minOrder[i],downCallFloor);
			  if(success==1){
				  downAlloateFail[downCallFloor]=0;
				  searchToppestLowest(minOrder[i]);
				  
				  break;
			  }
		  }
		  if(success==0){
			  for(int i=1;i<=numOfLift;i++){
				  if(group[minOrder[i]].state==FREE){
					  downAlloateFail[downCallFloor]=0;
					  success=1;
					  group[minOrder[i]].downStop[downCallFloor]=1;
					  searchToppestLowest(minOrder[i]);
					  break;
				  }
			  }
		  }
		  if(success==0)
			  downAlloateFail[downCallFloor]=1;
	  }
    
    
    
    
    
    public  void selecctMinDiatance(int callFloor){
  	  
    int callHeight=(callFloor-1)*group[1].cage.heightOfFloor;
  	  //从所选的电梯开始存入每台电梯的当前位置与请求楼层间的距离
  	  for(int i=1;i<=numOfLift;i++)
  		  distance[i]=Math.abs(group[i].cage.currentHeight-callHeight);
  	
  	  int req=((int)(Math.random()*numOfLift))+1;
  	  for(int i=1;i<=numOfLift;i++){
  		  int k=i;
  		  for(int j=1;j<=numOfLift;j++){
  		      if(distance[j]<distance[k])
  		    	  k=j; 
  		  }
  		  if(distance[req]==distance[k]){
   			 k=req;
   			 req=(req+1)%(numOfLift+1);
  		  }	 
  		  minOrder[i]=k;
      	  distance[k]=numOfLift+100000;
  	  }
   }
    
   
    
    //对1个电梯up进行搜索,成功后返回1
 /*  public  int  upChooseForOne(int callLif,int upCallFloor){
  	  if(group[callLif].state==GOUP
  			  &&group[callLif].floor<=upCallFloor){
  		  group[callLif].upStop[upCallFloor]=1;
            return 1;
  	  }else if(group[callLif].state==UNDONE){
  		  group[callLif].upStop[upCallFloor]=1;
  		  return 1;
  	  }
  	  return 0;
   }
  */
   
   
  /* //对1个电梯down进行搜索,成功后返回1
   public  int  downChooseForOne (int callLif,int downCallFloor){
 	  if(group[callLif].state==GODOWN
 			  &&group[callLif].floor>=downCallFloor){
 		  group[callLif].downStop[downCallFloor]=1;
           return 1;
 	  }else if(group[callLif].state==UNDONE){
 		  group[callLif].downStop[downCallFloor]=1;
 		  return 1;
 	  }
 	      return 0;
 	  
   }
 */  

   
   
   //对全部电梯的up搜索失败后,选择自己
  /* public  void  ChooseFail(int callLift,int callFloor,int ifUp){
 	  //需要改进
 	 //##################################################
 	   if(ifUp==1){
 	      group[callLift].upStop[callFloor]=1;
 	   }else{
 		  group[callLift].downStop[callFloor]=1;
 	   }
 	   searchToppestLowest(callLift);
   }
   
   */
   
   
  public  void setUpButtonBlack(int floor){
  	 for(int i=1;i<=numOfLift;i++){
  		 outBtn.UP[floor].setForeground(Color.BLACK);
  	 }
   }
   
   
   public  void setUpButtonRed(int floor){
  	 for(int i=1;i<=numOfLift;i++){
  		outBtn.UP[floor].setForeground(Color.RED);
  	 }
   }
   
   public  void setDownButtonBlack(int floor){
  	 for(int i=1;i<=numOfLift;i++){
  		outBtn.DOWN[floor].setForeground(Color.BLACK);
  	 }
   }
   
   
   public  void setDownButtonRed(int floor){
  	 for(int i=1;i<=numOfLift;i++){
  		outBtn.DOWN[floor].setForeground(Color.RED);
  	 }
   }
 
  ///////////////////////////////cesi
   //对1个电梯up进行搜索,成功后返回1
   public  int  upChooseForOne(int callLif,int upCallFloor){
	   int callHeight=(upCallFloor-1)*group[1].cage.heightOfFloor;
    	  if(group[callLif].state==GOUP){
    		  if(group[callLif].floor<upCallFloor){
    		      group[callLif].upStop[upCallFloor]=1;
    		     
    		      
                  return 1;
    		  }else if(group[callLif].floor==upCallFloor&&group[callLif].cage.relativeHeight==0){ 
    			  group[callLif].upStop[upCallFloor]=0;

    			  //#################upCalls test
    		      upCalls[upCallFloor]=0;
    		      
    			  setUpButtonBlack(upCallFloor);
    			  group[callLif].gateTimer.start();
    		      group[callLif].ifOpen=true; 
                  return 1;
    		  }
    	  }else if(group[callLif].state==FREE){
    		  if(group[callLif].cage.floor<upCallFloor){
    			  group[callLif].upStop[upCallFloor]=1;
    			  return 1;
    		  }else if(group[callLif].cage.floor==upCallFloor&&group[callLif].cage.relativeHeight==0){
    			  group[callLif].upStop[upCallFloor]=1;
    		      return 1;
    		  }
    	  }
    	  return 0;
   }
   
   
   
   
// 对1个电梯down进行搜索,成功后返回1
   public  int  downChooseForOne (int callLif,int downCallFloor){
 	  if(group[callLif].state==GODOWN){
 		 if(group[callLif].floor>downCallFloor){
 		    group[callLif].downStop[downCallFloor]=1;
            return 1;
 		 }else if(group[callLif].floor==downCallFloor&&group[callLif].cage.relativeHeight==0){
 			group[callLif].downStop[downCallFloor]=0;
 			downCalls[downCallFloor]=0;
 			setDownButtonBlack(downCallFloor);
 			
 			group[callLif].gateTimer.start();
		    group[callLif].ifOpen=true; 
            return 1; 
 		 }   
 	  }else if(group[callLif].state==FREE){
 		 if(group[callLif].cage.floor>downCallFloor){
			  group[callLif].downStop[downCallFloor]=1;
			  return 1;
		  }else if(group[callLif].cage.floor==downCallFloor&&group[callLif].cage.relativeHeight==0){
			  group[callLif].downStop[downCallFloor]=1;
		      return 1;
		  }
 	  }
 	  return 0;
 	  
   }
   
   
   
   void setColorFloorNum(int lift,int floor){
	   for(int i=1;i<=numOfFloor;i++)
		   group[lift].tag.floorNum[i].setForeground(Color.BLUE);
	   group[lift].tag.floorNum[floor].setForeground(Color.RED);
	   
   }
    
  void  researchAll(int j){
	   for(int i=1;i<=numOfLift;i++)
	   if(i!=j)searchToppestLowest(i);
   }
   
   void cancelAllUpstop(int j){
	   for(int i=1;i<=numOfLift;i++)
		   group[i].upStop[j]=0;
   }
   void cancelAllDownstop(int j){
	   for(int i=1;i<=numOfLift;i++)
		   group[i].downStop[j]=0;
   }
}