This week only. Pastebin PRO Accounts Christmas Special! Don't miss out!Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Oct 30th, 2012  |  syntax: Java  |  size: 4.05 KB  |  views: 30  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
This paste has a previous version, view the difference. Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. Client -> InputThread
  2. ---------------------
  3.  
  4. package tw.client;
  5.  
  6. import java.io.IOException;
  7. import java.io.ObjectInputStream;
  8. import java.net.Socket;
  9. import java.util.Vector;
  10. import java.util.concurrent.BlockingQueue;
  11.  
  12. import tw.Projectile;
  13. import tw.Tank;
  14.  
  15.  
  16. public class InputThread extends Thread {
  17.        
  18.         private         ObjectInputStream       in                                      = null;
  19.         private         BlockingQueue           queue                           = null;
  20.         private         boolean                         running                         = true;
  21.        
  22.         private         int                                     playerNr                        = 0;
  23.         private         Vector<Tank>            updatedTanks            = null;
  24.         private         Vector<Projectile>      updatedProjectiles      = null;                
  25.        
  26.        
  27.         /**
  28.          * ClientThread constructor.
  29.          */
  30.         public InputThread(Socket socket, BlockingQueue queue) {
  31.                 this.queue = queue;
  32.                
  33.                 try {
  34.                         in = new ObjectInputStream(socket.getInputStream());
  35.                 } catch (IOException e) {
  36.                         e.printStackTrace();
  37.                 }
  38.                
  39.                 start();
  40.         }      
  41.        
  42.        
  43.         /**
  44.          * Run method, called when thread is started.
  45.          */
  46.         @SuppressWarnings("unchecked")
  47.         public void run() {            
  48.                 // Get playerNr and first tank vector
  49.                 try {
  50.                         playerNr = in.readInt();
  51.                         System.out.println("playerNr " + playerNr);
  52.                        
  53.                         updatedTanks = (Vector<Tank>) in.readUnshared();
  54.                         queue.put(updatedTanks);
  55.                 } catch (InterruptedException e2) {
  56.                         e2.printStackTrace();
  57.                 } catch (IOException e2) {
  58.                         e2.printStackTrace();
  59.                 } catch (ClassNotFoundException e2) {
  60.                         e2.printStackTrace();
  61.                 }
  62.                
  63.                 // Get entities from server
  64.                 try {
  65.                         while (running) {
  66.                                 updatedTanks = (Vector<Tank>) in.readUnshared();
  67.                                 System.out.println("Tank 0 is active: " + updatedTanks.get(0).isActive());
  68.                                 System.out.println("Tank 1 is active: " + updatedTanks.get(1).isActive());
  69.                                 sleep(5000);
  70.                         }
  71.                 } catch (IOException e) {
  72.                         e.printStackTrace();   
  73.                 } catch (ClassNotFoundException e) {
  74.                         e.printStackTrace();
  75.                 } catch (InterruptedException e) {
  76.                         e.printStackTrace();
  77.                 }
  78.         } // run       
  79.        
  80.        
  81.         /**
  82.          * Sets 'running' to 'false', stopping the input loop.
  83.          */
  84.         public void stopRunning() {
  85.                 running = false;
  86.         }
  87.        
  88.        
  89.         /**
  90.          * Getter of the property <tt>playerNr</tt>
  91.          * @return Returns playerNr
  92.          * @uml.property name="playerNr"
  93.          */
  94.         public int getPlayerNr() {
  95.                 return playerNr;
  96.         }
  97.        
  98.        
  99.         /**
  100.          * Getter of the property (vector) <tt>updatedEntitites</tt>
  101.          * @return  Returns the updatedEntities vector.
  102.          * @uml.property  name="updatedEntities"
  103.          */
  104.         public Vector<Tank> getUpdatedTanks() {
  105.                 return updatedTanks;
  106.         }
  107. }
  108.  
  109.  
  110. Server -> OutputThread
  111. ----------------------
  112.  
  113. package tw.server;
  114.  
  115. import java.io.IOException;
  116. import java.io.ObjectOutputStream;
  117. import java.net.Socket;
  118. import java.util.concurrent.BlockingQueue;
  119.  
  120.  
  121. public class OutputThread extends Thread  {
  122.        
  123.         private ObjectOutputStream      out                     = null;
  124.         private boolean                         running         = true;
  125.        
  126.         private int                                     playerNr;
  127.         private GameManager                     gm;
  128.        
  129.        
  130.         /**
  131.          * OutputThread constructor.
  132.          * @param s
  133.          * @param playerNr
  134.          * @param gm
  135.          * @throws IOException
  136.          */
  137.         public OutputThread(Socket s, int playerNr, GameManager gm) throws IOException {
  138.                 this.playerNr = playerNr;
  139.                 this.gm = gm;
  140.                
  141.                 out = new ObjectOutputStream(s.getOutputStream());
  142.                
  143.                 start();
  144.         }
  145.        
  146.        
  147.         public void run() {
  148.                
  149.                 // Send player number to client
  150.                 try {
  151.                         out.writeInt(playerNr);
  152.                 } catch (IOException e) {
  153.                         e.printStackTrace();
  154.                 }
  155.                
  156.                 // Send entities client
  157.                 try {
  158.                         while(running) {
  159.                                 out.writeUnshared(gm.getTanks());
  160.                                 System.out.println("Tank 0 is active: " + gm.getTanks().get(0).isActive());
  161.                                 System.out.println("Tank 1 is active: " + gm.getTanks().get(1).isActive());
  162.                                 sleep(5000);
  163.                         }
  164.                 } catch (IOException e1) {
  165.                         e1.printStackTrace();
  166.                 } catch (InterruptedException e) {
  167.                         e.printStackTrace();
  168.                 }
  169.         }
  170. }
  171.  
  172.  
  173. Client:
  174. Tank 0 is active: false
  175. Tank 1 is active: true
  176. Client output: 32
  177. Tank 0 is active: false
  178. Tank 1 is active: true
  179.  
  180. Server:
  181. Tank 0 is active: false
  182. Tank 1 is active: true
  183. Tank 0 is active: false
  184. Tank 1 is active: true
  185. GameManager: Action triggered!
  186. Tank 0 is active: true
  187. Tank 1 is active: false
  188. Tank 0 is active: true
  189. Tank 1 is active: false
clone this paste RAW Paste Data