new text document (3).txt

用java写的股票交易游戏

import java.util.ArrayList;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Vector;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.rmi.*;
import java.rmi.server.*;
import java.util.*;
import java.util.concurrent.Semaphore;
import java.rmi.registry.*;
public class StockExchange extends UnicastRemoteObject implements StockExchangeinterface{
	static ArrayList<CompanyInformation> company = null;  // records the information of the company 
	static ArrayList<PlayerSellInformation> playersell = null;   // records the information of the player sell
	static ArrayList<PlayerbuyInformation> playerbuy = null;  //records the information of the player buy
	//private static Semaphore semaphore1=new Semaphore(1);
	//private static Semaphore semaphore2=new Semaphore(1);
	private static int endstatus=1;

	private static Vector callbackObjects;
	private static int token=1;
    private static Vector playername;    // when the lost connection happens, then this will be 
    // useful to tell other players.
	private static Vector queue;
	StockExchange()throws RemoteException{
		super();
		 playername=new Vector();
		 callbackObjects = new Vector();
		 company=new ArrayList<CompanyInformation>();  
		 playersell=new ArrayList<PlayerSellInformation>();
		 playerbuy=new ArrayList<PlayerbuyInformation>();
		 queue=new Vector();
	} // constructor
	

	public void requesttoken(PlayerCallBackInterface g){             // Central Server Algorithm	
		try{
			if(this.token==1){
			g.SetMyturn(this.token);			
			this.token=0;
			}
			else{
				queue.addElement(g);
				System.out.println("in"+" "+g.getName());
		        
		}
		}
		catch(Exception e){			
		}
		}
			
	public void releasetoken(){
		this.token=1;
		try{
		PlayerCallBackInterface g=(PlayerCallBackInterface)queue.firstElement();
		System.out.println("out"+" "+g.getName());
		queue.removeElementAt(0);		
		g.SetMyturn(this.token);
		}
		
		catch(Exception e){			
		}
	}
	
    private static void callback(String name1,String name2,int n,String name3) {
        // the server calls the clients in the list when the data is updated  	
        
         for (int i = 0; i < callbackObjects.size(); i++)  {
           // convert the vector object to a callback object
           PlayerCallBackInterface player = (PlayerCallBackInterface) callbackObjects.elementAt(i);
            try{
                 player.printInformation(name1, name2, n, name3);
      
           }
           catch(Exception ex){
           }
         }
    }//end callback
    public void show(PlayerCallBackInterface g)      // show current company situation
    {  
    	try{
    	g.show11();}
    	catch(Exception e){    		
    	}
    	for(int i=0;i<company.size();i++){
    	try{
    		g.show1(company.get(i).getcompanyName(),company.get(i).getName(),company.get(i).getprice(),
    				company.get(i).getStockNumber());    		
    	}
    	catch(Exception e){
    		}
    	}}
    public void show2(PlayerCallBackInterface g){       // show current player information
    	try{
    		
    	     g.show22();
    	}
    	catch(Exception e){
    		
    	}
    	for(int i=0;i<playersell.size();i++){
    		try{
    		g.show2(playersell.get(i).getplayerName(),playersell.get(i).getstockName(),
    				playersell.get(i).getsellprice(),playersell.get(i).getStockNumber());}
    		catch(Exception e){
    			   		}
    		
    	}
    	try{
    		g.show44();
    		g.show33();
    	}
    	catch(Exception e){
    		
    	}
    	for(int i=0;i<playerbuy.size();i++){
    		try{
    		g.show3(playerbuy.get(i).getplayerName(),playerbuy.get(i).getstockName(),
    				playerbuy.get(i).getbuyprice(),playerbuy.get(i).getStockNumber());}
    		catch(Exception e){
    			   		}
    	}
    }
	private static void startRegistry(int RMIPortNum)throws RemoteException{
	     try {
	 	 Registry registry= LocateRegistry.getRegistry(RMIPortNum);
	 	 registry.list( );  
	 	
	 }
	 catch (RemoteException ex) {
	   // No valid registry at that port.
	       System.out.println(
	       "RMI registry cannot be located at port " + RMIPortNum);
	       Registry registry= LocateRegistry.createRegistry(RMIPortNum);
	       System.out.println( "RMI registry created at port " + RMIPortNum);
	 }
	 } // end startRegistry 
	
	public void addCallback(String name,PlayerCallBackInterface CallbackObject){    // to record the address of the player;
		// the function is to give each transcation to the all players
		callbackObjects.addElement (CallbackObject);
		playername.addElement(name);		
		try{
		for(int i = 0; i < callbackObjects.size(); i++){
			PlayerCallBackInterface player = (PlayerCallBackInterface) callbackObjects.elementAt(i);
			player.show4(name);
		}}
		catch(Exception e){
			
		}
			}
	
public void InitializeCompany(String companyName,String StockName,double price,int StockNumber,CompanyCallBackInterface g) {
	      company.add(new CompanyInformation(companyName,StockName,price,StockNumber,g));
	      System.out.println(companyName+""+StockName);
	 //     System.out.println(company+" "+StockName+" "+sellprice+" "+buyprice+" "+StockNumber);
} //end InitializeCompany

public void PlayerSell(String player,String StockName,double sellprice,int StockNumber,PlayerCallBackInterface g){
	try{   
		//semaphore1.acquire();
		find1(player,StockName,sellprice,StockNumber,g);
		//playersell.add(new PlayerSellInformation(player,StockName,sellprice,StockNumber,g));
		//System.out.println(player+" "+StockName+" "+sellprice+" "+StockNumber);  
		
	}
	catch(Exception e){		
	}
	
	//	semaphore1.release();
	
}    // put the sell information on the StockExchange


public void find1(String player,String StockName,double sellprice,int StockNumber,PlayerCallBackInterface g){    //to find the hightest buyprice 
	int n;    // for company
	int m;// for player
	double n1;  // for company
	double m1;   // for player
	double averageprice=0;   // finaly price
	while(StockNumber>0){
		 int ll=(int)(Math.random()*2); // 0 means the company rejects the bid while 1 means accepting		 
		 System.out.println("ll"+" "+ll);
		 n=0;    // for company
	     m=0;// for player
		 n1=0;  // for company
		 m1=0;   // for player
		 for(int i=0;i<company.size();i++){			 
			    if(company.get(i).getName().equals(StockName)){
			    n=i;
			    //System.out.println(i);
			    n1=company.get(i).getprice();
			    }
			    }
		// System.out.println("n"+"="+n);
		 for(int i=0;i<playerbuy.size();i++){
			    if(playerbuy.get(i).getstockName().equals(StockName)&&playerbuy.get(i).getbuyprice()>m1&&!(playerbuy.get(i).PlayerCallback()==g)){
			    m=i;
			    m1=playerbuy.get(i).getbuyprice();
			    }
			    }
		
	    if(sellprice<=n1&&n1>=m1&&ll==1){        // to choose the company
		CompanyInformation targetcom=company.get(n);
		//System.out.println("n"+n);
		CompanyCallBackInterface targetcompany = (CompanyCallBackInterface)targetcom.Companycallback();		
		averageprice=(sellprice*StockNumber+targetcom.getprice()*targetcom.getStockNumber())/(targetcom.getStockNumber()+StockNumber);
		averageprice=(double)Math.round(averageprice*100)/100;   
		try{
		targetcompany.BuyStock(StockNumber,sellprice);
		g.SellStock(StockName, StockNumber,averageprice);
		callback(targetcom.getcompanyName(),player,StockNumber,StockName);
		System.out.println("tr");
		}
		catch(Exception e){
			}   // end try
		//targetcompany.SellStock(StockNumber);
		finally{
			StockNumber=0;
		}
		
	}
	    else if((sellprice>m1&&sellprice>n1)||(sellprice<=n1&&m1==0&&ll==0)){
		   playersell.add(new PlayerSellInformation(player,StockName,sellprice,StockNumber,g));
		   break;
	   }
	    else if((sellprice<=m1&&m1>n1)||(sellprice<=n1&&n1>=m1&&ll==0)){          // to choose the player 
		   PlayerbuyInformation targetpla=playerbuy.get(m);
		   PlayerCallBackInterface targetplayer=(PlayerCallBackInterface)targetpla.PlayerCallback();
		   averageprice=(sellprice*StockNumber+targetpla.getbuyprice()*targetpla.getStockNumber())/(targetpla.getStockNumber()+StockNumber);
		   averageprice=(double)Math.round(averageprice*100)/100;   
		   int finallyStockNumber;
		   try{			  
			   if(StockNumber>=targetpla.getStockNumber()){ 
				   // it is impossible to self-sell, since it is a trick 
				   finallyStockNumber=targetpla.getStockNumber();
				   if(targetplayer.getBalance()>=(finallyStockNumber*averageprice)){
					   g.SellStock(StockName,finallyStockNumber,averageprice);
					   targetplayer.BuyStock(StockName,finallyStockNumber,averageprice);
					   callback(targetpla.getplayerName(),player,finallyStockNumber,StockName);
					   playerbuy.remove(m);
					   StockNumber-=targetpla.getStockNumber();
					   //System.out.println("twic");
					   continue;
				   }
				   else {
					   playerbuy.remove(m);
					   playersell.add(new PlayerSellInformation(player,StockName,sellprice,StockNumber,g));
					   continue;
				   }
				 //  finallyStockNumber=targetpla.getStockNumber();
				//   playerbuy.remove(m);
			   }
			   else if(StockNumber<targetpla.getStockNumber()){
				  // finallyStockNumber=StockNumber;
				   if(targetplayer.getBalance()>=(StockNumber*averageprice)){
				   targetpla.SetStockNumber((targetpla.getStockNumber()-StockNumber));	
				   g.SellStock(StockName,StockNumber,averageprice);
				   targetplayer.BuyStock(StockName,StockNumber,averageprice);
				   callback(targetpla.getplayerName(),player,StockNumber,StockName);
				   StockNumber=0;
			   }
				   else{
					   playerbuy.remove(m);
					   playersell.add(new PlayerSellInformation(player,StockName,sellprice,StockNumber,g));
					   continue;  
				   }
			   }
		   }
		   catch(Exception e){
			   }
	   }
	}	
}// end find1

public void PlayerBuy(String player,String StockName,double buyprice,int StockNumber,PlayerCallBackInterface g){ 
	// to find the lowest sellprice
	try{
	//	semaphore1.acquire();
	find2(player,StockName,buyprice,StockNumber,g);}
	catch(Exception ex){		
	}
	
//	semaphore1.release();	
	
}

	public void find2(String player,String StockName,double buyprice,int StockNumber,PlayerCallBackInterface g){
		int n;    // for company
		int m;// for player
		double n1;  // for company
		double m1;   // for player
		double averageprice=0;   // finally price
		while(StockNumber>0){
			 int mm=(int)(Math.random()*2);    // 1 meanas the company will accept while 0 means the compnay will reject
			 System.out.println("mm"+""+mm);
			 n=0;    // for company
		     m=0;// for player
			 n1=100000000;  // for company
			 m1=100000000;   // for player
			 for(int i=0;i<company.size();i++){			 
				    if(company.get(i).getName().equals(StockName)){