forked from External/mage
327 lines
9.4 KiB
Java
327 lines
9.4 KiB
Java
/*
|
|
* Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are
|
|
* permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
* conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
|
* provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* The views and conclusions contained in the software and documentation are those of the
|
|
* authors and should not be interpreted as representing official policies, either expressed
|
|
* or implied, of BetaSteward_at_googlemail.com.
|
|
*/
|
|
|
|
package mage.cards;
|
|
|
|
import mage.Constants.Rarity;
|
|
import mage.Constants.SetType;
|
|
import mage.util.Logging;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Constructor;
|
|
import java.net.URL;
|
|
import java.net.URLClassLoader;
|
|
import java.util.*;
|
|
import java.util.jar.JarEntry;
|
|
import java.util.jar.JarInputStream;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
/**
|
|
* @author BetaSteward_at_googlemail.com
|
|
*/
|
|
public abstract class ExpansionSet implements Serializable {
|
|
|
|
private final static Logger logger = Logging.getLogger(ExpansionSet.class.getName());
|
|
|
|
protected static Random rnd = new Random();
|
|
|
|
protected String name;
|
|
protected String code;
|
|
protected String symbolCode;
|
|
protected Date releaseDate;
|
|
protected ExpansionSet parentSet;
|
|
protected List<Class> cards;
|
|
protected SetType setType;
|
|
protected Map<Rarity, List<Class>> rarities;
|
|
|
|
protected String blockName;
|
|
protected boolean hasBoosters = false;
|
|
protected int numBoosterLands;
|
|
protected int numBoosterCommon;
|
|
protected int numBoosterUncommon;
|
|
protected int numBoosterRare;
|
|
protected int ratioBoosterMythic;
|
|
|
|
public ExpansionSet(String name, String code, String symbolCode, String packageName, Date releaseDate, SetType setType) {
|
|
this.name = name;
|
|
this.code = code;
|
|
this.symbolCode = symbolCode;
|
|
this.releaseDate = releaseDate;
|
|
this.setType = setType;
|
|
this.cards = getCardClassesForPackage(packageName);
|
|
this.rarities = getCardsByRarity();
|
|
}
|
|
|
|
public List<Class> getCards() {
|
|
return cards;
|
|
}
|
|
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
public String getCode() {
|
|
return code;
|
|
}
|
|
|
|
public String getSymbolCode() {
|
|
return symbolCode;
|
|
}
|
|
|
|
public Date getReleaseDate() {
|
|
return releaseDate;
|
|
}
|
|
|
|
public SetType getSetType() {
|
|
return setType;
|
|
}
|
|
|
|
public Card createCard(Class clazz) {
|
|
try {
|
|
Constructor<?> con = clazz.getConstructor(new Class[]{UUID.class});
|
|
return (Card) con.newInstance(new Object[]{null});
|
|
} catch (Exception ex) {
|
|
logger.log(Level.SEVERE, "Error creating card:" + clazz.getName(), ex);
|
|
ex.printStackTrace();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public Set<Card> createCards() {
|
|
Set<Card> created = new HashSet<Card>();
|
|
for (Class clazz : cards) {
|
|
created.add(createCard(clazz));
|
|
}
|
|
return created;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return name;
|
|
}
|
|
|
|
public Card findCard(String name) {
|
|
for (Card card : createCards()) {
|
|
if (name.equals(card.getName()))
|
|
return card;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Card findCard(String name, boolean random) {
|
|
List<Card> cards = new ArrayList<Card>();
|
|
for (Card card : createCards()) {
|
|
if (name.equals(card.getName())) {
|
|
cards.add(card);
|
|
}
|
|
}
|
|
if (cards.size() > 0) {
|
|
return cards.get(rnd.nextInt(cards.size()));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String findCard(int cardNum) {
|
|
for (Card card : createCards()) {
|
|
if (card.getCardNumber() == cardNum)
|
|
return card.getClass().getCanonicalName();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private ArrayList<Class> getCardClassesForPackage(String packageName) {
|
|
ClassLoader classLoader = this.getClass().getClassLoader();
|
|
assert classLoader != null;
|
|
String path = packageName.replace('.', '/');
|
|
Enumeration<URL> resources = null;
|
|
try {
|
|
resources = classLoader.getResources(path);
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
List<File> dirs = new ArrayList<File>();
|
|
boolean isLoadingFromJar = false;
|
|
String jarPath = null;
|
|
while (resources.hasMoreElements()) {
|
|
URL resource = resources.nextElement();
|
|
if (resource.toString().startsWith("jar:")) {
|
|
isLoadingFromJar = true;
|
|
jarPath = resource.getFile();
|
|
break;
|
|
}
|
|
dirs.add(new File(resource.getFile()));
|
|
}
|
|
ArrayList<Class> classes = new ArrayList<Class>();
|
|
if (isLoadingFromJar) {
|
|
if (jarPath.contains("!")) {
|
|
jarPath = jarPath.substring(0, jarPath.lastIndexOf('!'));
|
|
}
|
|
if (jarPath.startsWith("file:/")) {
|
|
jarPath = jarPath.substring(jarPath.indexOf("file:/") + "file:/".length());
|
|
}
|
|
try {
|
|
classes.addAll(findClassesInJar(new File(jarPath), path));
|
|
} catch (ClassNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
} else { // faster but doesn't work for jars
|
|
for (File directory : dirs) {
|
|
try {
|
|
classes.addAll(findClasses(directory, packageName));
|
|
} catch (ClassNotFoundException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
return classes;
|
|
}
|
|
|
|
private static List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException {
|
|
List<Class> classes = new ArrayList<Class>();
|
|
if (!directory.exists()) {
|
|
return classes;
|
|
}
|
|
File[] files = directory.listFiles();
|
|
if (files == null) {
|
|
return classes;
|
|
}
|
|
for (File file : files) {
|
|
if (file.isDirectory()) {
|
|
assert !file.getName().contains(".");
|
|
classes.addAll(findClasses(file, packageName + "." + file.getName()));
|
|
} else if (file.getName().endsWith(".class")) {
|
|
Class c = Class.forName(packageName + '.' + file.getName().substring(0, file.getName().length() - 6));
|
|
if (CardImpl.class.isAssignableFrom(c)) {
|
|
classes.add(c);
|
|
}
|
|
}
|
|
}
|
|
return classes;
|
|
}
|
|
|
|
private static List<Class> findClassesInJar(File file, String packageName) throws ClassNotFoundException {
|
|
List<Class> classes = new ArrayList<Class>();
|
|
|
|
if (!file.exists()) {
|
|
return classes;
|
|
}
|
|
|
|
try {
|
|
URL url = file.toURL();
|
|
URL[] urls = new URL[]{url};
|
|
ClassLoader cl = new URLClassLoader(urls);
|
|
|
|
JarInputStream jarFile = new JarInputStream(new FileInputStream(file));
|
|
JarEntry jarEntry;
|
|
|
|
while (true) {
|
|
jarEntry = jarFile.getNextJarEntry();
|
|
if (jarEntry == null) {
|
|
break;
|
|
}
|
|
if ((jarEntry.getName().startsWith(packageName)) && (jarEntry.getName().endsWith(".class"))) {
|
|
String clazz = jarEntry.getName().replaceAll("/", "\\.").replace(".class", "");
|
|
Class c = cl.loadClass(clazz);
|
|
if (CardImpl.class.isAssignableFrom(c)) {
|
|
classes.add(c);
|
|
}
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
|
|
|
|
return classes;
|
|
}
|
|
|
|
private Map<Rarity, List<Class>> getCardsByRarity() {
|
|
Map<Rarity, List<Class>> cardsByRarity = new HashMap<Rarity, List<Class>>();
|
|
|
|
for (Class clazz : cards) {
|
|
Card card = createCard(clazz);
|
|
if (!cardsByRarity.containsKey(card.getRarity()))
|
|
cardsByRarity.put(card.getRarity(), new ArrayList<Class>());
|
|
cardsByRarity.get(card.getRarity()).add(clazz);
|
|
}
|
|
|
|
return cardsByRarity;
|
|
}
|
|
|
|
public List<Card> createBooster() {
|
|
List<Card> booster = new ArrayList<Card>();
|
|
|
|
if (!hasBoosters)
|
|
return booster;
|
|
|
|
if (parentSet != null) {
|
|
for (int i = 0; i < numBoosterLands; i++) {
|
|
addToBooster(booster, parentSet, Rarity.LAND);
|
|
}
|
|
} else {
|
|
for (int i = 0; i < numBoosterLands; i++) {
|
|
addToBooster(booster, this, Rarity.LAND);
|
|
}
|
|
}
|
|
for (int i = 0; i < numBoosterCommon; i++) {
|
|
addToBooster(booster, this, Rarity.COMMON);
|
|
}
|
|
for (int i = 0; i < numBoosterUncommon; i++) {
|
|
addToBooster(booster, this, Rarity.UNCOMMON);
|
|
}
|
|
for (int i = 0; i < numBoosterRare; i++) {
|
|
if (ratioBoosterMythic > 0 && rnd.nextInt(ratioBoosterMythic) == 1) {
|
|
addToBooster(booster, this, Rarity.MYTHIC);
|
|
} else {
|
|
addToBooster(booster, this, Rarity.RARE);
|
|
}
|
|
}
|
|
|
|
return booster;
|
|
}
|
|
|
|
protected void addToBooster(List<Card> booster, ExpansionSet set, Rarity rarity) {
|
|
Card card = set.getRandom(rarity);
|
|
if (card != null)
|
|
booster.add(card);
|
|
}
|
|
|
|
protected Card getRandom(Rarity rarity) {
|
|
if (!rarities.containsKey(rarity))
|
|
return null;
|
|
int size = rarities.get(rarity).size();
|
|
if (size > 0) {
|
|
return createCard(rarities.get(rarity).get(rnd.nextInt(size)));
|
|
}
|
|
return null;
|
|
}
|
|
}
|