public void end() {
done = true;
printStatistics();
this.interrupt();
synchronized (workerThreads) {
workToDo.clear();
workerThreads.notifyAll();
}
for (int i = 0; i < workerThreads.size(); i++) {
((WorkerThread) workerThreads.get(i)).done();
}
}
/** {@inheritDoc} */
public void destroy() {
started.set(false);
destroyed.set(true);
releaseExternalResources();
if (notifierFuture != null) {
notifierFuture.cancel(true);
}
if (asyncWriteFuture != null) {
asyncWriteFuture.cancel(true);
}
if (bc != null) {
bc.destroy();
}
if (broadcasterCache != null) {
broadcasterCache.stop();
}
resources.clear();
broadcastOnResume.clear();
messages.clear();
asyncWriteQueue.clear();
delayedBroadcast.clear();
broadcasterCache = null;
if (BroadcasterFactory.getDefault() != null) {
BroadcasterFactory.getDefault().remove(this, name);
}
if (currentLifecycleTask != null) {
currentLifecycleTask.cancel(true);
}
}
@Override
protected void finalize() throws Throwable {
super.finalize();
synchronized (DevMountInfo.class) {
mInternalPathList.clear();
mExternalPathList.clear();
mExecutor.shutdown();
INSTANCE = null;
}
}
@Override
public void update(float tpf) {
super.update(tpf);
runningCommands.addAll(pendingCommands);
pendingCommands.clear();
for (PHATDeviceCommand bc : runningCommands) {
bc.run(app);
}
runningCommands.clear();
}
@SuppressWarnings("synthetic-access")
@Override
public void clear() {
super.clear();
getSaveInLdapAction().setEnabled(false);
firePropertyChange(ISaveablePart.PROP_DIRTY);
}
@Override
public void cancelAllTasks() {
for (PipeTask task : queuedTasks) {
task.cancel0();
}
queuedTasks.clear();
}
/** 停止所有任务 */
public void stopAllTask() {
// 从下载队列移除
for (Map.Entry<String, DownloadHttpTask> entry : mDownloadingTaskMap.entrySet()) {
DownloadHttpTask task = entry.getValue();
task.setInterrupt(true);
}
mDownloadingTaskMap.clear();
Iterator<DownloadInfo> downloadingIt = mDownloadingTasks.iterator();
while (downloadingIt.hasNext()) {
DownloadInfo b = downloadingIt.next();
b.setState(DownloadInfo.PAUSE);
downloadingIt.remove();
mPausingTasks.add(b); // 放入暂停队列
}
mDownloadingTasks.clear();
// 从等待队列移除
Iterator<DownloadInfo> waitIt = mWaitTasks.iterator();
while (waitIt.hasNext()) {
DownloadInfo b = waitIt.next();
b.setState(DownloadInfo.PAUSE);
waitIt.remove();
mPausingTasks.add(b); // 放入暂停队列
break;
}
mWaitTasks.clear();
}
/** Completely reset the instance to its initial state. */
public void reset() {
isResumed.set(false);
isCancelled.set(false);
isInScope.set(true);
isSuspendEvent.set(false);
listeners.clear();
action.type(Action.TYPE.CREATED);
}
protected void sendUpdates() {
// get the current version
int currentVersion = version.get();
//
boolean persist = isPersistentObject();
// get read-only version of events
ConcurrentLinkedQueue<ISharedObjectEvent> events =
new ConcurrentLinkedQueue<ISharedObjectEvent>(ownerMessage.getEvents());
// clear out previous events
ownerMessage.getEvents().clear();
//
if (!events.isEmpty()) {
// Send update to "owner" of this update request
SharedObjectMessage syncOwner = new SharedObjectMessage(null, name, currentVersion, persist);
syncOwner.addEvents(events);
if (source != null) {
// Only send updates when issued through RTMP request
Channel channel = ((RTMPConnection) source).getChannel((byte) 3);
if (channel != null) {
// ownerMessage.acquire();
channel.write(syncOwner);
log.debug("Owner: {}", channel);
} else {
log.warn("No channel found for owner changes!?");
}
}
}
// clear owner events
events.clear();
// get read-only version of sync events
events.addAll(syncEvents);
// clear out previous events
syncEvents.clear();
if (!events.isEmpty()) {
// Synchronize updates with the current listeners of this shared
for (IEventListener listener : currentListeners) {
if (listener == source) {
// Don't re-send update to active client
log.debug("Skipped {}", source);
continue;
}
if (!(listener instanceof RTMPConnection)) {
log.warn("Can't send sync message to unknown connection {}", listener);
continue;
}
// Create a new sync message for every client to avoid
// concurrent access through multiple threads
// TODO: perhaps we could cache the generated message
SharedObjectMessage syncMessage =
new SharedObjectMessage(null, name, currentVersion, persist);
syncMessage.addEvents(events);
Channel channel = ((RTMPConnection) listener).getChannel((byte) 3);
log.debug("Send to {}", channel);
channel.write(syncMessage);
}
}
}
public void clearAllMessages() {
if (messages.size() > 0) {
Debug.warn(
"Message inbox of "
+ username
+ " contained "
+ messages.size()
+ " extra messages, discarding...");
}
messages.clear();
}
/** This method cleans fields that are irrelevant for the archived execution attempt. */
public void prepareForArchiving() {
if (assignedResource != null && assignedResource.isAlive()) {
throw new IllegalStateException(
"Cannot archive Execution while the assigned resource is still running.");
}
assignedResource = null;
executionContext = null;
partialInputChannelDeploymentDescriptors.clear();
partialInputChannelDeploymentDescriptors = null;
}
protected void broadcastOnResume(AtmosphereResource<?, ?> r) {
Iterator<Entry> i = broadcastOnResume.iterator();
while (i.hasNext()) {
Entry e = i.next();
e.multipleAtmoResources = r;
push(e);
}
if (resources.isEmpty()) {
broadcastOnResume.clear();
}
}
/** Copies the next values to the snapshot */
@Override
public void copySnapshot() {
if (dirty.size() > 0) {
snapshot.clear();
synchronized (live) {
for (T o : live) {
snapshot.add(o);
}
}
}
dirty.clear();
}
synchronized void send(JSONStreamAware response) {
if (asyncContext == null) {
if (isInactive) {
// user not seen recently, no responses should be collected
return;
}
if (pendingResponses.size() > 1000) {
pendingResponses.clear();
// stop collecting responses for this user
isInactive = true;
if (secretPhrase == null) {
// but only completely remove users that don't have unlocked accounts
Users.remove(this);
}
return;
}
pendingResponses.offer(response);
} else {
JSONArray responses = new JSONArray();
JSONStreamAware pendingResponse;
while ((pendingResponse = pendingResponses.poll()) != null) {
responses.add(pendingResponse);
}
responses.add(response);
JSONObject combinedResponse = new JSONObject();
combinedResponse.put("responses", responses);
asyncContext.getResponse().setContentType("text/plain; charset=UTF-8");
try (Writer writer = asyncContext.getResponse().getWriter()) {
combinedResponse.writeJSONString(writer);
} catch (IOException e) {
Logger.logMessage("Error sending response to user", e);
}
asyncContext.complete();
asyncContext = null;
}
}
private void processCameraData(
final byte[] cameraData, final int imageWidth, final int imageHeight) {
cameraPreviewCallbackQueue.clear();
boolean offerSuccess =
cameraPreviewCallbackQueue.offer(
new Runnable() {
@Override
public void run() {
long start = System.nanoTime();
// Convert data to JPEG and compress
YuvImage image =
new YuvImage(cameraData, ImageFormat.NV21, imageWidth, imageHeight, null);
ByteArrayOutputStream out = new ByteArrayOutputStream();
Rect area = new Rect(0, 0, imageWidth, imageHeight);
image.compressToJpeg(area, IMAGE_QUALITY, out);
byte[] jpegVideoFrameData = out.toByteArray();
// rotate image
byte[] rotatedCameraData =
rotateImage(jpegVideoFrameData, imageWidth, imageHeight, currentCameraId);
if (rotatedCameraData.length == 0) {
return;
}
// send data to the opponent
//
cameraDataListener.onCameraDataReceive(rotatedCameraData);
//
//
// close stream
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
}
private void processNextClientRequest() {
QueueEntry qe = (QueueEntry) qClientRequests.poll();
if (qe != null) {
EventSocket sock = qe.sock;
String message = qe.message;
boolean isAllowed = false;
LockHolder lock = getLockForCommand(message);
if (lock != null) {
// if the lock exists check whether the user is allowed to use this command
int[] privs = lock.getAllowedPrivileges();
for (int priv : privs) if (priv == sock.getPrivilege()) isAllowed = true;
if (isAllowed) {
if (lockHolder == null) { // if no lock is set we try to execute the command
setLock(lock.setLockAction(message));
Debg.print("lock set and executed");
} else { // if a lock is already set the command might contain an abort message
String cmd = Parser.getValue(message, NanoComm.COMMAND_CMD);
String[] abortCmds = lockHolder.getAbortCommands();
boolean isAbortable = false;
if (abortCmds != null)
for (int i = 0; i < abortCmds.length; i++) {
if (cmd.equals(abortCmds[i])) isAbortable = true;
}
if (isAbortable) {
setLock(lockHolder.takeAbortActions("Overwriting command has been sent"));
} else sock.sendClientInfo("Please be patient, the remote experiment is still busy");
}
} else sock.sendClientInfo("Sorry, you are not allowed to use this command!");
} else Debg.print("No lock found for: " + message);
}
if (qClientRequests.size() > 10) {
Debg.err(
"I have been flooded by "
+ qClientRequests.size()
+ " client requests! I dropped everything except for the oldest one");
qe = (QueueEntry) qClientRequests.poll();
qClientRequests.clear();
qClientRequests.add(qe);
}
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
final int paddingTop = getPaddingTop();
if (needScrollCorrection) {
slide(null, 1, false);
needScrollCorrection = false;
pendingList.clear();
}
int childTop = paddingTop;
int childLeft = mOffsetLeft;
View iconView = channelIconInflateResult.rootView;
int childWidth = iconView.getMeasuredWidth();
int childHeight = iconView.getMeasuredHeight();
ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams) getLayoutParams();
childLeft += lp.leftMargin;
ViewGroup.MarginLayoutParams lpChild =
(ViewGroup.MarginLayoutParams) iconView.getLayoutParams();
childTop = getHeight() - childHeight - lpChild.bottomMargin;
childLeft += (lpChild.leftMargin);
setChildFrame(iconView, childLeft, childTop, childWidth, childHeight);
childLeft += (childWidth + lpChild.rightMargin + lpChild.leftMargin);
// childLeft -= mScrollDistance;
for (int i = 0; i < videoListViews.size(); i++) {
final View child = getChildAt(i);
childWidth = child.getMeasuredWidth();
childHeight = child.getMeasuredHeight();
lpChild = (ViewGroup.MarginLayoutParams) child.getLayoutParams();
childTop = getHeight() - childHeight - lpChild.bottomMargin;
childLeft += (lpChild.leftMargin);
setChildFrame(child, childLeft, childTop, childWidth, childHeight);
childLeft += (childWidth + lpChild.rightMargin);
}
}
private void executeInit(Context context) {
StorageManager mStorageManager =
(StorageManager) context.getSystemService(Context.STORAGE_SERVICE);
if (mStorageManager != null) {
Class<?> mStorageVolume = null;
Method mGetVolumeListMethod = null;
Method mGetVolumeStateMethod = null;
Method mGetPathMethod = null;
Method mIsRemovableMethod = null;
Object[] mStorageVolumeList = null;
try {
mStorageVolume = Class.forName(CLASS_NAME);
mGetVolumeListMethod =
mStorageManager.getClass().getMethod(METHOD_GET_VOLUME_LIST, new Class[0]);
mGetVolumeStateMethod =
mStorageManager
.getClass()
.getMethod(METHOD_GET_VOLUME_STATE, new Class[] {String.class});
mIsRemovableMethod = mStorageVolume.getMethod(METHOD_IS_REMOVABLE, new Class[0]);
mGetPathMethod = mStorageVolume.getMethod(METHOD_GET_PATH, new Class[0]);
mStorageVolumeList = (Object[]) mGetVolumeListMethod.invoke(mStorageManager, new Object[0]);
boolean mIsRemovable = false;
if (mStorageVolumeList != null && mStorageVolumeList.length > 0) {
int mStorageVolumeCount = mStorageVolumeList.length;
Log.i(TAG, "init() === > StorageVolume Count = " + mStorageVolumeCount);
mInternalPathList.clear();
mExternalPathList.clear();
for (int i = 0; i < mStorageVolumeCount; ++i) {
String mStoragePath =
(String) mGetPathMethod.invoke(mStorageVolumeList[i], new Object[0]);
mIsRemovable =
((Boolean) mIsRemovableMethod.invoke(mStorageVolumeList[i], new Object[0]))
.booleanValue();
if (!TextUtils.isEmpty(mStoragePath)) {
String state =
(String)
mGetVolumeStateMethod.invoke(mStorageManager, new Object[] {mStoragePath});
if ((state != null) && (state.equals(MOUNTED))) {
if (mIsRemovable) {
Log.i(TAG, "init() === > external storage path = (" + mStoragePath + ")");
mExternalPathList.add(mStoragePath);
} else {
Log.i(TAG, "init() === > internal storage path = (" + mStoragePath + ")");
mInternalPathList.add(mStoragePath);
}
}
}
}
}
} catch (ClassNotFoundException e) {
handleInvalid();
Log.e(TAG, "init() === > Exception:ClassNotFoundException");
} catch (NoSuchMethodException e) {
handleInvalid();
Log.e(TAG, "init() === > Exception:NoSuchMethodException");
} catch (IllegalArgumentException e) {
handleInvalid();
Log.e(TAG, "init() === > Exception:IllegalArgumentException");
} catch (IllegalAccessException e) {
handleInvalid();
Log.e(TAG, "init() === > Exception:IllegalAccessException");
} catch (InvocationTargetException e) {
handleInvalid();
Log.e(TAG, "init() === > Exception:InvocationTargetException");
}
} else {
handleInvalid();
Log.e(TAG, "init() === > can't get storage manager");
}
initSDCardPath();
}
/** {@inheritDoc} */
@Override
public synchronized AtmosphereResource resume() {
// We need to synchronize the method because the resume may occurs at the same time a message is
// published
// and we will miss that message. The DefaultBroadcaster synchronize on that method before
// writing a message.
try {
if (!isResumed && isInScope) {
action.type(Action.TYPE.RESUME);
isResumed = true;
// We need it as Jetty doesn't support timeout
Broadcaster b = getBroadcaster(false);
if (!b.isDestroyed() && b instanceof DefaultBroadcaster) {
((DefaultBroadcaster) b).broadcastOnResume(this);
}
notifyListeners();
try {
if (!b.isDestroyed()) {
broadcaster.removeAtmosphereResource(this);
}
} catch (IllegalStateException ex) {
logger.warn("Unable to resume", this);
logger.debug(ex.getMessage(), ex);
}
if (b.getScope() == Broadcaster.SCOPE.REQUEST) {
logger.debug("Broadcaster's scope is set to request, destroying it {}", b.getID());
b.destroy();
}
// Resuming here means we need to pull away from all other Broadcaster, if they exists.
if (config.getBroadcasterFactory() != null) {
config.getBroadcasterFactory().removeAllAtmosphereResource(this);
}
try {
req.setAttribute(ApplicationConfig.RESUMED_ON_TIMEOUT, Boolean.FALSE);
} catch (Exception ex) {
logger.debug("Resume exception: Cannot resume an already resumed/cancelled request", ex);
} finally {
try {
Meteor m = (Meteor) req.getAttribute(METEOR);
if (m != null) {
m.destroy();
}
} catch (Exception ex) {
logger.debug(
"Meteor resume exception: Cannot resume an already resumed/cancelled request", ex);
}
}
if (req.getAttribute(PRE_SUSPEND) == null) {
asyncSupport.action(this);
}
} else {
logger.debug("Cannot resume an already resumed/cancelled request {}", this);
}
} catch (Throwable t) {
logger.trace("Wasn't able to resume a connection {}", this, t);
}
notifyListeners(new AtmosphereResourceEventImpl(this, true, false));
listeners.clear();
return this;
}
public void clearAllTasks() {
mTaskQueue.clear();
}
public void clear() throws IOException {
queue.clear();
}
@Override
public AtmosphereResource resume() {
if (!isSuspended()) {
logger.warn("AtmosphereResource {} not suspend, cannot resume it.", uuid());
return this;
}
try {
if (!isResumed.getAndSet(true) && isInScope.get()) {
logger.trace("AtmosphereResource {} is resuming", uuid());
action.type(Action.TYPE.RESUME);
// We need it as Jetty doesn't support timeout
Broadcaster b = getBroadcaster(false);
if (!b.isDestroyed() && b instanceof DefaultBroadcaster) {
((DefaultBroadcaster) b).broadcastOnResume(this);
}
notifyListeners();
try {
if (!b.isDestroyed()) {
broadcaster.removeAtmosphereResource(this);
}
} catch (IllegalStateException ex) {
logger.warn("Unable to resume", this);
logger.debug(ex.getMessage(), ex);
}
if (b.getScope() == Broadcaster.SCOPE.REQUEST) {
logger.debug("Broadcaster's scope is set to request, destroying it {}", b.getID());
b.destroy();
}
// Resuming here means we need to pull away from all other Broadcaster, if they exists.
if (config.getBroadcasterFactory() != null) {
config.getBroadcasterFactory().removeAllAtmosphereResource(this);
}
try {
req.setAttribute(ApplicationConfig.RESUMED_ON_TIMEOUT, Boolean.FALSE);
} catch (Exception ex) {
logger.debug("Resume exception: Cannot resume an already resumed/cancelled request", ex);
} finally {
try {
Meteor m = (Meteor) req.getAttribute(METEOR);
if (m != null) {
m.destroy();
}
} catch (Exception ex) {
logger.debug(
"Meteor resume exception: Cannot resume an already resumed/cancelled request", ex);
}
}
if (req.getAttribute(PRE_SUSPEND) == null) {
asyncSupport.action(this);
}
} else {
logger.trace("Already resumed {}", this);
return this;
}
} catch (Throwable t) {
logger.trace("Wasn't able to resume a connection {}", this, t);
}
listeners.clear();
return this;
}
public void reset() {
overwriteQueue.clear();
overwriteBackup.clear();
}
public void clear() {
QUEUE.clear();
releaseCalls.set(0);
newBufferCalls.set(0);
}
@Override
public AtmosphereResource removeEventListeners() {
listeners.clear();
return this;
}
private void sendDataToMembers(ArrayList memberList) {
if (Logger.logLevel == -55) {
for (int i = 0; i < memberList.size(); i++) {
ConferenceMember m = (ConferenceMember) memberList.get(i);
Logger.println("conf " + getName() + ": " + m);
}
Logger.println("wt size " + workerThreads.size() + " sender threads " + senderThreads);
}
if (workerThreads.size() > 1 && workerThreads.size() != senderThreads) {
/*
* Stop old threads
* XXX We could just stop the extra threads or add new ones
* rather than stopping all of them.
*/
if (Logger.logLevel == -55) {
Logger.println("Stopping sender worker threads " + workerThreads.size());
}
for (int i = 0; i < workerThreads.size(); i++) {
((WorkerThread) workerThreads.get(i)).done();
}
workerThreads.clear();
}
if (senderThreads <= 1) {
singleThreadSendDataToMembers(memberList);
return;
}
CountDownLatch doneSignal = new CountDownLatch(workerThreads.size());
if (workerThreads.size() != senderThreads) {
/*
* Start new threads
*/
for (int i = 0; i < senderThreads; i++) {
workerThreads.add(new WorkerThread(i, doneSignal));
}
Logger.println("Started " + senderThreads + " sender threads");
}
workToDo.clear();
for (int i = 0; i < memberList.size(); i++) {
ConferenceMember member = (ConferenceMember) memberList.get(i);
if (member.getMemberSender().memberIsReadyForSenderData()) {
workToDo.add(member);
}
}
/*
* Start all of the worker threads
*/
for (int i = 0; i < workerThreads.size(); i++) {
WorkerThread workerThread = (WorkerThread) workerThreads.get(i);
workerThread.setLatch(doneSignal);
synchronized (workerThread) {
workerThread.notify();
}
}
if (!done) {
try {
doneSignal.await(); // wait for all to finish
} catch (InterruptedException e) {
}
}
}
public void clearqueue() {
movequeue.clear();
}
public void handleNotification(INotification notification) {
// Logger.debug("@ClientMediator.handleNotification:noti="+notification.getBody());
String noname = notification.getName();
if (noname == Const.TICK) {
if (destroyd) return;
long t = TimerCmd.timeStamp;
String[] ary;
int st, ed;
if (_lastRotTank != null) {
ary = _lastRotTank.split(" ");
st = Integer.parseInt(ary[0]);
ed = st + Integer.parseInt(ary[6]);
if (t <= ed && t >= st) {
int ist = Integer.parseInt(ary[0]);
if (_move.size() > 0) {
st = Integer.parseInt(_move.peek().split(" ")[0]);
while (st < ist && _move.size() > 0) {
_move.poll();
if (_move.size() == 0) break;
st = Integer.parseInt(_move.peek().split(" ")[0]);
}
}
}
}
if (_move.size() > 0) {
ary = _move.peek().split(" ");
st = Integer.parseInt(ary[0]);
ed = st + Integer.parseInt(ary[8]);
while ((t > ed) && _move.size() > 0) {
// Logger.debug("@TankMediator.handleNotification: t = " + t + " st = " + st + "
// ed="+ed);
String p = (String) _move.poll();
Logger.debug("ClientMediator.TICK _move.poll=" + p);
if (_move.size() == 0) break;
ary = _move.peek().split(" ");
st = Integer.parseInt(ary[0]);
ed = st + Integer.parseInt(ary[8]);
}
if (_move.size() > 0) {
String[] li = (String[]) _move.toArray(new String[0]);
for (int i = li.length - 1; i >= 0; i--) {
String s = li[i];
ary = s.split(" ");
st = Integer.parseInt(ary[0]);
ed = st + Integer.parseInt(ary[8]);
if (t <= ed && t >= st) {
if (t == st) { // ed==st in this situation
_state.x = (int) Float.parseFloat(ary[4]);
_state.y = (int) Float.parseFloat(ary[5]);
_nextX = _state.x;
_nextY = _state.y;
} else {
float sx = Float.parseFloat(ary[4]);
float ex = Float.parseFloat(ary[6]);
float sy = Float.parseFloat(ary[5]);
float ey = Float.parseFloat(ary[7]);
double eco = 1.0 * (t - st) / (ed - st);
_state.x = (int) (sx + (ex - sx) * eco);
_state.y = (int) (sy + (ey - sy) * eco);
double neco = 1.0 * (t + 1 - st) / (ed - st);
_nextX = (sx + (ex - sx) * neco);
_nextY = (sy + (ey - sy) * neco);
}
while (_move.size() > 1) _move.poll();
break;
}
}
}
}
if (_state != null) {
ConcurrentHashMap<Integer, BulletState> bs =
((ServerBulletMediator) (appFacade().retrieveMediator(Const.SERVER_BULLET_MEDIATOR)))
.getBullets();
for (Enumeration enu = bs.keys(); enu.hasMoreElements(); ) {
int id = (Integer) enu.nextElement();
BulletState blt = bs.get(id);
if (Texter.distance(blt.x, blt.y, _state.x, _state.y) < 16) {
this.sendNotification(Const.BROAD_CAST, "destroy bullet " + id, null);
_state.life -= 100;
if (_state.life <= 0) {
this.sendNotification(Const.BROAD_CAST, "destroy tank " + _state.tankID, null);
} else {
this.sendNotification(
Const.BROAD_CAST, "set-life tank " + _state.tankID + " " + _state.life, null);
}
}
}
}
// barrier and tank
if (_state != null) {
// colision detection
// Logger.only("ClientMediator.handleNotification: x="+_state.x+" y="+_state.y+"
// nx="+_nextX+" ny="+_nextY+" "+Texter.sqrareDis(_nextX, _nextY, 470, 200)+"
// "+Texter.sqrareDis(_state.x, _state.y, 470, 200));
if (!Arena.canGo(_state.x, _state.y, _nextX, _nextY)) {
Arena.addReq(_id, Const.STOP_MOVE, getState());
}
for (Enumeration enu = AcceptCmd.clients.elements(); enu.hasMoreElements(); ) {
ClientMediator cmm = (ClientMediator) enu.nextElement();
if (cmm.destroyd) return;
int cmid = cmm.getID();
if (cmid == _id) continue;
TankState ts = cmm.getState();
if (ts == null) continue;
double curdis = Texter.distance(ts.x, ts.y, _state.x, _state.y);
double netdis = Texter.distance(ts.x, ts.y, _nextX, _nextY);
if (curdis < 40 && netdis < curdis) {
Arena.addReq(_id, Const.STOP_MOVE, getState());
Arena.addReq(cmid, Const.STOP_MOVE, ts);
}
}
}
// handle delayed first
// ary=_delayOrder.toArray(new String[0]);
// _delayOrder.clear();
// for(int i=0;i<ary.length;i++){
// Logger.only("delayArray: "+ary[i]);
// int ttt=Integer.parseInt(ary[i].split(" ")[0]);
// if(ttt==t){
// tellClientWithTime(ary[i]);
// }else if(ttt>t){
// _delayOrder.add(ary[i]);
// }
// }
} else if (noname == Const.BROAD_CAST) {
String s = (String) notification.getBody();
String ary[] = s.split(" ");
if (notification.getType() == Const.NO_PREFIX) {
tellClientWithTime(s);
return;
} else if (s.indexOf("talk") > -1) {
tellClient(s, 0);
return;
}
if (_id == Integer.parseInt(ary[2])) {
if (s.indexOf("rotate-gun") > -1) {
_lastRotateGun = TimerCmd.timeStamp + " " + s;
if (_state != null) _state.gunAngle = Float.parseFloat(_lastRotateGun.split(" ")[5]);
} else if (s.indexOf("move tank") > -1) {
Logger.debug("ClientMediator: move add s=" + s);
int offset = Integer.parseInt(notification.getType());
if (offset == 0) _move.clear();
_move.add((TimerCmd.timeStamp + offset) + " " + s);
} else if (s.indexOf("create tank") > -1) {
_state =
new TankState(
_id,
ary[3],
Integer.parseInt(ary[6]),
(int) Float.parseFloat(ary[8]),
(int) Float.parseFloat(ary[9]),
Float.parseFloat(ary[10]),
Float.parseFloat(ary[11]));
_state.printState();
} else if (s.indexOf("rotate-tank") > -1) {
_lastRotTank = TimerCmd.timeStamp + " " + s;
if (_state != null) _state.tankAngle = Float.parseFloat(_lastRotTank.split(" ")[5]);
} else if (s.indexOf("destroy tank") > -1) {
this.destroyd = true;
}
}
if (notification.getType() != null) tellClient(s, Integer.parseInt(notification.getType()));
else tellClient(s, 0);
}
}