NewCharModel.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.gui.label;
 
import com.realtime.crossfire.jxclient.character.Choice;
import com.realtime.crossfire.jxclient.character.ClassRaceInfo;
import com.realtime.crossfire.jxclient.character.NewCharacterInformation;
import com.realtime.crossfire.jxclient.character.NewCharacterInformationListener;
import com.realtime.crossfire.jxclient.util.EventListenerList2;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class NewCharModel {
 
    @NotNull
    private static final String UNKNOWN = "unknown";
 
    public static final int PRIORITY_INVALID_STAT_STR = 1;
 
    public static final int PRIORITY_INVALID_STAT_DEX = 2;
 
    public static final int PRIORITY_INVALID_STAT_CON = 3;
 
    public static final int PRIORITY_INVALID_STAT_INT = 4;
 
    public static final int PRIORITY_INVALID_STAT_WIS = 5;
 
    public static final int PRIORITY_INVALID_STAT_POW = 6;
 
    public static final int PRIORITY_INVALID_STAT_CHA = 7;
 
    public static final int PRIORITY_UNUSED_POINTS = 8;
 
    public static final int PRIORITY_CHARACTER_NAME = 9;
 
    public static final int PRIORITY_SERVER_FAILURE = Integer.MAX_VALUE;
 
    @NotNull
    private final NewCharacterInformation newCharacterInformation;
 
    @NotNull
    private final EventListenerList2<NewCharModelListener> listeners = new EventListenerList2<>();
 
    @NotNull
    private final Map<NewcharStat, Integer> values = new EnumMap<>(NewcharStat.class);
 
    @NotNull
    private String race = UNKNOWN;
 
    @NotNull
    private String class_ = UNKNOWN;
 
    @NotNull
    private String startingMap = UNKNOWN;
 
    @Nullable
    private Choice option;
 
    private int optionIndex;
 
    @NotNull
    private final Map<Integer, String> errorTexts = new TreeMap<>();
 
    public NewCharModel(@NotNull final NewCharacterInformation newCharacterInformation) {
        this.newCharacterInformation = newCharacterInformation;
 
        this.newCharacterInformation.addNewCharacterInformationListener(new NewCharacterInformationListener() {
 
            @Override
            public void classListChanged() {
                setClass(class_);
                notifyListeners();
            }
 
            @Override
            public void classInfoChanged(@NotNull final String className) {
                notifyListeners();
            }
 
            @Override
            public void raceListChanged() {
                setRace(race);
                notifyListeners();
            }
 
            @Override
            public void raceInfoChanged(@NotNull final String raceName) {
                notifyListeners();
            }
 
            @Override
            public void startingMapListChanged() {
                setStartingMap(startingMap);
                notifyListeners();
            }
 
            @Override
            public void startingMapInfoChanged(@NotNull final String startingMapName) {
                notifyListeners();
            }
 
        });
        setClass(UNKNOWN);
        setRace(UNKNOWN);
        setStartingMap(UNKNOWN);
    }
 
    public void addListener(@NotNull final NewCharModelListener listener) {
        listeners.add(listener);
    }
 
    public void removeListener(@NotNull final NewCharModelListener listener) {
        listeners.remove(listener);
    }
 
    @NotNull
    public NewCharacterInformation getNewCharacterInformation() {
        return newCharacterInformation;
    }
 
    @NotNull
    public String getRace() {
        return race;
    }
 
    public void setRace(@NotNull final String race) {
        final List<String> list = newCharacterInformation.getRaceList();
        final String newRace;
        if (list.contains(race)) {
            newRace = race;
        } else if (!list.isEmpty()) {
            newRace = list.get(0);
        } else {
            newRace = UNKNOWN;
        }
        if (this.race.equals(newRace)) {
            return;
        }
 
        this.race = newRace;
        updateOption();
        notifyListeners();
    }
 
    @NotNull
    public String getClass_() {
        return class_;
    }
 
    public void setClass(@NotNull final String class_) {
        final List<String> list = newCharacterInformation.getClassesList();
        final String newClass;
        if (list.contains(class_)) {
            newClass = class_;
        } else if (!list.isEmpty()) {
            newClass = list.get(0);
        } else {
            newClass = UNKNOWN;
        }
        if (this.class_.equals(newClass)) {
            return;
        }
 
        this.class_ = newClass;
        updateOption();
        notifyListeners();
    }
 
    @NotNull
    public String getStartingMap() {
        return startingMap;
    }
 
    public void setStartingMap(@NotNull final String startingMap) {
        final List<String> list = newCharacterInformation.getStartingMapList();
        final String newStartingMap;
        if (list.contains(startingMap)) {
            newStartingMap = startingMap;
        } else if (!list.isEmpty()) {
            newStartingMap = list.get(0);
        } else {
            newStartingMap = UNKNOWN;
        }
        if (this.startingMap.equals(newStartingMap)) {
            return;
        }
 
        this.startingMap = newStartingMap;
        updateOption();
        notifyListeners();
    }
 
    public int getTotal(@NotNull final NewcharStat stat) {
        return getValue(stat)+getRaceStatAdjustment(stat)+getClassStatAdjustment(stat);
    }
 
    public void setValue(@NotNull final NewcharStat stat, final int value) {
        final Integer prevValue = values.put(stat, value);
        //noinspection EqualsReplaceableByObjectsCall
        if (prevValue == null || !prevValue.equals(value)) {
            notifyListeners();
        }
    }
 
    public int getValue(@NotNull final NewcharStat stat) {
        final Integer tmp = values.get(stat);
        return tmp == null ? 0 : tmp;
    }
 
    public int getRaceStatAdjustment(@NotNull final NewcharStat stat) {
        final ClassRaceInfo info = newCharacterInformation.getRaceInfo(race);
        return info == null ? 0 : (int)info.getStatAdjustment(stat.getStat()); // XXX: long->int cast
    }
 
    public int getClassStatAdjustment(@NotNull final NewcharStat stat) {
        final ClassRaceInfo info = newCharacterInformation.getClassInfo(class_);
        return info == null ? 0 : (int)info.getStatAdjustment(stat.getStat()); // XXX: long->int cast
    }
 
    public void setErrorText(final int priority, @Nullable final String text) {
        final String prevText = errorTexts.get(priority);
        errorTexts.compute(priority, (p, s) -> text);
        if (!Objects.equals(text, prevText)) {
            notifyListeners();
        }
    }
 
    @NotNull
    public String getErrorText() {
        final Iterator<String> it = errorTexts.values().iterator();
        return it.hasNext() ? it.next() : "";
    }
 
    public boolean hasNonServerFailureErrorText() {
        final Iterator<Integer> it = errorTexts.keySet().iterator();
        return it.hasNext() && it.next() != PRIORITY_SERVER_FAILURE;
    }
 
    private void notifyListeners() {
        for (final NewCharModelListener listener : listeners) {
            listener.changed();
        }
    }
 
    public int getUnusedPoints() {
        int result = newCharacterInformation.getNewCharInfo().getPoints();
        for (int value : values.values()) {
            result -= value;
        }
        return result;
    }
 
    @Nullable
    public Choice getOption() {
        return option;
    }
 
    public int getOptionIndex() {
        return optionIndex;
    }
 
    public void setOptionIndex(final int optionIndex) {
        final int newOptionIndex = optionIndex < 0 || option == null || optionIndex >= option.getChoices().size() ? 0 : optionIndex;
        if (this.optionIndex == newOptionIndex) {
            return;
        }
        this.optionIndex = newOptionIndex;
        notifyListeners();
    }
 
    private void updateOption() {
        @Nullable final Choice newOption;
        final ClassRaceInfo raceInfo = newCharacterInformation.getRaceInfo(race);
        if (raceInfo != null && !raceInfo.getChoices().isEmpty()) {
            newOption = raceInfo.getChoices().get(0);
        } else {
            final ClassRaceInfo classInfo = newCharacterInformation.getClassInfo(class_);
            if (classInfo != null && !classInfo.getChoices().isEmpty()) {
                newOption = classInfo.getChoices().get(0);
            } else {
                newOption = null;
            }
        }
        if (!Objects.equals(option, newOption)) {
            option = newOption;
            optionIndex = 0;
        }
    }
 
}