CommandQueue.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * JXClient is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff.
 * Copyright (C) 2006-2011 Andreas Kirschbaum.
 */

package com.realtime.crossfire.jxclient.queue;

import com.realtime.crossfire.jxclient.guistate.ClientSocketState;
import com.realtime.crossfire.jxclient.guistate.GuiStateListener;
import com.realtime.crossfire.jxclient.guistate.GuiStateManager;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireComcListener;
import com.realtime.crossfire.jxclient.server.crossfire.CrossfireServerConnection;
import java.util.LinkedList;
import java.util.List;
import org.jetbrains.annotations.NotNull;

public class CommandQueue {

    private static final int MAX_PENDING_COMMANDS = 10;

    @NotNull
    private final CrossfireServerConnection crossfireServerConnection;

    @NotNull
    private final List<Integer> pendingCommands = new LinkedList<>();

    private int repeatCount;

    private boolean isRunning;

    @NotNull
    @SuppressWarnings("FieldCanBeLocal")
    private final CrossfireComcListener crossfireComcListener = (packetNo, time) -> {
        synchronized (pendingCommands) {
            final int index = pendingCommands.indexOf(packetNo);
            if (index == -1) {
                System.err.println("Error: got unexpected comc command #"+packetNo);
                return;
            }
            if (index > 0) {
                System.err.println("Warning: got out of order comc command #"+packetNo);
            }

            for (int i = 0; i <= index; i++) {
                pendingCommands.remove(0);
            }
        }
    };

    @NotNull
    @SuppressWarnings("FieldCanBeLocal")
    private final GuiStateListener guiStateListener = new GuiStateListener() {

        @Override
        public void start() {
            // ignore
        }

        @Override
        public void metaserver() {
            // ignore
        }

        @Override
        public void preConnecting(@NotNull final String serverInfo) {
            // ignore
        }

        @Override
        public void connecting(@NotNull final String serverInfo) {
            clear();
        }

        @Override
        public void connecting(@NotNull final ClientSocketState clientSocketState) {
            // ignore
        }

        @Override
        public void connected() {
            // ignore
        }

        @Override
        public void connectFailed(@NotNull final String reason) {
            // ignore
        }

    };

    public CommandQueue(@NotNull final CrossfireServerConnection crossfireServerConnection, @NotNull final GuiStateManager guiStateManager) {
        this.crossfireServerConnection = crossfireServerConnection;
        crossfireServerConnection.addCrossfireComcListener(crossfireComcListener);
        guiStateManager.addGuiStateListener(guiStateListener);
    }

    private int getRepeatCount() {
        final int oldRepeatCount = repeatCount;
        resetRepeatCount();
        return oldRepeatCount;
    }

    public void resetRepeatCount() {
        repeatCount = 0;
    }

    public void addToRepeatCount(final int digit) {
        assert 0 <= digit && digit <= 9;
        repeatCount = (10*repeatCount+digit)%100000;
    }

    private void clear() {
        resetRepeatCount();
        synchronized (pendingCommands) {
            pendingCommands.clear();
            isRunning = false;
        }
    }

    public void sendNcom(final boolean mustSend, @NotNull final String command) {
        sendNcom(mustSend, getRepeatCount(), command);
    }

    public void sendNcom(final boolean mustSend, final int repeat, @NotNull final String command) {
        synchronized (pendingCommands) {
            if (!mustSend && pendingCommands.size() >= MAX_PENDING_COMMANDS) {
                return;
            }

            final int packetNo = crossfireServerConnection.sendNcom(repeat, command);
            pendingCommands.add(packetNo);

            if (command.startsWith("run ")) {
                isRunning = true;
            } else if (command.startsWith("run_stop")) {
                isRunning = false;
            }
        }
    }

    public boolean stopRunning() {
        synchronized (pendingCommands) {
            final boolean result = isRunning;
            if (result) {
                sendNcom(true, 0, "run_stop");
                assert !isRunning;
            }
            return result;
        }
    }

    public boolean checkRun() {
        synchronized (pendingCommands) {
            return isRunning;
        }
    }

    public boolean checkFire() {
        return false; // XXX: implement
    }

    public void sendMove(final int to, final int tag) {
        crossfireServerConnection.sendMove(to, tag, getRepeatCount());
    }

}