AnimationState.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.map;
 
import com.realtime.crossfire.jxclient.animations.Animation;
import com.realtime.crossfire.jxclient.faces.Face;
import com.realtime.crossfire.jxclient.faces.FacesManager;
import com.realtime.crossfire.jxclient.items.ItemSet;
import com.realtime.crossfire.jxclient.protocol.UpdItem;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.jetbrains.annotations.NotNull;
 
public class AnimationState implements Iterable<Location> {
 
    @NotNull
    private final Animation animation;
 
    @NotNull
    private final CfAnimationsMapListener mapListener;
 
    @NotNull
    private final ItemSet itemSet;
 
    @NotNull
    private final FacesManager facesManager;
 
    private int speed = 1;
 
    private int tickNo;
 
    private int index;
 
    private int lastFace = -1;
 
    @NotNull
    private final Set<Location> locations = new HashSet<>();
 
    @NotNull
    private final Collection<Integer> tags = new HashSet<>();
 
    public AnimationState(@NotNull final Animation animation, final int index, @NotNull final CfAnimationsMapListener mapListener, @NotNull final ItemSet itemSet, @NotNull final FacesManager facesManager) {
        this.animation = animation;
        this.mapListener = mapListener;
        this.itemSet = itemSet;
        this.facesManager = facesManager;
        this.index = index%animation.getFaces();
    }
 
    public void setSpeed(final int speed) {
        final int effectiveSpeed = Math.max(1, speed);
        if (this.speed == effectiveSpeed) {
            return;
        }
        final int tmpIndex = index/this.speed;
        final int tmpDelay = Math.min(index%this.speed, effectiveSpeed-1);
        this.speed = effectiveSpeed;
        index = tmpIndex*effectiveSpeed+tmpDelay;
        updateFace();
    }
 
    public void setTickNo(final int tickNo) {
        this.tickNo = tickNo;
    }
 
    public void updateTickNo(final int tickNo) {
        final int diff = tickNo-this.tickNo;
        if (tickNo < this.tickNo) {
            System.err.println("Ignoring inconsistent tick value: current tick number is "+tickNo+", previous tick number was "+this.tickNo+".");
        } else {
            index = (index+diff)%(speed*animation.getFaces());
        }
        this.tickNo = tickNo;
        updateFace();
    }
 
    private void updateFace() {
        final int face = animation.getFace(index/speed);
        if (face == lastFace) {
            return;
        }
        lastFace = face;
        for (Location location : locations) {
            mapListener.mapFace(location, face);
        }
        final Face face2 = facesManager.getFace(face);
        for (int tag : tags) {
            itemSet.updateItem(UpdItem.UPD_FACE, tag, 0, 0, 0, face2, "", "", 0, 0, 0);
        }
    }
 
    public void allocate(@NotNull final Location location) {
        if (!locations.add(location)) {
            throw new IllegalArgumentException("duplicate location "+location);
        }
        if (lastFace != -1) {
            mapListener.mapFace(location, lastFace);
        }
    }
 
    public void allocate(final int tag) {
        if (!tags.add(tag)) {
            throw new IllegalArgumentException("duplicate item tag "+tag);
        }
        if (lastFace != -1) {
            itemSet.updateItem(UpdItem.UPD_FACE, tag, 0, 0, 0, facesManager.getFace(lastFace), "", "", 0, 0, 0);
        }
    }
 
    public void free(@NotNull final Location location) {
        if (!locations.remove(location)) {
            throw new IllegalArgumentException("undefined location "+location);
        }
    }
 
    public void freeAllLocations() {
        locations.clear();
    }
 
    public void free(final int tag) {
        if (!tags.remove(tag)) {
            throw new IllegalArgumentException("undefined item tag "+tag);
        }
    }
 
    @NotNull
    @Override
    public Iterator<Location> iterator() {
        return Collections.unmodifiableSet(locations).iterator();
    }
 
    public void scroll(final int dx, final int dy, final int width, final int height) {
        final Collection<Location> tmp = new HashSet<>();
        for (Location location : locations) {
            if (0 <= location.getX() && location.getX() < width && 0 <= location.getY() && location.getY() < height) { // out-of-map bounds animations are dropped, not scrolled
                final int newX = location.getX()-dx;
                final int newY = location.getY()-dy;
                if (0 <= newX && newX < width && 0 <= newY && newY < height) { // in-map bounds animations are dropped if scrolled off the visible area
                    final Location newLocation = new Location(newX, newY, location.getLayer());
                    tmp.add(newLocation);
                }
            }
        }
        locations.clear();
        locations.addAll(tmp);
    }
 
}