feat: ajout des transmuteurs de la classe directions.

This commit is contained in:
Nicolas Hordé 2016-01-18 00:33:06 +01:00
parent 5ad0b46df5
commit 99e3e04ab6
7 changed files with 1462 additions and 3 deletions

View File

@ -28,6 +28,10 @@ import com.badlogic.gdx.utils.viewport.FitViewport;
import com.badlogic.gdx.utils.viewport.ScalingViewport; import com.badlogic.gdx.utils.viewport.ScalingViewport;
import com.badlogic.gdx.utils.viewport.StretchViewport; import com.badlogic.gdx.utils.viewport.StretchViewport;
import com.badlogic.gdx.Application; import com.badlogic.gdx.Application;
import fr.evolving.automata.Insufler100;
import fr.evolving.automata.Insufler33;
import fr.evolving.automata.Insufler50;
import fr.evolving.automata.Inverter_I; import fr.evolving.automata.Inverter_I;
import fr.evolving.automata.Inverter_II; import fr.evolving.automata.Inverter_II;
import fr.evolving.automata.Negativer; import fr.evolving.automata.Negativer;
@ -36,11 +40,13 @@ import fr.evolving.automata.Negativer_II;
import fr.evolving.automata.Negativer_III; import fr.evolving.automata.Negativer_III;
import fr.evolving.automata.Neutraliser_I; import fr.evolving.automata.Neutraliser_I;
import fr.evolving.automata.Neutraliser_II; import fr.evolving.automata.Neutraliser_II;
import fr.evolving.automata.Oneway;
import fr.evolving.automata.Positiver; import fr.evolving.automata.Positiver;
import fr.evolving.automata.Positiver_I; import fr.evolving.automata.Positiver_I;
import fr.evolving.automata.Positiver_II; import fr.evolving.automata.Positiver_II;
import fr.evolving.automata.Positiver_III; import fr.evolving.automata.Positiver_III;
import fr.evolving.automata.Transmuter; import fr.evolving.automata.Transmuter;
import fr.evolving.automata.distributor;
import fr.evolving.database.Base.datatype; import fr.evolving.database.Base.datatype;
import fr.evolving.database.DatabaseManager; import fr.evolving.database.DatabaseManager;
import fr.evolving.database.LocalBase; import fr.evolving.database.LocalBase;
@ -192,6 +198,11 @@ public class AssetLoader {
allTransmuter.add(new Inverter_II(null)); allTransmuter.add(new Inverter_II(null));
allTransmuter.add(new Neutraliser_I(null)); allTransmuter.add(new Neutraliser_I(null));
allTransmuter.add(new Neutraliser_II(null)); allTransmuter.add(new Neutraliser_II(null));
allTransmuter.add(new Oneway(null));
allTransmuter.add(new distributor(null));
allTransmuter.add(new Insufler100(null));
allTransmuter.add(new Insufler33(null));
allTransmuter.add(new Insufler50(null));
for (Transmuter transmuter : allTransmuter) { for (Transmuter transmuter : allTransmuter) {
Values<Integer> allTiles = transmuter.getTilesid().iterator(); Values<Integer> allTiles = transmuter.getTilesid().iterator();
while (allTiles.hasNext()) { while (allTiles.hasNext()) {

View File

@ -0,0 +1,293 @@
package fr.evolving.automata;
import java.util.Iterator;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.ObjectMap.Values;
import com.badlogic.gdx.utils.OrderedMap;
public class Insufler100 extends Transmuter {
private static String Name, Desc;
private static Class theClass;
private static int Price;
private static int Technology;
private static int Research;
private static Transmuter Upgrade;
private static Transmuter Unlock;
private static boolean showed;
private static boolean CanUpgradeTemp;
private static boolean CanUpgradeCycle;
private static boolean CanUpgradeRayon;
private static boolean CanUpgradeNrj;
private static float UpgradedTemp;
private static float UpgradedCycle;
private static float UpgradedRayon;
private static float UpgradedNrj;
private static float UsedTemp;
private static float UsedRayon;
private static float UsedNrj;
private static float TurnTemp;
private static float TurnRayon;
private static float TurnNrj;
private static boolean Activable;
private int ActivationLevel;
private int Rotation;
private static OrderedMap<Vector2, CaseType> Tilestype;
private static OrderedMap<Vector2, Integer> Tilesid;
public Insufler100(Level level) {
super(level);
this.Name = "Insufleur 100%";
this.Desc = "Insufleur blabla avec avecave aveca vecavec avec avec avec avecavecavecavec avec avecavecavec avec avecavecavecavec avec";
this.theClass = Class.Charge;
this.Price = 50;
this.Technology = 2;
this.Research = 0;
this.Upgrade = new Positiver_II(level);
this.Unlock = null;
this.showed = true;
this.CanUpgradeTemp = true;
this.CanUpgradeCycle = true;
this.CanUpgradeRayon = false;
this.CanUpgradeNrj = false;
this.UpgradedTemp = 1f;
this.UpgradedCycle = 1f;
this.UpgradedRayon = 1f;
this.UpgradedNrj = 1f;
this.UsedTemp = 0.5f;
this.UsedRayon = 0f;
this.UsedNrj = 0f;
this.TurnTemp = 0f;
this.TurnRayon = 0f;
this.TurnNrj = 0f;
this.Activable = true;
this.ActivationLevel = 0;
this.Tilestype = new OrderedMap<Vector2, CaseType>();
this.Tilestype.put(new Vector2(-1, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, 1), CaseType.Rien);
this.Tilestype.put(new Vector2(-1, 0), CaseType.Rien);
this.Tilestype.put(new Vector2(0, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(-1, -1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, -1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, -1), CaseType.Rien);
this.Tilesid = new OrderedMap<Vector2, Integer>();
this.Tilesid.put(new Vector2(-1, 1), 120);
this.Tilesid.put(new Vector2(0,1), 121);
this.Tilesid.put(new Vector2(1, 1), 122);
this.Tilesid.put(new Vector2(-1, 0), 123);
this.Tilesid.put(new Vector2(0, 0), 124);
this.Tilesid.put(new Vector2(1, 0), 125);
this.Tilesid.put(new Vector2(-1, -1), 126);
this.Tilesid.put(new Vector2(0, -1), 127);
this.Tilesid.put(new Vector2(1, -1), 128);
}
public String getName() {
return this.Name;
}
public String getDesc() {
return this.Desc;
}
public String getaClass() {
return this.theClass.toString();
}
public void ProcessCycle() {
this.level.Temp += TurnTemp * UpgradedTemp;
this.level.Rayon += TurnRayon * UpgradedRayon;
this.level.Nrj += TurnNrj * UpgradedNrj;
if (this.Activable)
this.ActivationLevel -= 1;
}
public void Run() {
this.level.Temp += UsedTemp * UpgradedTemp;
this.level.Rayon += UsedRayon * UpgradedRayon;
this.level.Nrj += UsedNrj * UpgradedNrj;
}
public void Unlock() {
if (this.Unlock == null)
return;
this.Unlock.SetShowed(true);
}
public void Upgrade() {
if (this.Upgrade == null)
return;
this.Unlock.SetShowed(true);
this.SetShowed(false);
}
public void Activate() {
if (this.Activable)
ActivationLevel = this.getMaxActivationLevel();
}
public void UpgradeTemp() {
if (isUpgradableTemp())
UpgradedTemp += -0.2f;
}
public void UpgradeNrj() {
if (isUpgradableNrj())
UpgradedNrj += -0.2f;
}
public void UpgradeRayon() {
if (isUpgradableRayon())
UpgradedRayon += -0.2f;
}
public void UpgradeCycle() {
if (isUpgradableCycle())
UpgradedCycle += 0.2f;
}
public Values<Integer> getTilesid() {
return Tilesid.values();
}
public CaseType getTilestype(int order) {
return Tilestype.values().toArray().get(order);
}
public OrderedMap<Vector2, Integer> getTilesidrotated() {
OrderedMap<Vector2, Integer> newTiles = new OrderedMap<Vector2, Integer>();
Iterator<Vector2> tiles = this.Tilesid.keys();
while (tiles.hasNext()) {
Vector2 key = tiles.next();
double delta = key.len();
double alpha = key.angleRad() + this.getRotation().ordinal()
* Math.PI / 2;
newTiles.put(
new Vector2((float) Math.round(delta * Math.cos(alpha)),
(float) Math.round(delta * Math.sin(alpha))),
this.Tilesid.get(key));
}
return newTiles;
}
public boolean isActivable() {
return this.Activable;
}
public int getMaxActivationLevel() {
return ActivationLevel = (int) (10 * this.UpgradedCycle);
}
public int getActivationLevel() {
if (this.Activable)
return ActivationLevel;
else
return -1;
}
public boolean getActivation() {
if (this.Activable)
return ActivationLevel > 0;
else
return true;
}
public int getPrice() {
return Price;
}
public int getSize() {
return (Tilesid.size);
}
public int getTechnology() {
return Technology;
}
public int getResearch() {
return Research;
}
public boolean isUpgradable() {
return this.Upgrade != null && this.Upgrade.isShowed();
}
public boolean isUnlockable() {
return this.Unlock != null && this.Unlock.isShowed();
}
public boolean isShowed() {
return this.showed;
}
public void SetShowed(boolean value) {
this.showed = value;
}
public boolean isUpgradableTemp() {
return CanUpgradeTemp && getUpgradeTemp() < 3;
}
public boolean isUpgradableCycle() {
return CanUpgradeCycle && getUpgradeCycle() < 3;
}
public boolean isUpgradableRayon() {
return CanUpgradeRayon && getUpgradeRayon() < 3;
}
public boolean isUpgradableNrj() {
return CanUpgradeNrj && getUpgradeNrj() < 3;
}
public int getUpgradeTemp() {
return Math.abs((int) ((10 * UpgradedTemp - 10) / 2f));
}
public int getUpgradeCycle() {
return Math.abs((int) ((10 * UpgradedCycle - 10) / 2f));
}
public int getUpgradeRayon() {
return Math.abs((int) ((10 * UpgradedRayon - 10) / 2f));
}
public int getUpgradeNrj() {
return Math.abs((int) ((10 * UpgradedNrj - 10) / 2f));
}
public float getUsedTemp() {
return UsedTemp * UpgradedTemp;
}
public float getUsedRayon() {
return UsedRayon * UpgradedRayon;
}
public float getUsedNrj() {
return UsedNrj * UpgradedNrj;
}
public float getTurnTemp() {
return TurnTemp * UpgradedTemp;
}
public float getTurnRayon() {
return TurnRayon * UpgradedRayon;
}
public float getTurnNrj() {
return TurnNrj * UpgradedNrj;
}
public Transmuter getUpgrade() {
return this.Upgrade;
}
public Transmuter getUnlock() {
return this.Unlock;
}
}

View File

@ -0,0 +1,295 @@
package fr.evolving.automata;
import java.util.Iterator;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.ObjectMap.Values;
import com.badlogic.gdx.utils.OrderedMap;
import fr.evolving.automata.Transmuter.CaseType;
public class Insufler33 extends Transmuter {
private static String Name, Desc;
private static Class theClass;
private static int Price;
private static int Technology;
private static int Research;
private static Transmuter Upgrade;
private static Transmuter Unlock;
private static boolean showed;
private static boolean CanUpgradeTemp;
private static boolean CanUpgradeCycle;
private static boolean CanUpgradeRayon;
private static boolean CanUpgradeNrj;
private static float UpgradedTemp;
private static float UpgradedCycle;
private static float UpgradedRayon;
private static float UpgradedNrj;
private static float UsedTemp;
private static float UsedRayon;
private static float UsedNrj;
private static float TurnTemp;
private static float TurnRayon;
private static float TurnNrj;
private static boolean Activable;
private int ActivationLevel;
private int Rotation;
private static OrderedMap<Vector2, CaseType> Tilestype;
private static OrderedMap<Vector2, Integer> Tilesid;
public Insufler33(Level level) {
super(level);
this.Name = "Insufleur 33%";
this.Desc = "Insufleur 33% avecave aveca vecavec avec avec avec avecavecavecavec avec avecavecavec avec avecavecavecavec avec";
this.theClass = Class.Charge;
this.Price = 50;
this.Technology = 2;
this.Research = 0;
this.Upgrade = new Positiver_II(level);
this.Unlock = null;
this.showed = true;
this.CanUpgradeTemp = true;
this.CanUpgradeCycle = true;
this.CanUpgradeRayon = false;
this.CanUpgradeNrj = false;
this.UpgradedTemp = 1f;
this.UpgradedCycle = 1f;
this.UpgradedRayon = 1f;
this.UpgradedNrj = 1f;
this.UsedTemp = 0.5f;
this.UsedRayon = 0f;
this.UsedNrj = 0f;
this.TurnTemp = 0f;
this.TurnRayon = 0f;
this.TurnNrj = 0f;
this.Activable = true;
this.ActivationLevel = 0;
this.Tilestype = new OrderedMap<Vector2, CaseType>();
this.Tilestype.put(new Vector2(-1, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, 1), CaseType.Rien);
this.Tilestype.put(new Vector2(-1, 0), CaseType.Rien);
this.Tilestype.put(new Vector2(0, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(-1, -1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, -1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, -1), CaseType.Rien);
this.Tilesid = new OrderedMap<Vector2, Integer>();
this.Tilesid.put(new Vector2(-1, 1), 120);
this.Tilesid.put(new Vector2(0,1), 121);
this.Tilesid.put(new Vector2(1, 1), 122);
this.Tilesid.put(new Vector2(-1, 0), 123);
this.Tilesid.put(new Vector2(0, 0), 129);
this.Tilesid.put(new Vector2(1, 0), 125);
this.Tilesid.put(new Vector2(-1, -1), 126);
this.Tilesid.put(new Vector2(0, -1), 127);
this.Tilesid.put(new Vector2(1, -1), 128);
}
public String getName() {
return this.Name;
}
public String getDesc() {
return this.Desc;
}
public String getaClass() {
return this.theClass.toString();
}
public void ProcessCycle() {
this.level.Temp += TurnTemp * UpgradedTemp;
this.level.Rayon += TurnRayon * UpgradedRayon;
this.level.Nrj += TurnNrj * UpgradedNrj;
if (this.Activable)
this.ActivationLevel -= 1;
}
public void Run() {
this.level.Temp += UsedTemp * UpgradedTemp;
this.level.Rayon += UsedRayon * UpgradedRayon;
this.level.Nrj += UsedNrj * UpgradedNrj;
}
public void Unlock() {
if (this.Unlock == null)
return;
this.Unlock.SetShowed(true);
}
public void Upgrade() {
if (this.Upgrade == null)
return;
this.Unlock.SetShowed(true);
this.SetShowed(false);
}
public void Activate() {
if (this.Activable)
ActivationLevel = this.getMaxActivationLevel();
}
public void UpgradeTemp() {
if (isUpgradableTemp())
UpgradedTemp += -0.2f;
}
public void UpgradeNrj() {
if (isUpgradableNrj())
UpgradedNrj += -0.2f;
}
public void UpgradeRayon() {
if (isUpgradableRayon())
UpgradedRayon += -0.2f;
}
public void UpgradeCycle() {
if (isUpgradableCycle())
UpgradedCycle += 0.2f;
}
public Values<Integer> getTilesid() {
return Tilesid.values();
}
public CaseType getTilestype(int order) {
return Tilestype.values().toArray().get(order);
}
public OrderedMap<Vector2, Integer> getTilesidrotated() {
OrderedMap<Vector2, Integer> newTiles = new OrderedMap<Vector2, Integer>();
Iterator<Vector2> tiles = this.Tilesid.keys();
while (tiles.hasNext()) {
Vector2 key = tiles.next();
double delta = key.len();
double alpha = key.angleRad() + this.getRotation().ordinal()
* Math.PI / 2;
newTiles.put(
new Vector2((float) Math.round(delta * Math.cos(alpha)),
(float) Math.round(delta * Math.sin(alpha))),
this.Tilesid.get(key));
}
return newTiles;
}
public boolean isActivable() {
return this.Activable;
}
public int getMaxActivationLevel() {
return ActivationLevel = (int) (10 * this.UpgradedCycle);
}
public int getActivationLevel() {
if (this.Activable)
return ActivationLevel;
else
return -1;
}
public boolean getActivation() {
if (this.Activable)
return ActivationLevel > 0;
else
return true;
}
public int getPrice() {
return Price;
}
public int getSize() {
return (Tilesid.size);
}
public int getTechnology() {
return Technology;
}
public int getResearch() {
return Research;
}
public boolean isUpgradable() {
return this.Upgrade != null && this.Upgrade.isShowed();
}
public boolean isUnlockable() {
return this.Unlock != null && this.Unlock.isShowed();
}
public boolean isShowed() {
return this.showed;
}
public void SetShowed(boolean value) {
this.showed = value;
}
public boolean isUpgradableTemp() {
return CanUpgradeTemp && getUpgradeTemp() < 3;
}
public boolean isUpgradableCycle() {
return CanUpgradeCycle && getUpgradeCycle() < 3;
}
public boolean isUpgradableRayon() {
return CanUpgradeRayon && getUpgradeRayon() < 3;
}
public boolean isUpgradableNrj() {
return CanUpgradeNrj && getUpgradeNrj() < 3;
}
public int getUpgradeTemp() {
return Math.abs((int) ((10 * UpgradedTemp - 10) / 2f));
}
public int getUpgradeCycle() {
return Math.abs((int) ((10 * UpgradedCycle - 10) / 2f));
}
public int getUpgradeRayon() {
return Math.abs((int) ((10 * UpgradedRayon - 10) / 2f));
}
public int getUpgradeNrj() {
return Math.abs((int) ((10 * UpgradedNrj - 10) / 2f));
}
public float getUsedTemp() {
return UsedTemp * UpgradedTemp;
}
public float getUsedRayon() {
return UsedRayon * UpgradedRayon;
}
public float getUsedNrj() {
return UsedNrj * UpgradedNrj;
}
public float getTurnTemp() {
return TurnTemp * UpgradedTemp;
}
public float getTurnRayon() {
return TurnRayon * UpgradedRayon;
}
public float getTurnNrj() {
return TurnNrj * UpgradedNrj;
}
public Transmuter getUpgrade() {
return this.Upgrade;
}
public Transmuter getUnlock() {
return this.Unlock;
}
}

View File

@ -0,0 +1,295 @@
package fr.evolving.automata;
import java.util.Iterator;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.ObjectMap.Values;
import com.badlogic.gdx.utils.OrderedMap;
import fr.evolving.automata.Transmuter.CaseType;
public class Insufler50 extends Transmuter {
private static String Name, Desc;
private static Class theClass;
private static int Price;
private static int Technology;
private static int Research;
private static Transmuter Upgrade;
private static Transmuter Unlock;
private static boolean showed;
private static boolean CanUpgradeTemp;
private static boolean CanUpgradeCycle;
private static boolean CanUpgradeRayon;
private static boolean CanUpgradeNrj;
private static float UpgradedTemp;
private static float UpgradedCycle;
private static float UpgradedRayon;
private static float UpgradedNrj;
private static float UsedTemp;
private static float UsedRayon;
private static float UsedNrj;
private static float TurnTemp;
private static float TurnRayon;
private static float TurnNrj;
private static boolean Activable;
private int ActivationLevel;
private int Rotation;
private static OrderedMap<Vector2, CaseType> Tilestype;
private static OrderedMap<Vector2, Integer> Tilesid;
public Insufler50(Level level) {
super(level);
this.Name = "Insufleur 50%";
this.Desc = "Insufleur 50% avecave aveca vecavec avec avec avec avecavecavecavec avec avecavecavec avec avecavecavecavec avec";
this.theClass = Class.Charge;
this.Price = 50;
this.Technology = 2;
this.Research = 0;
this.Upgrade = new Positiver_II(level);
this.Unlock = null;
this.showed = true;
this.CanUpgradeTemp = true;
this.CanUpgradeCycle = true;
this.CanUpgradeRayon = false;
this.CanUpgradeNrj = false;
this.UpgradedTemp = 1f;
this.UpgradedCycle = 1f;
this.UpgradedRayon = 1f;
this.UpgradedNrj = 1f;
this.UsedTemp = 0.5f;
this.UsedRayon = 0f;
this.UsedNrj = 0f;
this.TurnTemp = 0f;
this.TurnRayon = 0f;
this.TurnNrj = 0f;
this.Activable = true;
this.ActivationLevel = 0;
this.Tilestype = new OrderedMap<Vector2, CaseType>();
this.Tilestype.put(new Vector2(-1, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, 1), CaseType.Rien);
this.Tilestype.put(new Vector2(-1, 0), CaseType.Rien);
this.Tilestype.put(new Vector2(0, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(-1, -1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, -1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(1, -1), CaseType.Rien);
this.Tilesid = new OrderedMap<Vector2, Integer>();
this.Tilesid.put(new Vector2(-1, 1), 120);
this.Tilesid.put(new Vector2(0,1), 121);
this.Tilesid.put(new Vector2(1, 1), 122);
this.Tilesid.put(new Vector2(-1, 0), 123);
this.Tilesid.put(new Vector2(0, 0), 130);
this.Tilesid.put(new Vector2(1, 0), 125);
this.Tilesid.put(new Vector2(-1, -1), 126);
this.Tilesid.put(new Vector2(0, -1), 127);
this.Tilesid.put(new Vector2(1, -1), 128);
}
public String getName() {
return this.Name;
}
public String getDesc() {
return this.Desc;
}
public String getaClass() {
return this.theClass.toString();
}
public void ProcessCycle() {
this.level.Temp += TurnTemp * UpgradedTemp;
this.level.Rayon += TurnRayon * UpgradedRayon;
this.level.Nrj += TurnNrj * UpgradedNrj;
if (this.Activable)
this.ActivationLevel -= 1;
}
public void Run() {
this.level.Temp += UsedTemp * UpgradedTemp;
this.level.Rayon += UsedRayon * UpgradedRayon;
this.level.Nrj += UsedNrj * UpgradedNrj;
}
public void Unlock() {
if (this.Unlock == null)
return;
this.Unlock.SetShowed(true);
}
public void Upgrade() {
if (this.Upgrade == null)
return;
this.Unlock.SetShowed(true);
this.SetShowed(false);
}
public void Activate() {
if (this.Activable)
ActivationLevel = this.getMaxActivationLevel();
}
public void UpgradeTemp() {
if (isUpgradableTemp())
UpgradedTemp += -0.2f;
}
public void UpgradeNrj() {
if (isUpgradableNrj())
UpgradedNrj += -0.2f;
}
public void UpgradeRayon() {
if (isUpgradableRayon())
UpgradedRayon += -0.2f;
}
public void UpgradeCycle() {
if (isUpgradableCycle())
UpgradedCycle += 0.2f;
}
public Values<Integer> getTilesid() {
return Tilesid.values();
}
public CaseType getTilestype(int order) {
return Tilestype.values().toArray().get(order);
}
public OrderedMap<Vector2, Integer> getTilesidrotated() {
OrderedMap<Vector2, Integer> newTiles = new OrderedMap<Vector2, Integer>();
Iterator<Vector2> tiles = this.Tilesid.keys();
while (tiles.hasNext()) {
Vector2 key = tiles.next();
double delta = key.len();
double alpha = key.angleRad() + this.getRotation().ordinal()
* Math.PI / 2;
newTiles.put(
new Vector2((float) Math.round(delta * Math.cos(alpha)),
(float) Math.round(delta * Math.sin(alpha))),
this.Tilesid.get(key));
}
return newTiles;
}
public boolean isActivable() {
return this.Activable;
}
public int getMaxActivationLevel() {
return ActivationLevel = (int) (10 * this.UpgradedCycle);
}
public int getActivationLevel() {
if (this.Activable)
return ActivationLevel;
else
return -1;
}
public boolean getActivation() {
if (this.Activable)
return ActivationLevel > 0;
else
return true;
}
public int getPrice() {
return Price;
}
public int getSize() {
return (Tilesid.size);
}
public int getTechnology() {
return Technology;
}
public int getResearch() {
return Research;
}
public boolean isUpgradable() {
return this.Upgrade != null && this.Upgrade.isShowed();
}
public boolean isUnlockable() {
return this.Unlock != null && this.Unlock.isShowed();
}
public boolean isShowed() {
return this.showed;
}
public void SetShowed(boolean value) {
this.showed = value;
}
public boolean isUpgradableTemp() {
return CanUpgradeTemp && getUpgradeTemp() < 3;
}
public boolean isUpgradableCycle() {
return CanUpgradeCycle && getUpgradeCycle() < 3;
}
public boolean isUpgradableRayon() {
return CanUpgradeRayon && getUpgradeRayon() < 3;
}
public boolean isUpgradableNrj() {
return CanUpgradeNrj && getUpgradeNrj() < 3;
}
public int getUpgradeTemp() {
return Math.abs((int) ((10 * UpgradedTemp - 10) / 2f));
}
public int getUpgradeCycle() {
return Math.abs((int) ((10 * UpgradedCycle - 10) / 2f));
}
public int getUpgradeRayon() {
return Math.abs((int) ((10 * UpgradedRayon - 10) / 2f));
}
public int getUpgradeNrj() {
return Math.abs((int) ((10 * UpgradedNrj - 10) / 2f));
}
public float getUsedTemp() {
return UsedTemp * UpgradedTemp;
}
public float getUsedRayon() {
return UsedRayon * UpgradedRayon;
}
public float getUsedNrj() {
return UsedNrj * UpgradedNrj;
}
public float getTurnTemp() {
return TurnTemp * UpgradedTemp;
}
public float getTurnRayon() {
return TurnRayon * UpgradedRayon;
}
public float getTurnNrj() {
return TurnNrj * UpgradedNrj;
}
public Transmuter getUpgrade() {
return this.Upgrade;
}
public Transmuter getUnlock() {
return this.Unlock;
}
}

View File

@ -0,0 +1,277 @@
package fr.evolving.automata;
import java.util.Iterator;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.ObjectMap.Values;
import com.badlogic.gdx.utils.OrderedMap;
public class Oneway extends Transmuter {
private static String Name, Desc;
private static Class theClass;
private static int Price;
private static int Technology;
private static int Research;
private static Transmuter Upgrade;
private static Transmuter Unlock;
private static boolean showed;
private static boolean CanUpgradeTemp;
private static boolean CanUpgradeCycle;
private static boolean CanUpgradeRayon;
private static boolean CanUpgradeNrj;
private static float UpgradedTemp;
private static float UpgradedCycle;
private static float UpgradedRayon;
private static float UpgradedNrj;
private static float UsedTemp;
private static float UsedRayon;
private static float UsedNrj;
private static float TurnTemp;
private static float TurnRayon;
private static float TurnNrj;
private static boolean Activable;
private int ActivationLevel;
private int Rotation;
private static OrderedMap<Vector2, CaseType> Tilestype;
private static OrderedMap<Vector2, Integer> Tilesid;
public Oneway(Level level) {
super(level);
this.Name = "Antiretour";
this.Desc = "Antiretour avec...blabla avec...blabla avec avecave aveca vecavec avec avec avec avecavecavecavec avec avecavecavec avec avecavecavecavec avec";
this.theClass = Class.Charge;
this.Price = 50;
this.Technology = 2;
this.Research = 0;
this.Upgrade = new Positiver_II(level);
this.Unlock = null;
this.showed = true;
this.CanUpgradeTemp = true;
this.CanUpgradeCycle = true;
this.CanUpgradeRayon = false;
this.CanUpgradeNrj = false;
this.UpgradedTemp = 1f;
this.UpgradedCycle = 1f;
this.UpgradedRayon = 1f;
this.UpgradedNrj = 1f;
this.UsedTemp = 0.5f;
this.UsedRayon = 0f;
this.UsedNrj = 0f;
this.TurnTemp = 0f;
this.TurnRayon = 0f;
this.TurnNrj = 0f;
this.Activable = true;
this.ActivationLevel = 0;
this.Tilestype = new OrderedMap<Vector2, CaseType>();
this.Tilestype.put(new Vector2(0, 0), CaseType.Cuivre);
this.Tilesid = new OrderedMap<Vector2, Integer>();
this.Tilesid.put(new Vector2(0, 0), 114);
}
public String getName() {
return this.Name;
}
public String getDesc() {
return this.Desc;
}
public String getaClass() {
return this.theClass.toString();
}
public void ProcessCycle() {
this.level.Temp += TurnTemp * UpgradedTemp;
this.level.Rayon += TurnRayon * UpgradedRayon;
this.level.Nrj += TurnNrj * UpgradedNrj;
if (this.Activable)
this.ActivationLevel -= 1;
}
public void Run() {
this.level.Temp += UsedTemp * UpgradedTemp;
this.level.Rayon += UsedRayon * UpgradedRayon;
this.level.Nrj += UsedNrj * UpgradedNrj;
}
public void Unlock() {
if (this.Unlock == null)
return;
this.Unlock.SetShowed(true);
}
public void Upgrade() {
if (this.Upgrade == null)
return;
this.Unlock.SetShowed(true);
this.SetShowed(false);
}
public void Activate() {
if (this.Activable)
ActivationLevel = this.getMaxActivationLevel();
}
public void UpgradeTemp() {
if (isUpgradableTemp())
UpgradedTemp += -0.2f;
}
public void UpgradeNrj() {
if (isUpgradableNrj())
UpgradedNrj += -0.2f;
}
public void UpgradeRayon() {
if (isUpgradableRayon())
UpgradedRayon += -0.2f;
}
public void UpgradeCycle() {
if (isUpgradableCycle())
UpgradedCycle += 0.2f;
}
public Values<Integer> getTilesid() {
return Tilesid.values();
}
public CaseType getTilestype(int order) {
return Tilestype.values().toArray().get(order);
}
public OrderedMap<Vector2, Integer> getTilesidrotated() {
OrderedMap<Vector2, Integer> newTiles = new OrderedMap<Vector2, Integer>();
Iterator<Vector2> tiles = this.Tilesid.keys();
while (tiles.hasNext()) {
Vector2 key = tiles.next();
double delta = key.len();
double alpha = key.angleRad() + this.getRotation().ordinal()
* Math.PI / 2;
newTiles.put(
new Vector2((float) Math.round(delta * Math.cos(alpha)),
(float) Math.round(delta * Math.sin(alpha))),
this.Tilesid.get(key));
}
return newTiles;
}
public boolean isActivable() {
return this.Activable;
}
public int getMaxActivationLevel() {
return ActivationLevel = (int) (10 * this.UpgradedCycle);
}
public int getActivationLevel() {
if (this.Activable)
return ActivationLevel;
else
return -1;
}
public boolean getActivation() {
if (this.Activable)
return ActivationLevel > 0;
else
return true;
}
public int getPrice() {
return Price;
}
public int getSize() {
return (Tilesid.size);
}
public int getTechnology() {
return Technology;
}
public int getResearch() {
return Research;
}
public boolean isUpgradable() {
return this.Upgrade != null && this.Upgrade.isShowed();
}
public boolean isUnlockable() {
return this.Unlock != null && this.Unlock.isShowed();
}
public boolean isShowed() {
return this.showed;
}
public void SetShowed(boolean value) {
this.showed = value;
}
public boolean isUpgradableTemp() {
return CanUpgradeTemp && getUpgradeTemp() < 3;
}
public boolean isUpgradableCycle() {
return CanUpgradeCycle && getUpgradeCycle() < 3;
}
public boolean isUpgradableRayon() {
return CanUpgradeRayon && getUpgradeRayon() < 3;
}
public boolean isUpgradableNrj() {
return CanUpgradeNrj && getUpgradeNrj() < 3;
}
public int getUpgradeTemp() {
return Math.abs((int) ((10 * UpgradedTemp - 10) / 2f));
}
public int getUpgradeCycle() {
return Math.abs((int) ((10 * UpgradedCycle - 10) / 2f));
}
public int getUpgradeRayon() {
return Math.abs((int) ((10 * UpgradedRayon - 10) / 2f));
}
public int getUpgradeNrj() {
return Math.abs((int) ((10 * UpgradedNrj - 10) / 2f));
}
public float getUsedTemp() {
return UsedTemp * UpgradedTemp;
}
public float getUsedRayon() {
return UsedRayon * UpgradedRayon;
}
public float getUsedNrj() {
return UsedNrj * UpgradedNrj;
}
public float getTurnTemp() {
return TurnTemp * UpgradedTemp;
}
public float getTurnRayon() {
return TurnRayon * UpgradedRayon;
}
public float getTurnNrj() {
return TurnNrj * UpgradedNrj;
}
public Transmuter getUpgrade() {
return this.Upgrade;
}
public Transmuter getUnlock() {
return this.Unlock;
}
}

View File

@ -0,0 +1,285 @@
package fr.evolving.automata;
import java.util.Iterator;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.utils.ObjectMap.Values;
import com.badlogic.gdx.utils.OrderedMap;
public class distributor extends Transmuter {
private static String Name, Desc;
private static Class theClass;
private static int Price;
private static int Technology;
private static int Research;
private static Transmuter Upgrade;
private static Transmuter Unlock;
private static boolean showed;
private static boolean CanUpgradeTemp;
private static boolean CanUpgradeCycle;
private static boolean CanUpgradeRayon;
private static boolean CanUpgradeNrj;
private static float UpgradedTemp;
private static float UpgradedCycle;
private static float UpgradedRayon;
private static float UpgradedNrj;
private static float UsedTemp;
private static float UsedRayon;
private static float UsedNrj;
private static float TurnTemp;
private static float TurnRayon;
private static float TurnNrj;
private static boolean Activable;
private int ActivationLevel;
private int Rotation;
private static OrderedMap<Vector2, CaseType> Tilestype;
private static OrderedMap<Vector2, Integer> Tilesid;
public distributor(Level level) {
super(level);
this.Name = "Distributeur";
this.Desc = "Distribue lol avec avecave aveca vecavec avec avec avec avecavecavecavec avec avecavecavec avec avecavecavecavec avec";
this.theClass = Class.Direction;
this.Price = 50;
this.Technology = 2;
this.Research = 0;
this.Upgrade = null;
this.Unlock = null;
this.showed = true;
this.CanUpgradeTemp = true;
this.CanUpgradeCycle = true;
this.CanUpgradeRayon = false;
this.CanUpgradeNrj = false;
this.UpgradedTemp = 1f;
this.UpgradedCycle = 1f;
this.UpgradedRayon = 1f;
this.UpgradedNrj = 1f;
this.UsedTemp = 0.5f;
this.UsedRayon = 0f;
this.UsedNrj = 0f;
this.TurnTemp = 0f;
this.TurnRayon = 0f;
this.TurnNrj = 0f;
this.Activable = true;
this.ActivationLevel = 0;
this.Tilestype = new OrderedMap<Vector2, CaseType>();
this.Tilestype.put(new Vector2(0, 1), CaseType.Cuivre);
this.Tilestype.put(new Vector2(-1, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, 0), CaseType.Tout);
this.Tilestype.put(new Vector2(1, 0), CaseType.Cuivre);
this.Tilestype.put(new Vector2(0, -1), CaseType.Cuivre);
this.Tilesid = new OrderedMap<Vector2, Integer>();
this.Tilesid.put(new Vector2(0, 1), 115);
this.Tilesid.put(new Vector2(-1, 0), 116);
this.Tilesid.put(new Vector2(0, 0), 117);
this.Tilesid.put(new Vector2(1, 0), 118);
this.Tilesid.put(new Vector2(0, -1), 119);
}
public String getName() {
return this.Name;
}
public String getDesc() {
return this.Desc;
}
public String getaClass() {
return this.theClass.toString();
}
public void ProcessCycle() {
this.level.Temp += TurnTemp * UpgradedTemp;
this.level.Rayon += TurnRayon * UpgradedRayon;
this.level.Nrj += TurnNrj * UpgradedNrj;
if (this.Activable)
this.ActivationLevel -= 1;
}
public void Run() {
this.level.Temp += UsedTemp * UpgradedTemp;
this.level.Rayon += UsedRayon * UpgradedRayon;
this.level.Nrj += UsedNrj * UpgradedNrj;
}
public void Unlock() {
if (this.Unlock == null)
return;
this.Unlock.SetShowed(true);
}
public void Upgrade() {
if (this.Upgrade == null)
return;
this.Unlock.SetShowed(true);
this.SetShowed(false);
}
public void Activate() {
if (this.Activable)
ActivationLevel = this.getMaxActivationLevel();
}
public void UpgradeTemp() {
if (isUpgradableTemp())
UpgradedTemp += -0.2f;
}
public void UpgradeNrj() {
if (isUpgradableNrj())
UpgradedNrj += -0.2f;
}
public void UpgradeRayon() {
if (isUpgradableRayon())
UpgradedRayon += -0.2f;
}
public void UpgradeCycle() {
if (isUpgradableCycle())
UpgradedCycle += 0.2f;
}
public Values<Integer> getTilesid() {
return Tilesid.values();
}
public CaseType getTilestype(int order) {
return Tilestype.values().toArray().get(order);
}
public OrderedMap<Vector2, Integer> getTilesidrotated() {
OrderedMap<Vector2, Integer> newTiles = new OrderedMap<Vector2, Integer>();
Iterator<Vector2> tiles = this.Tilesid.keys();
while (tiles.hasNext()) {
Vector2 key = tiles.next();
double delta = key.len();
double alpha = key.angleRad() + this.getRotation().ordinal()
* Math.PI / 2;
newTiles.put(
new Vector2((float) Math.round(delta * Math.cos(alpha)),
(float) Math.round(delta * Math.sin(alpha))),
this.Tilesid.get(key));
}
return newTiles;
}
public boolean isActivable() {
return this.Activable;
}
public int getMaxActivationLevel() {
return ActivationLevel = (int) (10 * this.UpgradedCycle);
}
public int getActivationLevel() {
if (this.Activable)
return ActivationLevel;
else
return -1;
}
public boolean getActivation() {
if (this.Activable)
return ActivationLevel > 0;
else
return true;
}
public int getPrice() {
return Price;
}
public int getSize() {
return (Tilesid.size);
}
public int getTechnology() {
return Technology;
}
public int getResearch() {
return Research;
}
public boolean isUpgradable() {
return this.Upgrade != null && this.Upgrade.isShowed();
}
public boolean isUnlockable() {
return this.Unlock != null && this.Unlock.isShowed();
}
public boolean isShowed() {
return this.showed;
}
public void SetShowed(boolean value) {
this.showed = value;
}
public boolean isUpgradableTemp() {
return CanUpgradeTemp && getUpgradeTemp() < 3;
}
public boolean isUpgradableCycle() {
return CanUpgradeCycle && getUpgradeCycle() < 3;
}
public boolean isUpgradableRayon() {
return CanUpgradeRayon && getUpgradeRayon() < 3;
}
public boolean isUpgradableNrj() {
return CanUpgradeNrj && getUpgradeNrj() < 3;
}
public int getUpgradeTemp() {
return Math.abs((int) ((10 * UpgradedTemp - 10) / 2f));
}
public int getUpgradeCycle() {
return Math.abs((int) ((10 * UpgradedCycle - 10) / 2f));
}
public int getUpgradeRayon() {
return Math.abs((int) ((10 * UpgradedRayon - 10) / 2f));
}
public int getUpgradeNrj() {
return Math.abs((int) ((10 * UpgradedNrj - 10) / 2f));
}
public float getUsedTemp() {
return UsedTemp * UpgradedTemp;
}
public float getUsedRayon() {
return UsedRayon * UpgradedRayon;
}
public float getUsedNrj() {
return UsedNrj * UpgradedNrj;
}
public float getTurnTemp() {
return TurnTemp * UpgradedTemp;
}
public float getTurnRayon() {
return TurnRayon * UpgradedRayon;
}
public float getTurnNrj() {
return TurnNrj * UpgradedNrj;
}
public Transmuter getUpgrade() {
return this.Upgrade;
}
public Transmuter getUnlock() {
return this.Unlock;
}
}

View File

@ -56,6 +56,7 @@ import fr.evolving.UI.WarnDialog;
import fr.evolving.assets.AssetLoader; import fr.evolving.assets.AssetLoader;
import fr.evolving.assets.Preference; import fr.evolving.assets.Preference;
import fr.evolving.automata.Level; import fr.evolving.automata.Level;
import fr.evolving.automata.Neutraliser_II;
import fr.evolving.automata.Transmuter; import fr.evolving.automata.Transmuter;
import fr.evolving.automata.Transmuter.Angular; import fr.evolving.automata.Transmuter.Angular;
import fr.evolving.automata.Transmuter.CaseType; import fr.evolving.automata.Transmuter.CaseType;
@ -966,11 +967,13 @@ public class GameScreen implements Screen {
menu.setMenuTransmuter(0, 3, "Neutraliseur I", Angular.A00); menu.setMenuTransmuter(0, 3, "Neutraliseur I", Angular.A00);
menu.setMenuTransmuter(1, 3, "Neutraliseur II", Angular.A00); menu.setMenuTransmuter(1, 3, "Neutraliseur II", Angular.A00);
} else if (menuitem == 2) { } else if (menuitem == 2) {
menu.setMenuTransmuter(0, 7, "Antiretour", Angular.A00);
menu.setMenuTransmuter(1, 6, "Distributeur", Angular.A00);
menu.setMenuTransmuter(1, 2, "Insufleur 33%", Angular.A00);
} else if (menuitem == 3) { } else if (menuitem == 3) {
menu.setMenuTransmuter(1, 2, "Insufleur 50%", Angular.A00);
} else if (menuitem == 4) { } else if (menuitem == 4) {
menu.setMenuTransmuter(1, 2, "Insufleur 100%", Angular.A00);
} else if (menuitem == 5) { } else if (menuitem == 5) {
} else if (menuitem == 6) { } else if (menuitem == 6) {