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-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
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.map.PendingDirections;
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<>();
 
    @NotNull
    private final PendingDirections pendingDirections;
 
    private int repeatCount;
 
    private boolean isRunning;
 
    @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, @NotNull final String param) {
            // 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, @NotNull final PendingDirections pendingDirections) {
        this.crossfireServerConnection = crossfireServerConnection;
        this.pendingDirections = pendingDirections;
        crossfireServerConnection.addCrossfireComcListener(this::comcReceived);
        crossfireServerConnection.addCrossfireTickListener(this::tickReceived);
        crossfireServerConnection.addCrossfireMapScrollListener(this::mapScrollReceived);
        guiStateManager.addGuiStateListener(guiStateListener);
    }
 
    private int getRepeatCount() {
        final int oldRepeatCount = repeatCount;
        resetRepeatCount();
        return oldRepeatCount;
    }
 
    private 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();
            pendingDirections.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);
 
            final String[] tmp = command.split(" ", 2);
            if (tmp[0].equalsIgnoreCase("run")) {
                isRunning = true;
                pendingDirections.clear();
                if (tmp.length >= 2) {
                    try {
                        final int direction = Integer.parseInt(tmp[1]);
                        if (1 <= direction && direction <= 8) {
                            pendingDirections.run(direction-1);
                        }
                    } catch (final NumberFormatException ignored) {
                    }
                }
            } else if (tmp[0].equalsIgnoreCase("run_stop")) {
                isRunning = false;
                pendingDirections.clear();
            } else {
                final int direction;
                if (command.equalsIgnoreCase("north")) {
                    direction = 0;
                } else if (command.equalsIgnoreCase("northeast")) {
                    direction = 1;
                } else if (command.equalsIgnoreCase("east")) {
                    direction = 2;
                } else if (command.equalsIgnoreCase("southeast")) {
                    direction = 3;
                } else if (command.equalsIgnoreCase("south")) {
                    direction = 4;
                } else if (command.equalsIgnoreCase("southwest")) {
                    direction = 5;
                } else if (command.equalsIgnoreCase("west")) {
                    direction = 6;
                } else if (command.equalsIgnoreCase("northwest")) {
                    direction = 7;
                } else {
                    direction = -1;
                }
                if (direction != -1) {
                    if (isRunning) {
                        pendingDirections.run(direction);
                    } else {
                        pendingDirections.add(direction, packetNo);
                    }
                }
            }
        }
    }
 
    public void sendRawString(@NotNull final String command) {
        synchronized (pendingCommands) {
            crossfireServerConnection.sendRawString(command);
        }
    }
 
    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());
    }
 
    private void mapScrollReceived(final int dx, final int dy) {
        final int direction;
        if (dx == 0 && dy == -1) {
            direction = 0;
        } else if (dx == 1 && dy == -1) {
            direction = 1;
        } else if (dx == 1 && dy == 0) {
            direction = 2;
        } else if (dx == 1 && dy == 1) {
            direction = 3;
        } else if (dx == 0 && dy == 1) {
            direction = 4;
        } else if (dx == -1 && dy == 1) {
            direction = 5;
        } else if (dx == -1 && dy == 0) {
            direction = 6;
        } else if (dx == -1 && dy == -1) {
            direction = 7;
        } else {
            return;
        }
        pendingDirections.mapScroll(direction);
    }
 
    private void comcReceived(final int packetNo, final int 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);
            }
 
            pendingCommands.subList(0, index+1).clear();
        }
        pendingDirections.comc(packetNo);
    }
 
    private void tickReceived(final int tickNo) {
        pendingDirections.tick();
    }
 
}