You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
399 lines
11 KiB
399 lines
11 KiB
package net.sector.level.ship;
|
|
|
|
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
import net.sector.level.ship.modules.pieces.Piece;
|
|
import net.sector.level.ship.modules.pieces.body.*;
|
|
import net.sector.level.ship.modules.pieces.weapons.*;
|
|
import net.sector.models.wavefront.loader.RenderModel;
|
|
import net.sector.util.Log;
|
|
|
|
import com.porcupine.color.RGB;
|
|
import com.porcupine.math.Calc;
|
|
|
|
|
|
/**
|
|
* Table of pieces.
|
|
*
|
|
* @author Ondřej Hruška (MightyPork)
|
|
*/
|
|
public class PieceRegistry {
|
|
|
|
public static class PieceEntry {
|
|
public String id;
|
|
public String discovery;
|
|
public String group;
|
|
public String label;
|
|
public RenderModel model;
|
|
public int baseCost;
|
|
public Class<? extends Piece> pieceClass;
|
|
|
|
public PieceEntry(String id, String discovery, String pieceGroup, String label, Class<? extends Piece> pieceClass) {
|
|
this.discovery = discovery;
|
|
this.group = pieceGroup;
|
|
this.label = label;
|
|
this.pieceClass = pieceClass;
|
|
this.id = id;
|
|
|
|
try {
|
|
Piece inst = pieceClass.newInstance();
|
|
model = inst.getModel();
|
|
baseCost = inst.getBaseCost();
|
|
} catch (InstantiationException e) {
|
|
Log.e("Error registering piece.", e);
|
|
} catch (IllegalAccessException e) {
|
|
Log.e("Error registering piece.", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Human readable labels for piece groups */
|
|
public static LinkedHashMap<String, String> groups = new LinkedHashMap<String, String>();
|
|
|
|
public static Map<String, PieceEntry> pieces = new LinkedHashMap<String, PieceEntry>();
|
|
|
|
public static String designerDefaultGroup = null;
|
|
|
|
|
|
|
|
/**
|
|
* initialize static fields
|
|
*/
|
|
public static void init() {
|
|
Log.f1("Initializing PieceRegistry...");
|
|
|
|
//@formatter:off
|
|
|
|
|
|
String gBODY, gWEAPONS, gENGINES;
|
|
// piece groups
|
|
registerPieceGroup(gBODY = "body", "Body");
|
|
registerPieceGroup(gWEAPONS = "weapons", "Guns");
|
|
registerPieceGroup(gENGINES = "propulsion", "Engines");
|
|
|
|
|
|
String dBODY, dENGINE_R, dENGINE_I, dCANNON, dLASER, dPLASMA, dEMP, dFIRE, dROCKET, dROCKET_G;
|
|
|
|
// piece discoveries
|
|
dBODY = "body";
|
|
|
|
dENGINE_R = "engineRocket";
|
|
dENGINE_I = "engineIon";
|
|
|
|
dCANNON = "cannon";
|
|
dLASER = "laser";
|
|
dPLASMA = "plasma";
|
|
dROCKET = "rocket";
|
|
dROCKET_G = "rocket_guided";
|
|
dEMP = "emp";
|
|
dFIRE = "fireball";
|
|
|
|
|
|
// pieces
|
|
|
|
// body box
|
|
registerPiece("bb_cube", dBODY, gBODY, "Cube", PieceBbCube.class);
|
|
registerPiece("bb_triangle", dBODY, gBODY, "Triangle", PieceBbTriangle.class);
|
|
registerPiece("bb_arrow", dBODY, gBODY, "Arrow", PieceBbArrow.class);
|
|
registerPiece("bb_point", dBODY, gBODY, "Point", PieceBbPoint.class);
|
|
|
|
// body smooth
|
|
// one side
|
|
registerPiece("bs_side1", dBODY, gBODY, "Border 1 side", PieceBsSide1.class);
|
|
registerPiece("bs_side2_next", dBODY, gBODY, "Border 2 sides next", PieceBsSide2Next.class);
|
|
registerPiece("bs_side2_opp", dBODY, gBODY, "Border 2 sides opposite", PieceBsSide2Opp.class);
|
|
registerPiece("bs_side3", dBODY, gBODY, "Border 3 sides", PieceBsSide3.class);
|
|
registerPiece("bs_corner1", dBODY, gBODY, "Border 1 corner", PieceBsCorner1.class);
|
|
registerPiece("bs_corner2_next", dBODY, gBODY, "Border 2 corners next", PieceBsCorner2Next.class);
|
|
registerPiece("bs_corner2_opp", dBODY, gBODY, "Border 2 corners opposite", PieceBsCorner2Opp.class);
|
|
registerPiece("bs_corner3", dBODY, gBODY, "Border 3 corners", PieceBsCorner3.class);
|
|
registerPiece("bs_corner4", dBODY, gBODY, "Border 4 corners", PieceBsCorner4.class);
|
|
registerPiece("bs_corner1_side1", dBODY, gBODY, "Border 1 corner 1 side", PieceBsCorner1Side1.class);
|
|
registerPiece("bs_corner1_side1_m", dBODY, gBODY, "Border 1 corner 1 side", PieceBsCorner1Side1M.class);
|
|
registerPiece("bs_corner2_side1", dBODY, gBODY, "Border 2 corners 1 side", PieceBsCorner2Side1.class);
|
|
registerPiece("bs_corner1_side2", dBODY, gBODY, "Border 1 corner 2 side", PieceBsCorner1Side2.class);
|
|
registerPiece("bs_point", dBODY, gBODY, "Border Point", PieceBsPoint.class);
|
|
registerPiece("bs_triangle", dBODY, gBODY, "Border Triangle", PieceBsTriangle.class);
|
|
|
|
|
|
//body wing
|
|
registerPiece("bw_cube", dBODY, gBODY, "Square Wing", PieceBwCube.class);
|
|
registerPiece("bw_triangle", dBODY, gBODY, "Triangle Wing", PieceBwCorner.class);
|
|
registerPiece("bw_arrow", dBODY, gBODY, "Arrow Wing", PieceBwPoint.class);
|
|
|
|
// engine
|
|
registerPiece("engine_rocket", dENGINE_R, gENGINES, "Rocket Engine", PieceEngineRocket.class);
|
|
registerPiece("engine_ion", dENGINE_I, gENGINES, "Ion Engine", PieceEngineIon.class);
|
|
|
|
// weapons
|
|
registerPiece("w_cannon", dCANNON, gWEAPONS, "Cannon", PieceCannon.class);
|
|
registerPiece("w_laser", dLASER, gWEAPONS, "Laser Gun", PieceLaser.class);
|
|
registerPiece("w_plasma", dPLASMA, gWEAPONS, "Plasma Gun", PiecePlasmaGun.class);
|
|
registerPiece("w_emp", dEMP, gWEAPONS, "EMP Launcher", PieceEMPGun.class);
|
|
registerPiece("w_rocket", dROCKET, gWEAPONS, "Rocket Launcher", PieceRocketLauncher.class);
|
|
registerPiece("w_rocket_g", dROCKET_G, gWEAPONS, "Guided Rocket Launcher", PieceRocketLauncherGuided.class);
|
|
registerPiece("w_fireball", dFIRE, gWEAPONS, "Flamethrower", PieceFlamethrower.class);
|
|
|
|
//@formatter:on
|
|
}
|
|
|
|
/**
|
|
* Get piece damage color.
|
|
*
|
|
* @param health piece health
|
|
* @param healthMax max health
|
|
* @return color
|
|
*/
|
|
public static RGB getDamageColor(double health, double healthMax) {
|
|
RGB clr = new RGB(0, 0, 0);
|
|
double yellow = healthMax * 0.7;
|
|
if (health <= yellow) {
|
|
clr.r = 1;
|
|
clr.g = health / yellow;
|
|
} else if (health < healthMax) {
|
|
clr.r = Calc.clampd(1 - (health - yellow) / yellow, 0, 1);
|
|
clr.g = 1;
|
|
} else {
|
|
clr.r = 0;
|
|
clr.g = 1;
|
|
}
|
|
return clr;
|
|
}
|
|
|
|
//
|
|
// /**
|
|
// * Register discoverable key
|
|
// *
|
|
// * @param id discovery key
|
|
// * @param label human readable discovery name
|
|
// * @param defaultLevel initial discovery level (0 = unavailable)
|
|
// * @param maxLevel max discovery level
|
|
// * @param dependencies dependencies name, level, name, level...
|
|
// */
|
|
// public static void registerDiscovery(String id, String label, int defaultLevel, int maxLevel, Object... dependencies) {
|
|
//
|
|
// DiscoveryRegistry.registerDiscovery(id, label, defaultLevel, maxLevel, dependencies);
|
|
// }
|
|
|
|
/**
|
|
* Register piece group
|
|
*
|
|
* @param id group name
|
|
* @param label human readable label
|
|
*/
|
|
public static void registerPieceGroup(String id, String label) {
|
|
groups.put(id, label);
|
|
if (designerDefaultGroup == null) designerDefaultGroup = id;
|
|
}
|
|
|
|
/**
|
|
* Register new piece
|
|
*
|
|
* @param id unique identifier
|
|
* @param discovery key for discovery table
|
|
* @param group piece group
|
|
* @param label label for ship designer and similar
|
|
* @param pieceClass class of the piece
|
|
*/
|
|
public static void registerPiece(String id, String discovery, String group, String label, Class<? extends Piece> pieceClass) {
|
|
|
|
pieces.put(id, new PieceEntry(id, discovery, group, label, pieceClass));
|
|
|
|
if (!DiscoveryRegistry.discoveryExists(discovery)) {
|
|
Log.w("Ship piece " + id + " registered with unknown discovery key " + discovery + "!");
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Get piece name from piece instance.
|
|
*
|
|
* @param p piece instance
|
|
* @return name
|
|
*/
|
|
public static String getPieceName(Piece p) {
|
|
for (Entry<String, PieceEntry> entry : pieces.entrySet()) {
|
|
if (p.getClass() == entry.getValue().pieceClass) return entry.getKey();
|
|
}
|
|
throw new RuntimeException("Class of piece " + p + " could not be resolved.");
|
|
}
|
|
|
|
/**
|
|
* Get maximal level for piece instance
|
|
*
|
|
* @param piece piece instance
|
|
* @return piece max level
|
|
*/
|
|
public final static int getPieceLevelMax(Piece piece) {
|
|
String pieceName = getPieceName(piece);
|
|
return getPieceLevelMax(pieceName);
|
|
}
|
|
|
|
/**
|
|
* Get maximal level for piece name
|
|
*
|
|
* @param id piece name
|
|
* @return max level
|
|
*/
|
|
public static int getPieceLevelMax(String id) {
|
|
String discoveryName = getPieceDiscoveryKey(id);
|
|
return DiscoveryRegistry.getDiscoveryLevelMax(discoveryName);
|
|
}
|
|
|
|
/**
|
|
* Build new ship piece for name
|
|
*
|
|
* @param id piece name
|
|
* @return the piece
|
|
*/
|
|
public static Piece makePiece(String id) {
|
|
return makePiece(id, 1, 0);
|
|
}
|
|
|
|
/**
|
|
* Build new ship piece for name
|
|
*
|
|
* @param id piece name
|
|
* @param level piece level
|
|
* @return the piece
|
|
*/
|
|
public static Piece makePiece(String id, int level) {
|
|
return makePiece(id, level, 0);
|
|
}
|
|
|
|
/**
|
|
* Build new ship piece for name
|
|
*
|
|
* @param id piece name
|
|
* @param level piece level
|
|
* @param rotate piece rotate
|
|
* @return the piece
|
|
*/
|
|
public static Piece makePiece(String id, int level, int rotate) {
|
|
try {
|
|
Piece p = pieces.get(id).pieceClass.newInstance();
|
|
p.setPieceRotate(rotate);
|
|
p.setLevel(level);
|
|
return p;
|
|
} catch (Exception e) {
|
|
Log.e("Cant make piece for: " + id);
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get model for piece
|
|
*
|
|
* @param id piece name
|
|
* @return the model
|
|
*/
|
|
public static RenderModel getModel(String id) {
|
|
return pieces.get(id).model;
|
|
}
|
|
|
|
|
|
/**
|
|
* Calculate how much upgrade / downgrade will cost.
|
|
*
|
|
* @param base base cost (level 1)
|
|
* @param from level from (before up/down-grade)
|
|
* @param to level to (after up/down-grade)
|
|
* @return cost (negative if money was returned)
|
|
*/
|
|
public static int getLevelChangeCost(int base, int from, int to) {
|
|
return (getLevelCost(base, to) - getLevelCost(base, from));
|
|
}
|
|
|
|
/**
|
|
* Get level cost
|
|
*
|
|
* @param base base cost (level 1)
|
|
* @param level current level
|
|
* @return cost
|
|
*/
|
|
public static int getLevelCost(int base, int level) {
|
|
return base * (level * level);
|
|
}
|
|
|
|
/**
|
|
* Get how much repair will cost
|
|
*
|
|
* @param base base cost (level 1)
|
|
* @param level current level
|
|
* @param health health of the piece
|
|
* @param healthMax max piece health
|
|
* @return cost
|
|
*/
|
|
public static int getRepairCost(int base, int level, double health, double healthMax) {
|
|
return (int) Math.round(getLevelCost(base, level) * (1 - health / healthMax));
|
|
}
|
|
|
|
/**
|
|
* Get piece cost for selling
|
|
*
|
|
* @param base base cost (level 1)
|
|
* @param level current level
|
|
* @param health health of the piece
|
|
* @param healthMax max piece health
|
|
* @return total cost
|
|
*/
|
|
public static int getPieceCost(int base, int level, double health, double healthMax) {
|
|
return getLevelCost(base, level) - getRepairCost(base, level, health, healthMax);
|
|
}
|
|
|
|
/**
|
|
* Get piece base cost for other calculations
|
|
*
|
|
* @param id piece name
|
|
* @return cost of level 1.
|
|
*/
|
|
public static int getBaseCost(String id) {
|
|
if (id.equals("")) return -1;
|
|
return pieces.get(id).baseCost;
|
|
}
|
|
|
|
/**
|
|
* Get piece name for tooltip
|
|
*
|
|
* @param id name
|
|
* @return tooltip text
|
|
*/
|
|
public static String getPieceLabel(String id) {
|
|
return pieces.get(id).label;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get piece group key
|
|
*
|
|
* @param id name
|
|
* @return group key
|
|
*/
|
|
public static String getPieceGroup(String id) {
|
|
return pieces.get(id).group;
|
|
}
|
|
|
|
/**
|
|
* Get group label
|
|
*
|
|
* @param id key
|
|
* @return group label
|
|
*/
|
|
public static String getGroupLabel(String id) {
|
|
return groups.get(id);
|
|
}
|
|
|
|
/**
|
|
* Get discovery key, discovery needed to buy piece (eg. "body","cannon")
|
|
*
|
|
* @param pieceName
|
|
* @return discovery key
|
|
*/
|
|
public static String getPieceDiscoveryKey(String pieceName) {
|
|
return pieces.get(pieceName).discovery;
|
|
}
|
|
|
|
}
|
|
|