CfAnimations.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.animations.Animations;
import com.realtime.crossfire.jxclient.faces.FacesManager;
import com.realtime.crossfire.jxclient.items.CfItem;
import com.realtime.crossfire.jxclient.items.ItemListener;
import com.realtime.crossfire.jxclient.items.ItemSet;
import com.realtime.crossfire.jxclient.items.ItemSetListener;
import com.realtime.crossfire.jxclient.protocol.Map2;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;
import java.util.random.RandomGenerator;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class CfAnimations {
 
    @NotNull
    private static final Object SYNC = new Object();
 
    @NotNull
    private final ItemSet itemSet;
 
    @NotNull
    private final FacesManager facesManager;
 
    @NotNull
    private final Animations animations;
 
    @NotNull
    private final Collection<Integer> unknownAnimations = new HashSet<>();
 
    @NotNull
    private final RandomGenerator random = new Random();
 
    @NotNull
    @SuppressWarnings("FieldCanBeLocal")
    private final ItemSetListener itemSetListener = new ItemSetListener() {
 
        @Override
        public void playerChanged(@Nullable final CfItem player) {
            if (!tags.isEmpty()) {
                System.err.println("Warning: player inventory is not empty when changing players");
                for (final int tag : tags.values()) {
                    tagRemove(tag);
                }
                tags.clear();
            }
 
            if (playerTag != -1) {
                itemSet.removeInventoryListener(playerTag, playerInventoryListener);
            }
            playerTag = player == null ? -1 : player.getTag();
            if (playerTag != -1) {
                itemSet.addInventoryListener(playerTag, playerInventoryListener);
            }
        }
 
        @Override
        public void openContainerChanged(final int tag) {
        }
 
    };
 
    @NotNull
    @SuppressWarnings("FieldAccessedSynchronizedAndUnsynchronized")
    private CfAnimationsMapListener mapListener = new CfAnimationsMapListener() {
 
        @NotNull
        @Override
        public Object mapBegin() {
            return SYNC;
        }
 
        @Override
        public void mapFace(@NotNull final Location location, final int faceNum) {
        }
 
        @Override
        public void mapEnd() {
        }
 
    };
 
    private int mapWidth;
 
    private int mapHeight;
 
    @NotNull
    private final AnimationMap mapAnimations = new AnimationMap();
 
    @NotNull
    private final AnimationSet tagAnimations = new AnimationSet();
 
    @NotNull
    private final Collection<AnimationState> animationStates = new HashSet<>();
 
    @NotNull
    private final Map<Integer, AnimationState> syncAnimationStates = new HashMap<>();
 
    @NotNull
    private final Collection<AnimationState> pendingTickUpdates = new ArrayList<>();
 
    @NotNull
    private final ItemListener playerInventoryListener = new ItemListener() {
 
        @Override
        public void itemChanged(final int tag) {
        }
 
        @Override
        public void itemRemoved(final int tag) {
        }
 
        @Override
        public void inventoryAdded(final int tag, final int index, @NotNull final CfItem item) {
            final int itemTag = item.getTag();
            final int anim = item.getAnim();
            final int animSpeed = item.getAnimSpeed();
            if (anim != 0) {
                final Animation animation = animations.get(anim&Map2.ANIM_MASK);
                if (animation == null) {
                    if (unknownAnimations.add(anim&Map2.ANIM_MASK)) {
                        System.err.println("Unknown animation id "+(anim&Map2.ANIM_MASK)+", ignoring");
                    }
                    return;
                }
 
                final Integer prevTag = tags.put(index, itemTag);
                if (prevTag != null) {
                    tagRemove(prevTag);
                }
                tagAdd(itemTag, animation, (anim>>Map2.ANIM_TYPE_SHIFT)&Map2.ANIM_TYPE_MASK);
                tagAnimations.updateSpeed(itemTag, animSpeed);
            }
        }
 
        @Override
        public void inventoryRemoved(final int tag, final int index) {
            final Integer prevTag = tags.remove(index);
            if (prevTag == null) {
                return;
            }
 
            tagRemove(prevTag);
        }
 
    };
 
    @NotNull
    private final Map<Integer, Integer> tags = new HashMap<>();
 
    private int playerTag = -1;
 
    public CfAnimations(@NotNull final ItemSet itemSet, @NotNull final FacesManager facesManager, @NotNull final Animations animations) {
        this.itemSet = itemSet;
        this.facesManager = facesManager;
        this.animations = animations;
 
        itemSet.addItemSetListener(itemSetListener);
    }
 
    public void setMapListener(@NotNull final CfAnimationsMapListener mapListener) {
        this.mapListener = mapListener;
    }
 
    public void mapClear() {
        mapAnimations.clear();
        final Collection<AnimationState> tagAnimationStates = tagAnimations.getAllAnimationStates();
        animationStates.retainAll(tagAnimationStates);
        for (final AnimationState animationState : animationStates) {
            animationState.freeAllLocations();
        }
        syncAnimationStates.values().retainAll(tagAnimationStates);
        pendingTickUpdates.retainAll(tagAnimationStates);
    }
 
    public void mapAdd(@NotNull final Location location, @NotNull final Animation animation, final int type) {
        mapAnimations.add(location, add(animation, type));
    }
 
    public void mapRemove(final int x, final int y) {
        for (int layer = 0; layer < Map2.NUM_LAYERS; layer++) {
            mapAnimations.remove(new Location(x, y, layer));
        }
    }
 
    public void mapRemove(@NotNull final Location location) {
        mapAnimations.remove(location);
    }
 
    public void mapUpdateSpeed(@NotNull final Location location, final int speed) {
        mapAnimations.updateSpeed(location, speed);
    }
 
    public void mapScroll(final int dx, final int dy) {
        mapAnimations.scroll(dx, dy, mapWidth, mapHeight);
    }
 
    public void mapSetSize(final int mapWidth, final int mapHeight) {
        this.mapWidth = mapWidth;
        this.mapHeight = mapHeight;
        mapClear();
    }
 
    public void tick(final int tickNo) {
        for (AnimationState animationState : pendingTickUpdates) {
            animationState.setTickNo(tickNo);
        }
        pendingTickUpdates.clear();
        final Iterable<AnimationState> animationStatesToUpdate = new ArrayList<>(animationStates);
        synchronized (mapListener.mapBegin()) {
            for (AnimationState animationState : animationStatesToUpdate) {
                animationState.updateTickNo(tickNo);
            }
            mapListener.mapEnd();
        }
    }
 
    private void tagAdd(final int tag, @NotNull final Animation animation, final int type) {
        tagAnimations.add(tag, add(animation, type));
    }
 
    private void tagRemove(final int tag) {
        tagAnimations.remove(tag);
    }
 
    @NotNull
    private AnimationState add(@NotNull final Animation animation, final int type) {
        assert 0 <= type && type < 4;
 
        final AnimationState animationState;
        final boolean addToPendingTickUpdates;
        switch (type) {
        default: // invalid; treated as "normal"
        case Map2.ANIM_NORMAL: // animation starts at index 0
            animationState = new AnimationState(animation, 0, mapListener, itemSet, facesManager);
            addToPendingTickUpdates = true;
            break;
 
        case Map2.ANIM_RANDOM: // animation starts at random index
            animationState = new AnimationState(animation, random.nextInt(animation.getFaces()), mapListener, itemSet, facesManager);
            addToPendingTickUpdates = true;
            break;
 
        case Map2.ANIM_SYNC: // animation is synchronized with other animations
            final int animationId = animation.getAnimationId();
            final AnimationState tmp = syncAnimationStates.get(animationId);
            if (tmp == null) {
                animationState = new AnimationState(animation, 0, mapListener, itemSet, facesManager);
                syncAnimationStates.put(animationId, animationState);
                addToPendingTickUpdates = true;
            } else {
                animationState = tmp;
                addToPendingTickUpdates = false;
            }
            break;
        }
 
        animationStates.add(animationState);
        if (addToPendingTickUpdates) {
            pendingTickUpdates.add(animationState);
        }
 
        return animationState;
    }
 
}