perso
/
WireChem
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat: ajout de fichiers précédemment oubliés dans git (dossier ui) création de la classe transmuter création de 3 classes dérivée pour le positiver 1,2 & 3 réalisation de test pour vérifier que la classe fonctionne

This commit is contained in:
Nicolas Hordé 2015-08-02 18:19:09 +02:00
parent c716f144c1
commit ee17dfd5d5
9 changed files with 1340 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
core/src/fr/evolving/UI/Menu.java Normal file
View File

@ -0,0 +1,103 @@
package fr.evolving.UI;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.maps.MapLayers;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer.Cell;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.Actor;
import fr.evolving.assets.AssetLoader;
import fr.evolving.automata.Level;
public class Menu extends Actor{
private TiledMap map;
private OrthogonalTiledMapRenderer MapRenderer;
private OrthographicCamera camera;
private int tilesizex;
private int tilesizey;
private float decx;
private float decy;
private int size=32;
public Menu(int tilesizex,int tilesizey) {
this.tilesizex=tilesizex;
this.tilesizey=tilesizey;
map=new TiledMap();
map.getTileSets().addTileSet(AssetLoader.tileSet);
MapLayers layers = map.getLayers();
for (int i = 0; i < 3; i++) {
TiledMapTileLayer layer = new TiledMapTileLayer(tilesizex, tilesizey, 128, 128);
for (int x = 0; x < layer.getWidth(); x++) {
for (int y = 0; y < layer.getHeight(); y++) {
Cell cell = new Cell();
if (i==0)
cell.setTile(AssetLoader.tileSet.getTile(54));
layer.setCell(x, y, cell);
}
}
layers.add(layer);
}
MapRenderer = new OrthogonalTiledMapRenderer(map,1/(float)size);
camera = new OrthographicCamera();
camera.setToOrtho(false, tilesizex*32,tilesizex*32*AssetLoader.height/AssetLoader.width);
Gdx.app.debug(getClass().getSimpleName(),"Caméra pour tilemap:"+(tilesizex*size)+"x"+(tilesizey*size));
decx=-102f;
decy=-20f;
camera.translate(decx,decy);
Gdx.app.debug(getClass().getSimpleName(),"Décalage:"+decx+"x"+decy);
}
public void clear()
{
TiledMapTileLayer layer = (TiledMapTileLayer) map.getLayers().get(0);
for (int x = 0; x < layer.getWidth(); x++)
for (int y = 0; y < layer.getHeight(); y++)
layer.getCell(x, y).setTile(AssetLoader.tileSet.getTile(54));
}
public void setMenu(int x,int y,int tile)
{
Cell cell=((TiledMapTileLayer)map.getLayers().get(0)).getCell(x,y);
if (cell!=null)
cell.setTile(AssetLoader.tileSet.getTile(tile));
}
public int getMenu(int x,int y)
{
Cell cell=((TiledMapTileLayer)map.getLayers().get(0)).getCell(x,y);
if (cell!=null)
return cell.getTile().getId();
else
return 0;
}
public Vector2 screentoworld(float x, float y) {
int xx=(int) ((x-1531f)/60f);
int yy=(int) ((y-(AssetLoader.height-776f))/60f);
return new Vector2(xx,yy);
}
public Vector2 worldtoscreen(int x, int y) {
float xx=1531.0f+x*60f;
float yy=AssetLoader.height-776.0f+y*60f;
return new Vector2(xx,yy);
}
@Override
public void draw(Batch batch, float parentAlpha) {
batch.end();
camera.update();
MapRenderer.setView(camera);
MapRenderer.render();
batch.begin();
}
}

58
core/src/fr/evolving/UI/Objectives.java Normal file
View File

@ -0,0 +1,58 @@
package fr.evolving.UI;
import java.util.Arrays;
import java.util.Collections;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.BitmapFont.HAlignment;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.scenes.scene2d.Actor;
import fr.evolving.assets.AssetLoader;
public class Objectives extends Actor {
public ShapeRenderer shaperenderer;
public int[] Victory;
BitmapFont font;
BitmapFont font2;
public Objectives() {
shaperenderer = new ShapeRenderer();
font=AssetLoader.Skin_level.getFont("Vademecum-18");
font2=AssetLoader.Skin_level.getFont("OpenDyslexicAlta-28");
}
public void setVictory(int[] Victory) {
this.Victory=Victory;
}
@Override
public final void draw(Batch batch, float parentAlpha) {
shaperenderer.setProjectionMatrix(batch.getProjectionMatrix());
int element=0;
int type=0;
for(int vict: Victory) {
if (vict!=0) {
batch.end();
shaperenderer.begin(ShapeType.Filled);
shaperenderer.setColor(AssetLoader.Typecolors[type]);
shaperenderer.rect(this.getX()+element*40, this.getY(), 40, 68);
shaperenderer.end();
shaperenderer.begin(ShapeType.Line);
shaperenderer.setColor(1, 1, 1, 1);
shaperenderer.rect(this.getX()+element*40, this.getY(), 40, 68);
shaperenderer.end();
batch.begin();
font.draw(batch, AssetLoader.Typenames[type], this.getX()+element*40+2,this.getY()+69);
font2.draw(batch, String.valueOf(vict), this.getX()+element*40+11,this.getY()+35);
element+=1;
}
type+=1;
}
}
}

143
core/src/fr/evolving/UI/TouchMaptiles.java Normal file
View File

@ -0,0 +1,143 @@
package fr.evolving.UI;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.maps.MapLayers;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer.Cell;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.scenes.scene2d.Actor;
import fr.evolving.assets.AssetLoader;
import fr.evolving.automata.Level;
public class TouchMaptiles extends Actor{
private TiledMap map;
private OrthogonalTiledMapRenderer MapRenderer;
private OrthographicCamera camera;
private Level level;
private int sizex;
private int sizey;
private float viewwidth,viewheight,decx,decy;
public TouchMaptiles(Level level,int sizex,int sizey) {
this.level=level;
this.sizex=sizex;
this.sizey=sizey;
map=new TiledMap();
map.getTileSets().addTileSet(AssetLoader.tileSet);
MapLayers layers = map.getLayers();
for (int i = 0; i < 3; i++) {
TiledMapTileLayer layer = new TiledMapTileLayer(level.Grid.sizeX, level.Grid.sizeY, sizex, sizey);
for (int x = 0; x < layer.getWidth();x++) {
for (int y = 0; y < layer.getHeight(); y++) {
Cell cell = new Cell();
if (i==0)
cell.setTile(AssetLoader.tileSet.getTile(53));
layer.setCell(x, y, cell);
}
}
layers.add(layer);
}
MapRenderer = new OrthogonalTiledMapRenderer(map,1/128.0f);
camera = new OrthographicCamera();
initzoom();
}
public Vector2 screentoworld(float x, float y) {
x=(int)((x/AssetLoader.width*camera.viewportWidth)+decx);
y=(int)((y/AssetLoader.height*camera.viewportHeight)+decy);
return new Vector2(x,y);
}
public Vector2 screentoworldsize(float x, float y) {
x=((x/AssetLoader.width*camera.viewportWidth));
y=((y/AssetLoader.height*camera.viewportHeight));
return new Vector2(x,y);
}
public void redraw(int tile) {
for (int x=0;x<level.Grid.sizeX;x++)
for (int y=0;y<level.Grid.sizeY;y++) {
if (level.Grid.getCopper(x,y))
((TiledMapTileLayer)map.getLayers().get(1)).getCell((int)x, (int)y).setTile(AssetLoader.tileSet.getTile(level.Grid.getCoppercalc(x,y)));
else
((TiledMapTileLayer)map.getLayers().get(1)).getCell((int)x, (int)y).setTile(null);
if (level.Grid.GetFiber(x,y))
((TiledMapTileLayer)map.getLayers().get(0)).getCell((int)x, (int)y).setTile(AssetLoader.tileSet.getTile(61));
else
((TiledMapTileLayer)map.getLayers().get(0)).getCell((int)x, (int)y).setTile(AssetLoader.tileSet.getTile(tile));
}
}
public void initzoom() {
if ((level.Grid.sizeX/(float)level.Grid.sizeY)>(AssetLoader.width/AssetLoader.height))
{
viewwidth=level.Grid.sizeX;
viewheight=level.Grid.sizeX/((float)AssetLoader.width/AssetLoader.height);
}
else
{
viewheight=level.Grid.sizeY;
viewwidth=level.Grid.sizeY*((float)AssetLoader.width/AssetLoader.height);
}
Gdx.app.debug(getClass().getSimpleName(),"Caméra pour tilemap:"+viewwidth+"x"+viewheight);
camera.setToOrtho(false, viewwidth,viewheight);
decx=(level.Grid.sizeX-viewwidth)/2.0f;
decy=(level.Grid.sizeY-viewheight)/2.0f;
Gdx.app.debug(getClass().getSimpleName(),"Décalage:"+decx+"x"+decy);
camera.translate(decx,decy);
}
public void fillempty(int tile)
{
TiledMapTileLayer layer = (TiledMapTileLayer)map.getLayers().get(0);
for (int x = 0; x < layer.getWidth(); x++)
for (int y = 0; y < layer.getHeight(); y++)
if (layer.getCell(x, y).getTile().getId()==53 || layer.getCell(x, y).getTile().getId()==60) layer.getCell(x, y).setTile(AssetLoader.tileSet.getTile(tile));
}
public void setZoom(float factor) {
viewwidth*=factor;
viewheight*=factor;
camera.setToOrtho(false, viewwidth, viewheight);
camera.translate(decx,decy);
Gdx.app.debug(getClass().getSimpleName(),"Caméra pour tilemap:"+camera.viewportWidth+"x"+camera.viewportHeight+" zoom:"+factor);
}
public float getDecx() {
return decx;
}
public float getDecy() {
return decy;
}
public void setDec(float x,float y) {
Vector2 dec=screentoworldsize(x,y);
decx=decx-dec.x;
decy=decy-dec.y;
camera.setToOrtho(false, viewwidth, viewheight);
camera.translate(decx,decy);
Gdx.app.debug(getClass().getSimpleName(),"Decalage:"+dec.x+"x"+dec.y+" newxy:"+decx+"x"+decy);
return;
}
@Override
public void draw(Batch batch, float parentAlpha) {
batch.end();
//batch.setProjectionMatrix(camera.combined);
camera.update();
MapRenderer.setView(camera);
//MapRenderer.setView(camera.combined,0,0,maxx,maxx);
MapRenderer.render();
batch.begin();
}
}

84
core/src/fr/evolving/automata/Grid.java
View File

@ -21,16 +21,16 @@ public class Grid implements Serializable{
public void tiling() { public void tiling() {
for (int x=0;x<this.sizeX;x++) for (int x=0;x<this.sizeX;x++)
for (int y=0;y<this.sizeY;y++) for (int y=0;y<this.sizeY;y++)
if (GetCopper(x,y)) if (getCopper(x,y))
{ {
int value=0; int value=0;
if (GetCopper(x,y+1)) if (getCopper(x,y+1))
value++; value++;
if (GetCopper(x-1,y)) if (getCopper(x-1,y))
value+=8; value+=8;
if (GetCopper(x,y-1)) if (getCopper(x,y-1))
value+=4; value+=4;
if (GetCopper(x+1,y)) if (getCopper(x+1,y))
value+=2; value+=2;
GetXY(x,y).Copper_calc=value; GetXY(x,y).Copper_calc=value;
} }
@ -40,47 +40,47 @@ public class Grid implements Serializable{
for (int y=0;y<this.sizeY;y++) for (int y=0;y<this.sizeY;y++)
{ {
int value=0; int value=0;
if (GetCoppercalc(x,y)==15) if (getCoppercalc(x,y)==15)
{ {
if (GetCopper(x-1,y-1)) if (getCopper(x-1,y-1))
value++; value++;
if (GetCopper(x,y-1)) if (getCopper(x,y-1))
value++; value++;
if (GetCopper(x+1,y-1)) if (getCopper(x+1,y-1))
value++; value++;
if (GetCopper(x-1,y)) if (getCopper(x-1,y))
value++; value++;
if (GetCopper(x+1,y)) if (getCopper(x+1,y))
value++; value++;
if (GetCopper(x-1,y+1)) if (getCopper(x-1,y+1))
value++; value++;
if (GetCopper(x,y+1)) if (getCopper(x,y+1))
value++; value++;
if (GetCopper(x+1,y+1)) if (getCopper(x+1,y+1))
value++; value++;
if (value>=5) if (value>=5)
GetXY(x,y).Copper_calc=GetXY(x,y).Copper_calc+20; GetXY(x,y).Copper_calc=GetXY(x,y).Copper_calc+20;
} }
else else
{ {
if (GetCoppercalc(x,y)!=-1) if (getCoppercalc(x,y)!=-1)
{ {
int oldvalue=GetXY(x,y).Copper_calc; int oldvalue=GetXY(x,y).Copper_calc;
if (GetCoppercalc(x-1,y-1)==15 || GetCoppercalc(x-1,y-1)==35) if (getCoppercalc(x-1,y-1)==15 || getCoppercalc(x-1,y-1)==35)
value++; value++;
if (GetCoppercalc(x,y-1)==15 || GetCoppercalc(x,y-1)==35) if (getCoppercalc(x,y-1)==15 || getCoppercalc(x,y-1)==35)
value++; value++;
if (GetCoppercalc(x+1,y-1)==15 || GetCoppercalc(x+1,y-1)==35) if (getCoppercalc(x+1,y-1)==15 || getCoppercalc(x+1,y-1)==35)
value++; value++;
if (GetCoppercalc(x-1,y)==15 || GetCoppercalc(x-1,y)==35) if (getCoppercalc(x-1,y)==15 || getCoppercalc(x-1,y)==35)
value++; value++;
if (GetCoppercalc(x+1,y)==15 || GetCoppercalc(x+1,y)==35) if (getCoppercalc(x+1,y)==15 || getCoppercalc(x+1,y)==35)
value++; value++;
if (GetCoppercalc(x-1,y+1)==15 || GetCoppercalc(x-1,y+1)==35) if (getCoppercalc(x-1,y+1)==15 || getCoppercalc(x-1,y+1)==35)
value++; value++;
if (GetCoppercalc(x,y+1)==15 || GetCoppercalc(x,y+1)==35) if (getCoppercalc(x,y+1)==15 || getCoppercalc(x,y+1)==35)
value++; value++;
if (GetCoppercalc(x+1,y+1)==15 || GetCoppercalc(x+1,y+1)==35) if (getCoppercalc(x+1,y+1)==15 || getCoppercalc(x+1,y+1)==35)
value++; value++;
if (value>=1 && oldvalue!=1 && oldvalue!=2 && oldvalue!=4 && oldvalue!=8 && oldvalue!=10 && oldvalue!=5) if (value>=1 && oldvalue!=1 && oldvalue!=2 && oldvalue!=4 && oldvalue!=8 && oldvalue!=10 && oldvalue!=5)
GetXY(x,y).Copper_calc=oldvalue+20; GetXY(x,y).Copper_calc=oldvalue+20;
@ -90,16 +90,16 @@ public class Grid implements Serializable{
for (int x=0;x<this.sizeX;x++) for (int x=0;x<this.sizeX;x++)
for (int y=0;y<this.sizeY;y++) for (int y=0;y<this.sizeY;y++)
{ {
if (GetCoppercalc(x,y)==35) if (getCoppercalc(x,y)==35)
{ {
int value=0; int value=0;
if (!GetCopper(x+1,y+1)) if (!getCopper(x+1,y+1))
value+=2; value+=2;
if (!GetCopper(x-1,y-1)) if (!getCopper(x-1,y-1))
value+=8; value+=8;
if (!GetCopper(x+1,y-1)) if (!getCopper(x+1,y-1))
value+=4; value+=4;
if (!GetCopper(x-1,y+1)) if (!getCopper(x-1,y+1))
value+=1; value+=1;
GetXY(x,y).Copper_calc=GetXY(x,y).Copper_calc+value; GetXY(x,y).Copper_calc=GetXY(x,y).Copper_calc+value;
} }
@ -111,33 +111,33 @@ public class Grid implements Serializable{
if (oldvalue==27||oldvalue==31||oldvalue==33||oldvalue==34) if (oldvalue==27||oldvalue==31||oldvalue==33||oldvalue==34)
{ {
int value=0; int value=0;
if (GetCopper(x,y+1) && GetCoppercalc(x,y+1)<15) if (getCopper(x,y+1) && getCoppercalc(x,y+1)<15)
value+=1; value+=1;
if (GetCopper(x-1,y) && GetCoppercalc(x-1,y)<15) if (getCopper(x-1,y) && getCoppercalc(x-1,y)<15)
value+=6; value+=6;
if (GetCopper(x,y-1) && GetCoppercalc(x,y-1)<15) if (getCopper(x,y-1) && getCoppercalc(x,y-1)<15)
value+=2; value+=2;
if (GetCopper(x+1,y) && GetCoppercalc(x+1,y)<15) if (getCopper(x+1,y) && getCoppercalc(x+1,y)<15)
value+=2; value+=2;
if (value>0) if (value>0)
GetXY(x,y).Copper_calc=oldvalue+22+value; GetXY(x,y).Copper_calc=oldvalue+22+value;
} }
int value=0; int value=0;
if (oldvalue==34 && (GetCoppercalc(x-1,y)==31 || GetCoppercalc(x-1,y)==55 || GetCoppercalc(x-1,y)==58)) if (oldvalue==34 && (getCoppercalc(x-1,y)==31 || getCoppercalc(x-1,y)==55 || getCoppercalc(x-1,y)==58))
value=62; value=62;
if (oldvalue==34 && (GetCoppercalc(x+1,y)==31 || GetCoppercalc(x+1,y)==55 || GetCoppercalc(x+1,y)==58)) if (oldvalue==34 && (getCoppercalc(x+1,y)==31 || getCoppercalc(x+1,y)==55 || getCoppercalc(x+1,y)==58))
value=58; value=58;
if (oldvalue==31 && (GetCoppercalc(x-1,y)==34 || GetCoppercalc(x-1,y)==58 || GetCoppercalc(x-1,y)==62)) if (oldvalue==31 && (getCoppercalc(x-1,y)==34 || getCoppercalc(x-1,y)==58 || getCoppercalc(x-1,y)==62))
value=59; value=59;
if (oldvalue==31 && (GetCoppercalc(x+1,y)==34 || GetCoppercalc(x+1,y)==58 || GetCoppercalc(x+1,y)==62)) if (oldvalue==31 && (getCoppercalc(x+1,y)==34 || getCoppercalc(x+1,y)==58 || getCoppercalc(x+1,y)==62))
value=55; value=55;
if (oldvalue==33 && (GetCoppercalc(x,y-1)==27 || GetCoppercalc(x,y-1)==50 || GetCoppercalc(x,y-1)==51)) if (oldvalue==33 && (getCoppercalc(x,y-1)==27 || getCoppercalc(x,y-1)==50 || getCoppercalc(x,y-1)==51))
value=57; value=57;
if (oldvalue==33 && (GetCoppercalc(x,y+1)==27 || GetCoppercalc(x,y+1)==50 || GetCoppercalc(x,y+1)==51)) if (oldvalue==33 && (getCoppercalc(x,y+1)==27 || getCoppercalc(x,y+1)==50 || getCoppercalc(x,y+1)==51))
value=56; value=56;
if (oldvalue==27 && (GetCoppercalc(x,y-1)==33 || GetCoppercalc(x,y-1)==56 || GetCoppercalc(x,y-1)==57)) if (oldvalue==27 && (getCoppercalc(x,y-1)==33 || getCoppercalc(x,y-1)==56 || getCoppercalc(x,y-1)==57))
value=51; value=51;
if (oldvalue==27 && (GetCoppercalc(x,y+1)==33 || GetCoppercalc(x,y+1)==56 || GetCoppercalc(x,y+1)==57)) if (oldvalue==27 && (getCoppercalc(x,y+1)==33 || getCoppercalc(x,y+1)==56 || getCoppercalc(x,y+1)==57))
value=50; value=50;
if (value>0) if (value>0)
GetXY(x,y).Copper_calc=value; GetXY(x,y).Copper_calc=value;
@ -154,7 +154,7 @@ public class Grid implements Serializable{
return this.Cells[(int)X][(int)Y]; return this.Cells[(int)X][(int)Y];
} }
public boolean GetCopper(float X,float Y) { public boolean getCopper(float X,float Y) {
Cell cell=GetXY(X,Y); Cell cell=GetXY(X,Y);
if (cell==null) if (cell==null)
return false; return false;
@ -170,7 +170,7 @@ public class Grid implements Serializable{
return cell.Fiber>0; return cell.Fiber>0;
} }
public int GetCoppercalc(float X,float Y) { public int getCoppercalc(float X,float Y) {
Cell cell=GetXY(X,Y); Cell cell=GetXY(X,Y);
if (cell==null) if (cell==null)
return 0; return 0;

257
core/src/fr/evolving/automata/Positiver_I.java Normal file
View File

@ -0,0 +1,257 @@
package fr.evolving.automata;
import java.util.HashMap;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.math.Vector2;
import fr.evolving.automata.Transmuter.CaseType;
import fr.evolving.automata.Transmuter.Class;
public class Positiver_I extends Transmuter {
private static String Name;
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 int Id;
private static boolean Activable;
private int ActivationLevel;
private static HashMap<Vector2,CaseType> Tiles;
public Positiver_I(Level level) {
super(level);
this.Name="positiveur I";
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.Id=0;
this.Activable=true;
this.ActivationLevel=0;
this.Tiles= new HashMap<Vector2,CaseType>();
this.Tiles.put(new Vector2(1,0), CaseType.Fibre);
}
public String getName() {
return this.Name;
}
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=(int)(10*this.UpgradedCycle);
}
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 int getMainTile() {
return this.getSize()*100+Id*this.getSize();
}
public int FindMainTile(int Id) {
int thesize=Id/100;
int deltaid=Id-thesize*100;
return thesize*100+((int)(deltaid/thesize))*thesize;
}
public HashMap<Vector2,CaseType> getTiles() {
return this.Tiles;
}
public boolean isActivable() {
return this.Activable;
}
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 (Tiles.size()+1);
}
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;
}
}

256
core/src/fr/evolving/automata/Positiver_II.java Normal file
View File

@ -0,0 +1,256 @@
package fr.evolving.automata;
import java.util.HashMap;
import com.badlogic.gdx.math.Vector2;
import fr.evolving.automata.Transmuter.CaseType;
import fr.evolving.automata.Transmuter.Class;
public class Positiver_II extends Transmuter {
private static String Name;
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 int Id;
private static boolean Activable;
private int ActivationLevel;
private static HashMap<Vector2,CaseType> Tiles;
public Positiver_II(Level level) {
super(level);
this.Name="positiveur II";
this.theClass=Class.Charge;
this.Price=50;
this.Technology=2;
this.Research=40;
this.Upgrade=new Positiver_III(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.Id=1;
this.Activable=true;
this.ActivationLevel=0;
this.Tiles= new HashMap<Vector2,CaseType>();
this.Tiles.put(new Vector2(1,0), CaseType.Fibre);
}
public String getName() {
return this.Name;
}
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=(int)(10*this.UpgradedCycle);
}
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 int getMainTile() {
return this.getSize()*100+Id*this.getSize();
}
public int FindMainTile(int Id) {
int thesize=Id/100;
int deltaid=Id-thesize*100;
return thesize*100+((int)(deltaid/thesize))*thesize;
}
public HashMap<Vector2,CaseType> getTiles() {
return this.Tiles;
}
public boolean isActivable() {
return this.Activable;
}
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 (Tiles.size()+1);
}
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;
}
}

256
core/src/fr/evolving/automata/Positiver_III.java Normal file
View File

@ -0,0 +1,256 @@
package fr.evolving.automata;
import java.util.HashMap;
import com.badlogic.gdx.math.Vector2;
import fr.evolving.automata.Transmuter.CaseType;
import fr.evolving.automata.Transmuter.Class;
public class Positiver_III extends Transmuter {
private static String Name;
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 int Id;
private static boolean Activable;
private int ActivationLevel;
private static HashMap<Vector2,CaseType> Tiles;
public Positiver_III(Level level) {
super(level);
this.Name="positiveur III";
this.theClass=Class.Charge;
this.Price=50;
this.Technology=2;
this.Research=120;
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.Id=1;
this.Activable=true;
this.ActivationLevel=0;
this.Tiles= new HashMap<Vector2,CaseType>();
this.Tiles.put(new Vector2(1,0), CaseType.Fibre);
}
public String getName() {
return this.Name;
}
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=(int)(10*this.UpgradedCycle);
}
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 int getMainTile() {
return this.getSize()*100+Id*this.getSize();
}
public int FindMainTile(int Id) {
int thesize=Id/100;
int deltaid=Id-thesize*100;
return thesize*100+((int)(deltaid/thesize))*thesize;
}
public HashMap<Vector2,CaseType> getTiles() {
return this.Tiles;
}
public boolean isActivable() {
return this.Activable;
}
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 (Tiles.size()+1);
}
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;
}
}

181
core/src/fr/evolving/automata/Transmuter.java
View File

@ -1,5 +1,184 @@
package fr.evolving.automata; package fr.evolving.automata;
abstract public class Transmuter { import java.util.HashMap;
import java.util.Iterator;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.math.Vector2;
public abstract class Transmuter {
public enum CaseType{Rien,Cuivre,Fibre,Tout,Nimporte};
public enum Class{Structure,Charge,Direction,Filtrage,Synthèse,Détection,Divers,Scénario};
protected Level level;
public Transmuter(Level level) {
this.level=level;
}
public String getName() {
return "";
}
public String getaClass() {
return "";
}
public void ProcessCycle() {
}
public void Run() {
}
public void Unlock() {
}
public void Upgrade() {
}
public void Activate() {
}
public void UpgradeTemp() {
}
public void UpgradeNrj() {
}
public void UpgradeRayon() {
}
public void UpgradeCycle() {
}
public int getMainTile() {
return 0;
}
public int FindMainTile(int Id) {
return 0;
}
public HashMap<Vector2,CaseType> getTiles() {
return null;
}
public int getActivationLevel() {
return 0;
}
public boolean getActivation() {
return false;
}
public int getPrice() {
return 0;
}
public int getSize() {
return 0;
}
public int getTechnology() {
return 0;
}
public int getResearch() {
return 0;
}
public boolean isUpgradable() {
return false;
}
public boolean isUnlockable() {
return false;
}
public boolean isShowed() {
return false;
}
public void SetShowed(boolean value) {
}
public boolean isActivable() {
return false;
}
public boolean isUpgradableTemp() {
return false;
}
public boolean isUpgradableCycle() {
return false;
}
public boolean isUpgradableRayon() {
return false;
}
public boolean isUpgradableNrj() {
return false;
}
public Transmuter getUpgrade() {
return null;
}
public Transmuter getUnlock() {
return null;
}
public int getUpgradeCycle() {
return 0;
}
public int getUpgradeTemp() {
return 0;
}
public int getUpgradeRayon() {
return 0;
}
public int getUpgradeNrj() {
return 0;
}
public float getUsedTemp() {
return 0;
}
public float getUsedRayon() {
return 0;
}
public float getUsedNrj() {
return 0;
}
public float getTurnTemp() {
return 0;
}
public float getTurnRayon() {
return 0;
}
public float getTurnNrj() {
return 0;
}
public String getInformations() {
Iterator<Vector2> keySetIterator = this.getTiles().keySet().iterator();
String result;
result="**********************************\n"+"Name:"+this.getName()+"\nClass:"+this.getaClass()+" Id:"+this.getMainTile()+"\nPrice:"+this.getPrice()+" Tech:"+this.getTechnology()+"\nResearch:"+this.getResearch()+" Size:"+this.getSize()+"\nActivable:"+this.isActivable()+" Activation:"+this.getActivationLevel()+" Visible:"+this.isShowed()+"\nUpgradable:"+((this.isUpgradable())?this.getUpgrade().getName():this.isUpgradable())+" Unlockable:"+((this.isUnlockable())?this.getUnlock().getName():this.isUnlockable())+"\nUpgrade Cycle:"+this.getUpgradeCycle()+" upgrade:"+this.isUpgradableCycle()+"\nUpgrade Temperature:"+this.getUpgradeTemp()+" upgrade:"+this.isUpgradableTemp()+"\nUpgrade Nrj:"+this.getUpgradeNrj()+" upgrade:"+this.isUpgradableNrj()+"\nUpgrade Rayon:"+this.getUpgradeRayon()+" upgrade:"+this.isUpgradableRayon()+"\nTemperature /turn:"+this.getTurnTemp()+" Rayon /turn:"+this.getTurnRayon()+" Nrj /turn:"+this.getTurnNrj()+"\nTemperature /use:"+this.getUsedTemp()+" Rayon /use:"+this.getUsedRayon()+" Nrj /use:"+this.getUsedNrj()+"\n";
while(keySetIterator.hasNext()){
Vector2 key = keySetIterator.next();
result+="coords:" + key + " type: " + this.getTiles().get(key);
}
result+="\n**********************************";
return result;
}
} }

45
core/src/fr/evolving/screens/GameScreen.java
View File

@ -1,5 +1,6 @@
package fr.evolving.screens; package fr.evolving.screens;
import java.util.Iterator;
import java.util.Timer; import java.util.Timer;
import java.util.TimerTask; import java.util.TimerTask;
@ -42,6 +43,8 @@ import fr.evolving.UI.Objectives;
import fr.evolving.UI.TouchMaptiles; import fr.evolving.UI.TouchMaptiles;
import fr.evolving.assets.AssetLoader; import fr.evolving.assets.AssetLoader;
import fr.evolving.automata.Level; import fr.evolving.automata.Level;
import fr.evolving.automata.Positiver_I;
import fr.evolving.automata.Positiver_II;
import fr.evolving.inputs.InputHandler; import fr.evolving.inputs.InputHandler;
public class GameScreen implements Screen { public class GameScreen implements Screen {
@ -123,6 +126,46 @@ public class GameScreen implements Screen {
Gdx.app.debug(event.getListenerActor().toString(),"Barre:Niveaux"); Gdx.app.debug(event.getListenerActor().toString(),"Barre:Niveaux");
((Game)Gdx.app.getApplicationListener()).setScreen(new LevelScreen(level.aWorld)); ((Game)Gdx.app.getApplicationListener()).setScreen(new LevelScreen(level.aWorld));
} }
});
Barre[0].addListener(new ClickListener(){
@Override
public void clicked(InputEvent event, float x, float y) {
Gdx.app.debug(event.getListenerActor().toString(),"tests");
level.Grid.Cells[0][0].Transmuter=new Positiver_I(level);
level.Grid.Cells[0][1].Transmuter=new Positiver_II(level);
level.Grid.Cells[0][2].Transmuter=new Positiver_I(level);
Gdx.app.debug("0 upgrade",String.valueOf(level.Grid.Cells[0][0].Transmuter.getUpgradeCycle()));
Gdx.app.debug("0 activation",String.valueOf(level.Grid.Cells[0][0].Transmuter.getActivationLevel()));
Gdx.app.debug("2 activation",String.valueOf(level.Grid.Cells[0][2].Transmuter.getActivationLevel()));
level.Grid.Cells[0][0].Transmuter.Activate();
level.Grid.Cells[0][0].Transmuter.UpgradeCycle();
Gdx.app.debug("0 activation",String.valueOf(level.Grid.Cells[0][0].Transmuter.getActivationLevel()));
Gdx.app.debug("2 activation",String.valueOf(level.Grid.Cells[0][2].Transmuter.getActivationLevel()));
level.Grid.Cells[0][0].Transmuter.Activate();
Gdx.app.debug("0 activation",String.valueOf(level.Grid.Cells[0][0].Transmuter.getActivationLevel()));
Gdx.app.debug("2 upgrade",String.valueOf(level.Grid.Cells[0][2].Transmuter.getUpgradeCycle()));
Gdx.app.debug("0 upgrade",String.valueOf(level.Grid.Cells[0][0].Transmuter.getUpgradeCycle()));
level.Grid.Cells[0][0].Transmuter.UpgradeCycle();
Gdx.app.debug("2 upgrade",String.valueOf(level.Grid.Cells[0][2].Transmuter.getUpgradeCycle()));
Gdx.app.debug("0 upgrade",String.valueOf(level.Grid.Cells[0][0].Transmuter.getUpgradeCycle()));
level.Grid.Cells[0][0].Transmuter.UpgradeCycle();
Gdx.app.debug("2 upgrade",String.valueOf(level.Grid.Cells[0][2].Transmuter.getUpgradeCycle()));
Gdx.app.debug("0 upgrade",String.valueOf(level.Grid.Cells[0][0].Transmuter.getUpgradeCycle()));
level.Grid.Cells[0][0].Transmuter.UpgradeCycle();
Gdx.app.debug("2 upgrade",String.valueOf(level.Grid.Cells[0][2].Transmuter.getUpgradeCycle()));
Gdx.app.debug("0 upgrade",String.valueOf(level.Grid.Cells[0][0].Transmuter.getUpgradeCycle()));
Gdx.app.debug("1 upgrade",String.valueOf(level.Grid.Cells[0][1].Transmuter.getUpgradeCycle()));
Gdx.app.debug("0 nom",String.valueOf(level.Grid.Cells[0][0].Transmuter.getName()));
Gdx.app.debug("1 nom",String.valueOf(level.Grid.Cells[0][1].Transmuter.getName()));
Gdx.app.debug("1 taille",String.valueOf(level.Grid.Cells[0][1].Transmuter.getTiles().size()));
level.Grid.Cells[0][0].Transmuter.UpgradeTemp();
level.Grid.Cells[0][1].Transmuter.UpgradeTemp();
level.Grid.Cells[0][2].Transmuter.UpgradeTemp();
level.Grid.Cells[0][2].Transmuter.UpgradeNrj();
Gdx.app.debug("0 informations",String.valueOf(level.Grid.Cells[0][0].Transmuter.getInformations()));
Gdx.app.debug("1 informations",String.valueOf(level.Grid.Cells[0][1].Transmuter.getInformations()));
Gdx.app.debug("2 informations",String.valueOf(level.Grid.Cells[0][2].Transmuter.getInformations()));
}
}); });
if (Gdx.graphics.isFullscreen()) if (Gdx.graphics.isFullscreen())
Barre[14].getStyle().up =new TextureRegionDrawable(AssetLoader.Atlas_level.findRegion("windows")); Barre[14].getStyle().up =new TextureRegionDrawable(AssetLoader.Atlas_level.findRegion("windows"));
@ -313,7 +356,7 @@ public class GameScreen implements Screen {
if (level.Grid.GetXY(coords.x,coords.y)!=null) if (level.Grid.GetXY(coords.x,coords.y)!=null)
{ {
Gdx.app.debug(event.getListenerActor().toString(),"Screen coordinates translated to world coordinates: "+ "X: " + coords.x + " Y: " + coords.y); Gdx.app.debug(event.getListenerActor().toString(),"Screen coordinates translated to world coordinates: "+ "X: " + coords.x + " Y: " + coords.y);
if (level.Grid.GetCopper(coords.x,coords.y)==false) if (level.Grid.getCopper(coords.x,coords.y)==false)
level.Grid.GetXY(coords.x,coords.y).Copper=true; level.Grid.GetXY(coords.x,coords.y).Copper=true;
else else
level.Grid.GetXY(coords.x,coords.y).Copper=false; level.Grid.GetXY(coords.x,coords.y).Copper=false;