player.java

人工智能中Agent开发包。多 Agent 系统是处理自治 Agent 之间知识层的协作问题

/*
* The contents of this file are subject to the BT "ZEUS" Open Source 
* Licence (L77741), Version 1.0 (the "Licence"); you may not use this file 
* except in compliance with the Licence. You may obtain a copy of the Licence
* from $ZEUS_INSTALL/licence.html or alternatively from
* http://www.labs.bt.com/projects/agents/zeus/licence.htm
* 
* Except as stated in Clause 7 of the Licence, software distributed under the
* Licence is distributed WITHOUT WARRANTY OF ANY KIND, either express or 
* implied. See the Licence for the specific language governing rights and 
* limitations under the Licence.
* 
* The Original Code is within the package zeus.*.
* The Initial Developer of the Original Code is British Telecommunications
* public limited company, whose registered office is at 81 Newgate Street, 
* London, EC1A 7AJ, England. Portions created by British Telecommunications 
* public limited company are Copyright 1996-9. All Rights Reserved.
* 
* THIS NOTICE MUST BE INCLUDED ON ANY COPY OF THIS FILE
*/



/*******************************************************************
 *                    Video Tools for Zeus                         *
 *   Provides functionality to use record and playback feature     *
 *******************************************************************/

package zeus.visualiser.basic;

import java.util.*;
import javax.swing.*;

import zeus.util.*;
import zeus.gui.*;
import zeus.concepts.*;
import zeus.actors.*;


public class Player extends Thread {
  static final int COUNT = 0;
  static final int LIST = 1;
  static final int NEXT = 2;
  static final int PRIOR = 3;
  static final int FIRST = 4;
  static final int LAST = 5;
  static final int OPEN = 6;
  static final int CLOSE = 7;
  static final int READY = 8;
  static final int STOP = 9;

  private static long CDEFAULT_SPEED = 1000;
  private long DEFAULT_SPEED = CDEFAULT_SPEED;

  protected VideoTool video;

  private int max_count = -1;
  private int cmd = OPEN;
  private boolean playback = true;
  private boolean single_step = false;
  private long timeout;

  void setSpeed(long speed) { DEFAULT_SPEED = speed; }
  long getSpeed()           { return DEFAULT_SPEED; }

  static long getDefaultSpeed()       { return CDEFAULT_SPEED; }
  static void setDefaultSpeed(long s) { CDEFAULT_SPEED = s; }

  Player(VideoTool video) {
    Assert.notNull(video);
    this.video  = video;

    this.setPriority(Thread.NORM_PRIORITY-2);
    this.start();
  }

  private boolean ready() {
    switch( cmd ) {
    case READY:
    case NEXT:
    case PRIOR:
      return true;
    default:
      return false;
    }
  }

  synchronized void first() {
    if ( !ready() ) return;
    cmd = FIRST;
    single_step = false;
    timeout = DEFAULT_SPEED;
    notify();
  }

  synchronized void last() {
    if ( !ready() ) return;
    cmd = LAST;
    single_step = false;
    timeout = DEFAULT_SPEED;
    notify();
  }

  synchronized void forward_step() {
    if ( !ready() ) return;
    cmd = NEXT;
    single_step = true;
    timeout = DEFAULT_SPEED;
    notify();
  }

  synchronized void rewind_step() {
    if ( !ready() ) return;
    cmd = PRIOR;
    single_step = true;
    timeout = DEFAULT_SPEED;
    notify();
  }

  synchronized void forward() {
    if ( !ready() ) return;
    cmd = NEXT;
    single_step = false;
    timeout = DEFAULT_SPEED;
    notify();
   }

  synchronized void rewind() {
    if ( !ready() ) return;
    cmd = PRIOR;
    single_step = false;
    timeout = DEFAULT_SPEED;
    notify();
  }

  synchronized void fforward() {
    if ( !ready() ) return;
    cmd = NEXT;
    single_step = false;
    timeout = DEFAULT_SPEED/2;
    notify();
  }

  synchronized void frewind() {
    if ( !ready() ) return;
    cmd = PRIOR;
    single_step = false;
    timeout = DEFAULT_SPEED/2;
    notify();
  }

  synchronized void pause() {
    if ( !ready() ) return;
    cmd = READY;
    single_step = false;
    timeout = DEFAULT_SPEED;
  }

  synchronized void terminate() {
    playback = false;
    cmd = STOP;
    notify();
  }

  private boolean running() {
    switch( cmd ) {
       case NEXT:
       case PRIOR:
       case FIRST:
       case LAST:
       case STOP:
            return true;
       default:
            return false;
    }
  }

  void setCommand(int cmd) {
     this.cmd = cmd;
  }

  void setCount(int max) {
     this.max_count = max;
  }

  public void run() {
     int count = 0;
     while( playback ) {
        try {
           synchronized(this) {
              while( !running() )
                 wait();
           }
           if ( cmd == STOP ) return;

           if ( (cmd == NEXT  && count < max_count) ||
                (cmd == PRIOR && count > 0) ) {

              if ( cmd == NEXT )
  	         count++;
              else if ( cmd == PRIOR )
                 count--;

              if ( cmd == NEXT )
                 video.doPlayerCommand("db_next");
              else
	         video.doPlayerCommand("db_prior");

              if ( single_step )
	         cmd = READY;
              else
                 sleep(timeout);
           }
           else if ( cmd == FIRST || cmd == LAST ) {
              count = (cmd == FIRST) ? 0 : max_count;

              if ( cmd == FIRST )
	         video.doPlayerCommand("db_first");
              else
                 video.doPlayerCommand("db_last");

              single_step = false;
              cmd = READY;
           }
           else {
              synchronized(this) {
                 wait();
              }
           }
        }
        catch(InterruptedException e) {
        }
     }
  }
}