Rativel/jeu-de-combat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source
This commit is contained in:
Antoine 2021-06-10 14:25:01 +02:00
commit a7cc1f58ca
26 changed files with 920 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
game.set Normal file
View File

@ -0,0 +1 @@
{"game":[{"character2":"ken","character1":"ryu","fullscreen":"true","stage":"default","width":"1920","rounds":"5","height":"1080"}]}

2
pom.xml
View File

@ -34,7 +34,7 @@
<properties> <properties>
<lwjgl.version>3.2.3</lwjgl.version> <lwjgl.version>3.2.3</lwjgl.version>
<lwjgl.natives>natives-windows</lwjgl.natives> <lwjgl.natives>natives-linux</lwjgl.natives>
<javafx.version>11</javafx.version> <javafx.version>11</javafx.version>
</properties> </properties>

277
src/configuration/Config.java
View File

@ -1,165 +1,112 @@
package configuration; package configuration;
import java.util.Random; import java.io.*;
import org.json.simple.*;
public class Config { import org.json.simple.parser.*;
// tester a la main (okay normalement mais ajouter des test) public class Config {
public static void main(String[] args) {
int[] tempfortest = { 0, 2, 1, 1 }; // {arene/nb_joueur/perso1/perso2} 0=alatoire public int width, height, rounds;
config(tempfortest); public boolean fullscreen;
} public String stage;
public String p1, p2;
// les variable a configurer
// sel1 pour savoir si on a deja selectionner le joueur 1 public Config() throws FileNotFoundException {
parse();
public static String arene, perso1, perso2; }
public static int nb_joueur;
private static boolean sel1 = false; public void parse() throws FileNotFoundException {
/* // initialize the parser
* fonction config qui prend en entre un tableau d'entier chaque case JSONParser jsonP = new JSONParser();
* correspondant a une variable, et ne retourne rien mais modifie la valeur des try {
* variables par des fonctions annexes // read the json document
*/ JSONObject jsonO = (JSONObject) jsonP.parse(new FileReader("game.set"));
private static void config(int[] tab) { // to print all values
int i = 0; // System.out.println(jsonO.values());
while (i < tab.length) {
// isolate the "test" part and print it
switch (i) { // String test = (String) jsonO.get("test");
case 0: // System.out.println("ceci est un test :" + test);
SelArene(tab[i]);
i++;
break; JSONArray game = (JSONArray) jsonO.get("game");
JSONObject settings = (JSONObject) game.get(0);
case 1:
NbJoueur(tab[i]); // print a case of this element
i++; stage = (String) settings.get("stage");
break;
// nb players selection
case 2: /* JSONArray nb_players = (JSONArray) jsonO.get("nb_players");
SelPerso(tab[i]); System.out.println("nb_player : " + nb_players.get(1)); */
i++;
break; // character selection
p1 = (String) settings.get("character1");
case 3: p2 = (String) settings.get("character2");
SelPerso(tab[i]);
i++; height = Integer.parseInt((String) settings.get("height")); // String to int
break; width = Integer.parseInt((String) settings.get("width"));
/*
* case 4: ? // fullscreen
*/ String fs = (String) settings.get("fullscreen");
if (fs.equals("true")) {
default: fullscreen = true;
System.out.println("ERROR OUT OF BOUNDS CONFIG ARRAY"); } else fullscreen = false;
i = tab.length;
break; // rounds
} String temprounds = (String) settings.get("rounds");
} switch (temprounds) {
System.out.println(arene + " " + nb_joueur + " " + perso1 + " " + perso2 + " " + sel1); case "1": rounds = 1;
} case "3": rounds = 3;
case "5": rounds = 5;
/* default: rounds = 1;
* fonction SelArene prend un entier en parametre et permet de choisir l'arene }
* du jeu
*/ // button selection
/* JSONArray allButton = (JSONArray) jsonO.get("button");
private static void SelArene(int s) { System.out.println(allButton);
switch (s) {
case 0: String up = (String) allButton.get(0);
SelArene(random(1, 2)); System.out.println("button for up is : " + up); */
break;
case 1: } catch (FileNotFoundException e) {
arene = "arene1.png"; e.printStackTrace();
break; } catch (IOException e) {
e.printStackTrace();
case 2: } catch (ParseException e) {
arene = "arene2.png"; e.printStackTrace();
break;
}
default: }
System.out.println("ERROR ARENE INEXISTANTE");
} @SuppressWarnings("unchecked")
} public void write(int width, int height, int rounds, boolean fullscreen, String character1, String character2, String stage) throws Exception {
/* JSONObject metafile = new JSONObject();
* fonction NbJoueur prend un entier en parametre et permet de determiner si un JSONArray array = new JSONArray();
* bot sera necessaire
*/ JSONObject set = new JSONObject();
set.put("width", Integer.toString(width));
private static void NbJoueur(int s) { set.put("height", Integer.toString(height));
switch (s) { set.put("rounds", Integer.toString(rounds));
case 1: set.put("fullscreen", Boolean.toString(fullscreen));
nb_joueur = 1; set.put("character1", character1);
break; set.put("character2", character2);
set.put("stage", stage);
case 2:
nb_joueur = 2; array.add(set);
break;
default: metafile.put("game", array);
System.out.println("ERROR NUMBER OF PLAYER");
} try (FileWriter file = new FileWriter("game.set", false)) {
file.write(metafile.toJSONString());
} file.close();
/* } catch (FileNotFoundException e) {
* fonction SelArene prend un entier en parametre et permet de choisir le e.printStackTrace();
* personnage en fonction du joueur } catch (IOException e) {
*/ e.printStackTrace();
}
private static void SelPerso(int s) { }
if (sel1 == false) { }
switch (s) {
case 0:
SelPerso(random(1, 2));
break;
case 1:
perso1 = "perso1.png";
sel1 = true;
break;
case 2:
perso1 = "perso2.png";
sel1 = true;
break;
default:
System.out.println("ERROR PERSO INEXISTANT");
}
} else if (sel1 == true) {
switch (s) {
case 0:
SelPerso(random(1, 2));
break;
case 1:
perso2 = "perso1.png";
sel1 = false;
if (perso1 == perso2) {
perso2 = "perso1_swapcolor.png";
}
break;
case 2:
perso2 = "perso2.png";
sel1 = false;
if (perso1 == perso2) {
perso2 = "perso2_swapcolor.png";
}
break;
default:
System.out.println("ERROR PERSO INEXISTANT");
}
} else {
System.out.println("ERROR SELECTION PLAYER");
}
}
// fonction nombre aleatoire entre deux borne
private static int random(int min, int max) {
Random random = new Random();
int value = random.nextInt(max - 1 + min) + min;
return value;
}
}

75
src/configuration/JsonToJava.java
View File

@ -1,75 +0,0 @@
package configuration;
import java.io.*;
import org.json.simple.*;
import org.json.simple.parser.*;
public class JsonToJava {
public static void main(String args[]) {
JsonRecover();
}
private static void JsonRecover() {
// initialize the parser
JSONParser jsonP = new JSONParser();
try {
// read the json document
JSONObject jsonO = (JSONObject) jsonP.parse(new FileReader("src/configuration/config.json"));
// to print all values
// System.out.println(jsonO.values());
// isolate the "test" part and print it
// String test = (String) jsonO.get("test");
// System.out.println("ceci est un test :" + test);
// arena selection
// select an element on the list
JSONArray arena = (JSONArray) jsonO.get("arena");
// print a case of this element
System.out.println("arena : " + arena.get(1));
// nb players selection
JSONArray nb_players = (JSONArray) jsonO.get("nb_players");
System.out.println("nb_player : " + nb_players.get(1));
// character selection
JSONArray character1 = (JSONArray) jsonO.get("character1");
System.out.println("players 1 : " + character1.get(1));
JSONArray character2 = (JSONArray) jsonO.get("character2");
System.out.println("players 2 : " + character2.get(1));
// resolution
JSONArray resolution = (JSONArray) jsonO.get("resolution");
// resolution string " width x heigth"
JSONObject reso = (JSONObject) resolution.get(1);
String heightStr = (String) reso.get("height");
int height = Integer.parseInt(heightStr); // String to int
String widthStr = (String) reso.get("width");
int width = Integer.parseInt(widthStr);
System.out.println("heigth : " + height + " width : " + width);
// button selection
JSONArray allButton = (JSONArray) jsonO.get("button");
System.out.println(allButton);
String up = (String) allButton.get(0);
System.out.println("button for up is : " + up);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
}
}
}

55
src/configuration/config.json
View File

@ -1,55 +0,0 @@
{
"arena": [
"random",
"arena1.png",
"arena2.png"
],
"nb_players": [
"1",
"2"
],
"character1": [
"random",
"character1.png",
"character2.png"
],
"character2": [
"random",
"character1.png",
"character1_swapcolor.png",
"character2.png",
"character2_swapcolor.png"
],
"resolution": [
{
"width": "800",
"height": "600"
},
{
"width": "1280",
"height": "1024"
},
{
"width": "1680",
"height": "1050"
},
{
"width": "1920",
"height": "1080"
},
{
"persoWidth": "800",
"persoHeight": "600"
}
],
"button": [
"UP",
"DOWN",
"RIGTH",
"LEFT",
"A",
"B",
"X",
"Y"
]
}

6
src/engine/TestEngine.java
View File

@ -19,7 +19,7 @@ public class TestEngine {
/* /*
OpenAl TEST OpenAl TEST
*/ */
SoundManager soundManager = new SoundManager(); /*SoundManager soundManager = new SoundManager();
soundManager.init(); soundManager.init();
SoundListener soundListener = new SoundListener(); SoundListener soundListener = new SoundListener();
@ -31,7 +31,7 @@ public class TestEngine {
soundSource.setBuffer(jumpSoundBuffer.getBufferId()); soundSource.setBuffer(jumpSoundBuffer.getBufferId());
soundManager.addSoundSource("jump", soundSource); soundManager.addSoundSource("jump", soundSource);
// soundManager.playSoundSource("jump"); // soundManager.playSoundSource("jump");*/
/* /*
Engine Init Engine Init
@ -163,7 +163,7 @@ public class TestEngine {
if (engine.shouldClose()) engine.setRunning(false); if (engine.shouldClose()) engine.setRunning(false);
} }
soundManager.cleanup(); //soundManager.cleanup();
} }

352
src/gameplay/Characters/Blue/BlueBaseFrames.java Normal file
View File

@ -0,0 +1,352 @@
package gameplay.Characters.Blue;
import engine.Engine;
import engine.math.Vector3f;
import engine.object.Hitbox;
import engine.object.ObjectGl;
import gameplay.frames.Frame;
import gameplay.hitboxes.*;
import java.util.ArrayList;
public class BlueBaseFrames {
private static Frame generateStandFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,0.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(0,0,112,120);
return blueStandframe1;
}
private static Frame generateStandFrame2(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,75,300);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,0.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(112,0,112,120);
return blueStandframe1;
}
protected static Frame[] blueStandFrames() {
Frame[] sf = {generateStandFrame1(),generateStandFrame2()};
return sf;
}
private static Frame generateCrouchFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,0.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(112,120,112,120);
return blueStandframe1;
}
protected static Frame[] blueCrouchFrames() {
Frame[] cF = {generateCrouchFrame1()};
return cF;
}
private static Frame generateNeutralJumpFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(-10.0,0.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,false,false,false,false,false);
blueStandframe1.setSpriteWrap(830,0,112,120);
return blueStandframe1;
}
private static Frame generateNeutralJumpFrame2(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(10.0,0.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,false,false,false,false,false);
blueStandframe1.setSpriteWrap(830,0,112,120);
return blueStandframe1;
}
protected static Frame[] blueNeutralJump() {
Frame[] jF = new Frame[40];
for(int i = 0; i < jF.length/2; i++) {
jF[i] = generateNeutralJumpFrame1();
}
for(int i = jF.length/2; i < jF.length; i++) {
jF[i] = generateNeutralJumpFrame2();
}
return jF;
}
private static Frame GenerateForwardJumpFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(-10.0,10.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,false,false,false,false,false);
blueStandframe1.setSpriteWrap(750,0,112,120);
return blueStandframe1;
}
private static Frame GenerateForwardJumpFrame2(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(10.0,10.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,false,false,false,false,false);
blueStandframe1.setSpriteWrap(750,0,112,120);
return blueStandframe1;
}
protected static Frame[] blueForwardJump() {
Frame[] jF = new Frame[40];
for(int i = 0; i < jF.length/2; i++) {
jF[i] = GenerateForwardJumpFrame1();
}
for(int i = jF.length/2; i < jF.length; i++) {
jF[i] = GenerateForwardJumpFrame2();
}
return jF;
}
private static Frame BackJumpFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(-10.0,-10.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,false,false,false,false,false);
blueStandframe1.setSpriteWrap(750,0,112,120);
return blueStandframe1;
}
protected static Frame[] blueBackJump() {
Frame[] jF = new Frame[40];
for(int i = 0; i < jF.length/2; i++) {
jF[i] = BackJumpFrame1();
}
for(int i = jF.length/2; i < jF.length; i++) {
jF[i] = BackJumpFrame2();
}
return jF;
}
private static Frame BackJumpFrame2(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(10.0,-10.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,false,false,false,false,false);
blueStandframe1.setSpriteWrap(750,0,112,120);
return blueStandframe1;
}
private static Frame walkForwardFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(220,0,112,120);
return blueStandframe1;
}
private static Frame walkForwardFrame2(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(330,0,112,120);
return blueStandframe1;
}
private static Frame walkForwardFrame3(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(420,0,112,120);
return blueStandframe1;
}
private static Frame walkForwardFrame4(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(500,0,112,120);
return blueStandframe1;
}
protected static Frame[] blueFWalk() {
Frame[] f = new Frame[4];
f[0] = walkForwardFrame1();
f[1] = walkForwardFrame2();
f[2] = walkForwardFrame3();
f[3] = walkForwardFrame4();
return f;
}
private static Frame walkBackFrame4(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,-8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(220,0,112,120);
return blueStandframe1;
}
private static Frame walkBackFrame3(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,-8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(330,0,112,120);
return blueStandframe1;
}
private static Frame walkBackFrame2(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,-8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(420,0,112,120);
return blueStandframe1;
}
private static Frame walkBackFrame1(){
Passive_HitBox bStandPHB1 = new Passive_HitBox(70,70,150,500);
Passive_throw_HitBox bStandPTHB1 = new Passive_throw_HitBox(70,400,150,100);
Push_HitBox bStandPB1 = new Push_HitBox(70,70,150,500);
ArrayList<Passive_HitBox> phb = new ArrayList<Passive_HitBox>();
ArrayList<Passive_throw_HitBox> pthb = new ArrayList<Passive_throw_HitBox>();
phb.add(bStandPHB1);
pthb.add(bStandPTHB1);
Frame blueStandframe1 = new Frame(0.0,-8.0,phb,new ArrayList<Active_HitBox>(),pthb,new ArrayList<Active_throw_Hitbox>(),
bStandPB1,true,true,true,true,true);
blueStandframe1.setSpriteWrap(500,0,112,120);
return blueStandframe1;
}
protected static Frame[] blueBWalk() {
Frame[] f = new Frame[4];
f[0] = walkBackFrame1();
f[1] = walkBackFrame2();
f[2] = walkBackFrame3();
f[3] = walkBackFrame4();
return f;
}
public static void main(String[] args) {
Engine engine = new Engine(640, 480, new Vector3f(4.0f, 3.0f));
engine.init();
String path = "textures/Sprite.png";
String pathToBG = "textures/background_beach.png";
Frame f = generateStandFrame1();
ObjectGl blue = new ObjectGl(0f, 60f, 80f, 5f, path, null);
blue.setTextureWrap(f.getSprite()[0], f.getSprite()[1], f.getSprite()[2], f.getSprite()[3], ObjectGl.STICK_TOP);
blue.translate(new Vector3f(-750,200,0));
int posX = -750;
int posY = 200;
engine.add_objectGl(blue);
int counter = 0;
long ts1, ts2;
float posZ = 11;
while(counter < 1000) {
ts1 = System.currentTimeMillis();
posZ = 11;
engine.update();
engine.render();
counter++;
for(Passive_HitBox h: f.getPassHitBox()){
Hitbox hh = new Hitbox(posZ,h.getSize_x(),h.getSize_y(),5f,new Vector3f(1,0,0));
engine.add_objectGl(hh);
hh.translate(new Vector3f(-750+h.getPosY(),200+h.getPosY()));
}
blue.translate(new Vector3f(0,0,0));
ts2 = System.currentTimeMillis();
while(ts2-ts1 < 1000/20) {
ts2 = System.currentTimeMillis();
}
}
}
}

58
src/gameplay/Characters/Blue/CharacterBlue.java Normal file
View File

@ -0,0 +1,58 @@
package gameplay.Characters.Blue;
import gameplay.actions.*;
import gameplay.entities.Character;
import gameplay.frames.Frame;
import gameplay.Characters.Blue.BlueBaseFrames;
import gameplay.input.ButtonIG;
import java.util.ArrayList;
import static gameplay.input.ButtonIG.*;
public class CharacterBlue {
public static Character generateCharBlue(){
Frame[] standF = BlueBaseFrames.blueStandFrames();
Frame[] crouchF = BlueBaseFrames.blueCrouchFrames();
Frame[] nJumpF = BlueBaseFrames.blueNeutralJump();
Frame[] fJumpF = BlueBaseFrames.blueForwardJump();
Frame[] bJumpF = BlueBaseFrames.blueBackJump();
Frame[] fWalkF = BlueBaseFrames.blueFWalk();
Frame[] bWalkF = BlueBaseFrames.blueBWalk();
ButtonIG[][] fjcmd = {{UP,FORWARD}};
ButtonIG[][] bjcmd = {{UP,BACK}};
ButtonIG[][] njcmd = {{UP}};
Jump fJ = new Jump(fjcmd,fJumpF);
Jump nJ = new Jump(njcmd,nJumpF);
Jump bJ = new Jump(bjcmd,bJumpF);
/*
* Temporary values to change later
*/
Frame[] fDashF = new Frame[0];
Frame[] bDashF = new Frame[0];
ThrowPart[] tp = new ThrowPart[0];
ButtonIG[][] throwCMD = {{BACK,FORWARD,UP,DOWN},{BACK,FORWARD,UP,DOWN},{BACK,FORWARD,UP,DOWN}};
ButtonIG[][] fdashCMD = {{BACK,FORWARD,UP,DOWN},{BACK,FORWARD,UP,DOWN},{BACK,FORWARD,UP,DOWN}};
ButtonIG[][] bdashCMD = {{BACK,FORWARD,UP,DOWN},{BACK,FORWARD,UP,DOWN},{BACK,FORWARD,UP,DOWN}};
Throw th = new Throw(false,throwCMD,tp);
Dash fDash = new Dash(fdashCMD,fDashF);
Dash bDash =new Dash(bdashCMD,bDashF);
Frame[] fallingFs = new Frame[0];
Frame f = new Frame();
Attack[] atks = new Attack[0];
Character c = new Character(0,0,standF[0],1000,atks,fJ,nJ,bJ,fDash,bDash,th,standF,crouchF,fWalkF,bWalkF,f,f,fallingFs,f,f,f,f);
return c;
}
}

41
src/gameplay/actions/Attack.java
View File

@ -10,24 +10,31 @@ public class Attack implements Action {
/** /**
* Defines if the attack is a special one (E.G. a fireball) or a normal one (a punch) * Defines if the attack is a special one (E.G. a fireball) or a normal one (a punch)
*/ */
private static boolean isSpecial; private boolean isSpecial;
private Status requiredStatus;
private static Status requiredStatus;
/** /**
* The suite of Inputs to have the move come out. * The suite of Inputs to have the move come out.
* For example, a classic fireball would be something like * For example, a classic fireball would be something like
* {{DOWN},{DOWN,RIGHT},{RIGHT},{A}} * {{DOWN},{DOWN,RIGHT},{RIGHT},{A}}
*/ */
private static ButtonIG[][] command; private ButtonIG[][] command;
/** /**
* The different sections of the attack * The different sections of the attack
*/ */
private attackPart[] parts; private attackPart[] parts;
public Attack(boolean isSpecial, Status requiredStatus, ButtonIG[][] command, attackPart[] parts) {
this.isSpecial = isSpecial;
this.requiredStatus = requiredStatus;
this.command = command;
this.parts = parts;
}
@Override @Override
public ArrayList<Frame> getFrame() { public ArrayList<Frame> getFrame() {
ArrayList<Frame> res = new ArrayList<Frame>(); ArrayList<Frame> res = new ArrayList<Frame>();
@ -47,21 +54,21 @@ public class Attack implements Action {
return res; return res;
} }
public static boolean isIsSpecial() { public boolean isIsSpecial() {
return isSpecial; return this.isSpecial;
} }
public static void setIsSpecial(boolean isSpecial) { public void setIsSpecial(boolean isSpecial) {
Attack.isSpecial = isSpecial; this.isSpecial = isSpecial;
} }
@Override @Override
public ButtonIG[][] getCommand() { public ButtonIG[][] getCommand() {
return command; return this.command;
} }
public static void setCommand(ButtonIG[][] command) { public void setCommand(ButtonIG[][] command) {
Attack.command = command; this.command = command;
} }
public attackPart[] getParts() { public attackPart[] getParts() {
@ -72,13 +79,15 @@ public class Attack implements Action {
this.parts = parts; this.parts = parts;
} }
public static Status getRequiredStatus() { public Status getRequiredStatus() {
return requiredStatus; return this.requiredStatus;
} }
public static void setRequiredStatus(Status requiredStatus) { public void setRequiredStatus(Status requiredStatus) {
Attack.requiredStatus = requiredStatus; this.requiredStatus = requiredStatus;
} }
public boolean isSpecial() {return this.isSpecial();} public boolean isSpecial() {return this.isSpecial();}
} }

10
src/gameplay/actions/Dash.java
View File

@ -11,11 +11,11 @@ public class Dash implements Action {
* For example, a Front Dash would be something like * For example, a Front Dash would be something like
* {{FORWARD},{FORWARD}} * {{FORWARD},{FORWARD}}
*/ */
private static ButtonIG[][] command; private ButtonIG[][] command;
private Frame[] frames; private Frame[] frames;
@Override @Override
public ArrayList<Frame> getFrame() { public ArrayList<Frame> getFrame() {
ArrayList<Frame> res = new ArrayList<Frame>(); ArrayList<Frame> res = new ArrayList<Frame>();
@ -27,7 +27,11 @@ public class Dash implements Action {
@Override @Override
public ButtonIG[][] getCommand() { public ButtonIG[][] getCommand() {
return command; return this.command;
} }
public Dash(ButtonIG[][] command, Frame[] frames) {
this.command = command;
this.frames = frames;
}
} }

8
src/gameplay/actions/Jump.java
View File

@ -12,7 +12,7 @@ public class Jump implements Action {
* For example, a Front Jump would be something like * For example, a Front Jump would be something like
* {{UP,RIGHT}} * {{UP,RIGHT}}
*/ */
private static ButtonIG[][] command; private ButtonIG[][] command;
private Frame[] frames; private Frame[] frames;
@ -27,7 +27,11 @@ public class Jump implements Action {
@Override @Override
public ButtonIG[][] getCommand() { public ButtonIG[][] getCommand() {
return command; return this.command;
} }
public Jump(ButtonIG[][] command, Frame[] frames) {
this.command = command;
this.frames = frames;
}
} }

19
src/gameplay/actions/Throw.java
View File

@ -10,14 +10,14 @@ public class Throw implements Action {
/** /**
* Defines if the throw is a special one (E.G. a Moonsault Press ) or a normal one * Defines if the throw is a special one (E.G. a Moonsault Press ) or a normal one
*/ */
private static boolean isSpecial; private boolean isSpecial;
/** /**
* The suite of Inputs to have the move come out. * The suite of Inputs to have the move come out.
* For example, a Moonsault Press would be something like * For example, a Moonsault Press would be something like
* {{LEFT},{DOWN,LEFT},{DOWN},{DOWN,RIGHT},{RIGHT},{RIGHT,UP},{UP},{A}} * {{LEFT},{DOWN,LEFT},{DOWN},{DOWN,RIGHT},{RIGHT},{RIGHT,UP},{UP},{A}}
*/ */
private static ButtonIG[][] command; private ButtonIG[][] command;
/** /**
* The different sections of the throw * The different sections of the throw
@ -52,7 +52,20 @@ public class Throw implements Action {
@Override @Override
public ButtonIG[][] getCommand() { public ButtonIG[][] getCommand() {
return command; return this.command;
} }
public Throw(boolean isSpecial, ThrowPart[] parts) {
this.isSpecial = isSpecial;
this.parts = parts;
}
public Throw() {
}
public Throw(boolean isSpecial, ButtonIG[][] command, ThrowPart[] parts) {
this.isSpecial = isSpecial;
this.command = command;
this.parts = parts;
}
} }

174
src/gameplay/entities/Character.java
View File

@ -13,8 +13,8 @@ import java.util.ArrayList;
* *
*/ */
public class Character extends Entity { public class Character extends Entity {
private static int maxHP; private int maxHP;
private static int currentHP; private int currentHP;
/** /**
* All of the attacks, both special and normal, of the character * All of the attacks, both special and normal, of the character
@ -22,23 +22,23 @@ public class Character extends Entity {
* For example, you should have something like : * For example, you should have something like :
* {Rising Punch, FireBall, Jump D/C/B/A, Crouch D/C/B/A, Stand D/C/B/A} * {Rising Punch, FireBall, Jump D/C/B/A, Crouch D/C/B/A, Stand D/C/B/A}
*/ */
private static Attack[] attacks; private Attack[] attacks;
private static Jump forwardJump; private Jump forwardJump;
private static Jump neutralJump; private Jump neutralJump;
private static Jump backJump; private Jump backJump;
private static Dash forwardDash; private Dash forwardDash;
private static Dash backDash; private Dash backDash;
private static Throw normalthrow; private Throw normalthrow;
private static Status status; private Status status;
private static Frame[] defaultStandingFrames; private Frame[] defaultStandingFrames;
private static Frame[] defaultCrouchingFrames; private Frame[] defaultCrouchingFrames;
private static Frame[] forwardWalkFrames; private Frame[] forwardWalkFrames;
private static Frame[] backWalkFrames; private Frame[] backWalkFrames;
private Frame hitInAirFrame; //the frame to display when hit in the air. Shouldmake the character rise private Frame hitInAirFrame; //the frame to display when hit in the air. Shouldmake the character rise
private Frame fallingframe; //the frame to display when falling from the air private Frame fallingframe; //the frame to display when falling from the air
private Frame[] knockedDownFrames; private Frame[] knockedDownFrames;
@ -67,111 +67,137 @@ public class Character extends Entity {
this.currentHP = this.maxHP; this.currentHP = this.maxHP;
} }
public Character(int posx, int posy, Frame f, int maxHP, Attack[] attacks, Jump forwardJump, Jump neutralJump, Jump backJump, Dash forwardDash, Dash backDash, Throw normalthrow, Frame[] defaultStandingFrames, Frame[] defaultCrouchingFrames, Frame[] forwardWalkFrames, Frame[] backWalkFrames, Frame hitInAirFrame, Frame fallingframe, Frame[] knockedDownFrames, Frame standGuardFrame, Frame crouchGuardFrame, Frame standHitFrame, Frame crouchHitFrame) {
super(posx, posy, f);
this.maxHP = maxHP;
this.attacks = attacks;
this.forwardJump = forwardJump;
this.neutralJump = neutralJump;
this.backJump = backJump;
this.forwardDash = forwardDash;
this.backDash = backDash;
this.normalthrow = normalthrow;
this.defaultStandingFrames = defaultStandingFrames;
this.defaultCrouchingFrames = defaultCrouchingFrames;
this.forwardWalkFrames = forwardWalkFrames;
this.backWalkFrames = backWalkFrames;
this.hitInAirFrame = hitInAirFrame;
this.fallingframe = fallingframe;
this.knockedDownFrames = knockedDownFrames;
this.standGuardFrame = standGuardFrame;
this.crouchGuardFrame = crouchGuardFrame;
this.standHitFrame = standHitFrame;
this.crouchHitFrame = crouchHitFrame;
this.nextAttackParts = new ArrayList<attackPart>();
this.nextThrowParts = new ArrayList<ThrowPart>();
this.currentHP = maxHP;
this.status = Status.NORMAL;
}
public void setMaxHP(int HP) { public void setMaxHP(int HP) {
this.maxHP = HP; this.maxHP = HP;
} }
public int getMaxHP() { return this.maxHP;} public int getMaxHP() { return this.maxHP;}
public static Attack[] getAttacks() { public Attack[] getAttacks() {
return attacks; return this.attacks;
} }
public static void setAttacks(Attack[] attacks) { public void setAttacks(Attack[] attacks) {
Character.attacks = attacks; this.attacks = attacks;
} }
public static Jump getForwardJump() { public Jump getForwardJump() {
return forwardJump; return this.forwardJump;
} }
public static void setForwardJump(Jump forwardJump) { public void setForwardJump(Jump forwardJump) {
Character.forwardJump = forwardJump; this.forwardJump = forwardJump;
} }
public static Jump getNeutralJump() { public Jump getNeutralJump() {
return neutralJump; return this.neutralJump;
} }
public static void setNeutralJump(Jump neutralJump) { public void setNeutralJump(Jump neutralJump) {
Character.neutralJump = neutralJump; this.neutralJump = neutralJump;
} }
public static Jump getBackJump() { public Jump getBackJump() {
return backJump; return this.backJump;
} }
public static void setBackJump(Jump backJump) { public void setBackJump(Jump backJump) {
Character.backJump = backJump; this.backJump = backJump;
} }
public static Dash getForwardDash() { public Dash getForwardDash() {
return forwardDash; return this.forwardDash;
} }
public static void setForwardDash(Dash forwardDash) { public void setForwardDash(Dash forwardDash) {
Character.forwardDash = forwardDash; this.forwardDash = forwardDash;
} }
public static Dash getBackDash() { public Dash getBackDash() {
return backDash; return this.backDash;
} }
public static void setBackDash(Dash backDash) { public void setBackDash(Dash backDash) {
Character.backDash = backDash; this.backDash = backDash;
} }
public static Throw getNormalthrow() { public Throw getNormalthrow() {
return normalthrow; return this.normalthrow;
} }
public static void setNormalthrow(Throw normalthrow) { public void setNormalthrow(Throw normalthrow) {
Character.normalthrow = normalthrow; this.normalthrow = normalthrow;
} }
public static Status getStatus() { public Status getStatus() {
return status; return this.status;
} }
public static void setStatus(Status status) { public void setStatus(Status status) {
Character.status = status; this.status = status;
} }
public static Frame[] getDefaultStandingFrames() { public Frame[] getDefaultStandingFrames() {
return defaultStandingFrames; return this.defaultStandingFrames;
} }
public static void setDefaultStandingFrames(Frame[] defaultStandingFrames) { public void setDefaultStandingFrames(Frame[] defaultStandingFrames) {
Character.defaultStandingFrames = defaultStandingFrames; this.defaultStandingFrames = defaultStandingFrames;
} }
public static Frame[] getDefaultCrouchingFrames() { public Frame[] getDefaultCrouchingFrames() {
return defaultCrouchingFrames; return this.defaultCrouchingFrames;
} }
public static void setDefaultCrouchingFrames(Frame[] defaultCrouchingFrames) { public void setDefaultCrouchingFrames(Frame[] defaultCrouchingFrames) {
Character.defaultCrouchingFrames = defaultCrouchingFrames; this.defaultCrouchingFrames = defaultCrouchingFrames;
} }
public static Frame[] getForwardWalkFrames() { public Frame[] getForwardWalkFrames() {
return forwardWalkFrames; return this.forwardWalkFrames;
} }
public static void setForwardWalkFrames(Frame[] forwardWalkFrames) { public void setForwardWalkFrames(Frame[] forwardWalkFrames) {
Character.forwardWalkFrames = forwardWalkFrames; this.forwardWalkFrames = forwardWalkFrames;
} }
public static Frame[] getBackWalkFrames() { public Frame[] getBackWalkFrames() {
return backWalkFrames; return this.backWalkFrames;
} }
public static void setBackWalkFrames(Frame[] backWalkFrames) { public void setBackWalkFrames(Frame[] backWalkFrames) {
Character.backWalkFrames = backWalkFrames; this.backWalkFrames = backWalkFrames;
} }
public ArrayList<attackPart> getNextAttackParts() { public ArrayList<attackPart> getNextAttackParts() {
return nextAttackParts; return this.nextAttackParts;
} }
public void setNextAttackParts(ArrayList<attackPart> nextAttackParts) { public void setNextAttackParts(ArrayList<attackPart> nextAttackParts) {
@ -194,7 +220,7 @@ public class Character extends Entity {
} }
public ArrayList<ThrowPart> getNextThrowParts() { public ArrayList<ThrowPart> getNextThrowParts() {
return nextThrowParts; return this.nextThrowParts;
} }
public void setNextThrowParts(ArrayList<ThrowPart> nextAttackParts) { public void setNextThrowParts(ArrayList<ThrowPart> nextAttackParts) {
@ -216,8 +242,8 @@ public class Character extends Entity {
this.nextThrowParts.remove(0); this.nextThrowParts.remove(0);
} }
public static int getCurrentHP() { public int getCurrentHP() {
return currentHP; return this.currentHP;
} }
public void setCurrentHP(int currentHP) { public void setCurrentHP(int currentHP) {
@ -240,7 +266,7 @@ public class Character extends Entity {
} }
public Frame getHitInAirFrame() { public Frame getHitInAirFrame() {
return hitInAirFrame; return this.hitInAirFrame;
} }
public void setHitInAirFrame(Frame hitInAirFrame) { public void setHitInAirFrame(Frame hitInAirFrame) {
@ -248,7 +274,7 @@ public class Character extends Entity {
} }
public Frame getFallingframe() { public Frame getFallingframe() {
return fallingframe; return this.fallingframe;
} }
public void setFallingframe(Frame fallingframe) { public void setFallingframe(Frame fallingframe) {
@ -256,7 +282,7 @@ public class Character extends Entity {
} }
public Frame[] getKnockedDownFrames() { public Frame[] getKnockedDownFrames() {
return knockedDownFrames; return this.knockedDownFrames;
} }
public void setKnockedDownFrames(Frame[] knockedDownFrames) { public void setKnockedDownFrames(Frame[] knockedDownFrames) {
@ -264,7 +290,7 @@ public class Character extends Entity {
} }
public Frame getStandGuardFrame() { public Frame getStandGuardFrame() {
return standGuardFrame; return this.standGuardFrame;
} }
public void setStandGuardFrame(Frame standGuardFrame) { public void setStandGuardFrame(Frame standGuardFrame) {
@ -272,7 +298,7 @@ public class Character extends Entity {
} }
public Frame getCrouchGuardFrame() { public Frame getCrouchGuardFrame() {
return crouchGuardFrame; return this.crouchGuardFrame;
} }
public void setCrouchGuardFrame(Frame crouchGuardFrame) { public void setCrouchGuardFrame(Frame crouchGuardFrame) {
@ -280,7 +306,7 @@ public class Character extends Entity {
} }
public Frame getStandHitFrame() { public Frame getStandHitFrame() {
return standHitFrame; return this.standHitFrame;
} }
public void setStandHitFrame(Frame standHitFrame) { public void setStandHitFrame(Frame standHitFrame) {
@ -288,7 +314,7 @@ public class Character extends Entity {
} }
public Frame getCrouchHitFrame() { public Frame getCrouchHitFrame() {
return crouchHitFrame; return this.crouchHitFrame;
} }
public void setCrouchHitFrame(Frame crouchHitFrame) { public void setCrouchHitFrame(Frame crouchHitFrame) {

28
src/gameplay/frames/Frame.java
View File

@ -2,6 +2,7 @@ package gameplay.frames;
import java.util.ArrayList; import java.util.ArrayList;
import engine.graphics.Texture;
import gameplay.hitboxes.*; import gameplay.hitboxes.*;
/** /**
@ -24,6 +25,10 @@ public class Frame {
private boolean moveCancellable; private boolean moveCancellable;
private boolean isDashCancellable; private boolean isDashCancellable;
private boolean lastFrameOfHit; private boolean lastFrameOfHit;
/**
* an int of 4 that determines the texture wrap for the frame
*/
private int[] sprite;
public Frame() { public Frame() {
this.setMove_y(0.0); this.setMove_y(0.0);
@ -39,6 +44,7 @@ public class Frame {
this.moveCancellable = true; this.moveCancellable = true;
this.isDashCancellable = true; this.isDashCancellable = true;
this.lastFrameOfHit = false; this.lastFrameOfHit = false;
this.sprite = new int[4];
} }
public Frame(Double move_y, Double move_x, ArrayList<Passive_HitBox> passHitBox, ArrayList<Active_HitBox> actHitBox, public Frame(Double move_y, Double move_x, ArrayList<Passive_HitBox> passHitBox, ArrayList<Active_HitBox> actHitBox,
@ -58,6 +64,7 @@ public class Frame {
this.moveCancellable = moveCancellable; this.moveCancellable = moveCancellable;
this.isDashCancellable = isDashCancellable; this.isDashCancellable = isDashCancellable;
this.lastFrameOfHit = false; this.lastFrameOfHit = false;
this.sprite = new int[4];
} }
/* /*
@ -179,6 +186,25 @@ public class Frame {
this.jumpCancellable = f.jumpCancellable; this.jumpCancellable = f.jumpCancellable;
this.moveCancellable = f.isMoveCancellable(); this.moveCancellable = f.isMoveCancellable();
this.isDashCancellable = f.isDashCancellable; this.isDashCancellable = f.isDashCancellable;
this.lastFrameOfHit = islastFrameOfHit(); this.lastFrameOfHit = f.islastFrameOfHit();
this.setSpriteWrap(f.sprite[0], f.sprite[1], f.sprite[2], f.sprite[3]);
}
/**
* sets the coordinates on the spritesheet for the texture for that frame
* @param x coordinate of the lef tside
* @param y coordonate of the top
* @param sizeH horizontal size of the sprite
* @param sizeV horizontal size of the sprite
*/
public void setSpriteWrap(int x, int y, int sizeH, int sizeV) {
this.sprite[0] = x;
this.sprite[1] = y;
this.sprite[2] = sizeH;
this.sprite[3] = sizeV;
}
public int[] getSprite() {
return sprite;
} }
} }

4
src/gameplay/frames/nextFrameBuffer.java
View File

@ -49,7 +49,9 @@ public class nextFrameBuffer {
} }
public Frame getNextframe() { public Frame getNextframe() {
return this.next.current; try {
return this.next.current;
} catch(NullPointerException e) {return null;}
} }
/** /**

7
src/gameplay/hitboxes/Active_HitBox.java
View File

@ -1,5 +1,10 @@
package gameplay.hitboxes; package gameplay.hitboxes;
public class Active_HitBox extends HitBox { public class Active_HitBox extends HitBox {
public Active_HitBox() {
super();
}
public Active_HitBox(float posX, float posY, float sizeX, float sizeY) {
super(posX, posY, sizeX, sizeY);
}
} }

7
src/gameplay/hitboxes/Active_throw_Hitbox.java
View File

@ -1,5 +1,10 @@
package gameplay.hitboxes; package gameplay.hitboxes;
public class Active_throw_Hitbox extends HitBox { public class Active_throw_Hitbox extends HitBox {
public Active_throw_Hitbox() {
super();
}
public Active_throw_Hitbox(float posX, float posY, float sizeX, float sizeY) {
super(posX, posY, sizeX, sizeY);
}
} }

48
src/gameplay/hitboxes/HitBox.java
View File

@ -2,23 +2,31 @@ package gameplay.hitboxes;
public class HitBox { public class HitBox {
private double position_x; private float position_x;
private double position_y; private float position_y;
private double size_x; private float size_x;
private double size_y; private float size_y;
public HitBox() { public HitBox() {
this.position_x = 0.0; this.position_x = 0.0f;
this.position_y = 0.0; this.position_y = 0.0f;
this.size_x = 0.0; this.size_x = 0.0f;
this.size_y = 0.0; this.size_y = 0.0f;
}
public HitBox(float posX, float posY, float sizeX, float sizeY) {
this.position_x = posX;
this.position_y = posY;
this.size_x = sizeX;
this.size_y = sizeY;
} }
public void setPosition_x(Double position_x){ public void setPosition_x(float position_x){
this.position_x = position_x; this.position_x = position_x;
} }
public void setPosition_y(Double position_y){ public void setPosition_y(float position_y){
this.position_y = position_y; this.position_y = position_y;
} }
@ -30,10 +38,10 @@ public class HitBox {
public Boolean hit(HitBox hb) { public Boolean hit(HitBox hb) {
Boolean horiz = false; Boolean horiz = false;
Boolean ver = false; Boolean ver = false;
Double horizontal1 = this.position_x + this.size_x; float horizontal1 = this.position_x + this.size_x;
Double vertical1 = this.position_y + this.size_y; float vertical1 = this.position_y + this.size_y;
Double horizontal2 = hb.position_x + hb.size_x; float horizontal2 = hb.position_x + hb.size_x;
Double vertical2 = hb.position_y + hb.size_y; float vertical2 = hb.position_y + hb.size_y;
/* /*
@ -66,27 +74,27 @@ public class HitBox {
return horiz && ver; return horiz && ver;
} }
public Double getPosX() { public float getPosX() {
return position_x; return position_x;
} }
public Double getPosY() { public float getPosY() {
return position_y; return position_y;
} }
public Double getSize_x() { public float getSize_x() {
return size_x; return size_x;
} }
public void setSize_x(Double size_x) { public void setSize_x(float size_x) {
this.size_x = size_x; this.size_x = size_x;
} }
public Double getSize_y() { public float getSize_y() {
return size_y; return size_y;
} }
public void setSize_y(Double size_y) { public void setSize_y(float size_y) {
this.size_y = size_y; this.size_y = size_y;
} }

7
src/gameplay/hitboxes/Passive_HitBox.java
View File

@ -1,5 +1,10 @@
package gameplay.hitboxes; package gameplay.hitboxes;
public class Passive_HitBox extends HitBox { public class Passive_HitBox extends HitBox {
public Passive_HitBox() {
super();
}
public Passive_HitBox(float posX, float posY, float sizeX, float sizeY) {
super(posX, posY, sizeX, sizeY);
}
} }

7
src/gameplay/hitboxes/Passive_throw_HitBox.java
View File

@ -1,5 +1,10 @@
package gameplay.hitboxes; package gameplay.hitboxes;
public class Passive_throw_HitBox extends HitBox { public class Passive_throw_HitBox extends HitBox {
public Passive_throw_HitBox() {
super();
}
public Passive_throw_HitBox(float posX, float posY, float sizeX, float sizeY) {
super(posX, posY, sizeX, sizeY);
}
} }

3
src/gameplay/hitboxes/Push_HitBox.java
View File

@ -5,4 +5,7 @@ public class Push_HitBox extends HitBox {
public Push_HitBox() { public Push_HitBox() {
super(); super();
} }
public Push_HitBox(float posX, float posY, float sizeX, float sizeY) {
super(posX, posY, sizeX, sizeY);
}
} }

147
src/gameplay/match/match.java
View File

@ -1,7 +1,12 @@
package gameplay.match; package gameplay.match;
import engine.Engine;
import engine.input.Button; import engine.input.Button;
import engine.input.GamepadInput; import engine.input.GamepadInput;
import engine.math.Vector3f;
import engine.object.ObjectGl;
import engine.object.Sprite;
import gameplay.Characters.Blue.CharacterBlue;
import gameplay.actions.Attack; import gameplay.actions.Attack;
import gameplay.actions.attackPart; import gameplay.actions.attackPart;
import gameplay.actions.Throw; import gameplay.actions.Throw;
@ -36,42 +41,38 @@ public class match {
/** /**
* the level of the "ground", used to determine if a character is in the air or not. * the level of the "ground", used to determine if a character is in the air or not.
*/ */
private static final int groundLevel = 250; private static final int groundLevel = 200;
private int timer; private static int timer;
private InputBuffer inputsP1, inputsP2; private static InputBuffer inputsP1, inputsP2;
private int roundsWonP1, roundsWonP2; private static int roundsWonP1, roundsWonP2;
private Character p1, p2; //characters of player 1 and 2 private static Character p1, p2; //characters of player 1 and 2
private static long timeStamp1; private static long timeStamp1;
private static long timeStamp2; private static long timeStamp2;
private static int frameCount; private static int frameCount;
private static int oldPosXp1;
private static int oldPosXp2;
private static int oldPosYp1;
private static int oldPosYp2;
private static GamepadInput gamepad1 = null; private static GamepadInput gamepad1 = null;
private static GamepadInput gamepad2 = null; private static GamepadInput gamepad2 = null;
/** private static ObjectGl objP1,objP2;
* base constructor of the match class. private static Engine engine;
* Initiates a new match with with two given characters private static Frame f;
*/
public match(Character p1, Character p2) {
this.timer = 99;
this.inputsP1 = new InputBuffer(inputBufferSize);
this.inputsP2 = new InputBuffer(inputBufferSize);
this.p1 = p1;
this.p2 = p2;
this.roundsWonP1 = 0;
this.roundsWonP2 = 0;
}
/** /**
* Starts a new round, by placing the timer back at base value, characters back at full hp and such. * Starts a new round, by placing the timer back at base value, characters back at full hp and such.
*/ */
private void startNewRound() { private static void startNewRound() {
this.timer = 99; timer = 99;
this.inputsP1 = new InputBuffer(inputBufferSize); inputsP1 = new InputBuffer(inputBufferSize);
this.inputsP2 = new InputBuffer(inputBufferSize); inputsP2 = new InputBuffer(inputBufferSize);
this.p1.setPos(-500, groundLevel); //TODO : change to better values if needed p1.setPos(-750, groundLevel); //TODO : change to better values if needed
this.p2.setPos(500, groundLevel); //TODO : change to better values if needed p2.setPos(-750, groundLevel); //TODO : change to better values if needed
objP1.translate(new Vector3f(p1.getPosX(),p1.getPosY(),0));
objP1.translate(new Vector3f(p2.getPosX(),p2.getPosY(),0));
} }
/** /**
@ -79,7 +80,7 @@ public class match {
* Used for playing animations and such. * Used for playing animations and such.
* TODO : Implement this once we know what to do. * TODO : Implement this once we know what to do.
*/ */
private void endRound() { private static void endRound() {
} }
@ -88,7 +89,7 @@ public class match {
* Used for playing animations and such. * Used for playing animations and such.
* TODO : Implement this once we know what to do. * TODO : Implement this once we know what to do.
*/ */
private void endMatch() { private static void endMatch() {
} }
@ -156,7 +157,32 @@ public class match {
} */ } */
boolean Joystick1Present = glfwJoystickPresent(GLFW_JOYSTICK_1); boolean Joystick1Present = glfwJoystickPresent(GLFW_JOYSTICK_1);
boolean Joystick2Present = glfwJoystickPresent(GLFW_JOYSTICK_2); boolean Joystick2Present = glfwJoystickPresent(GLFW_JOYSTICK_2);
match match = new match(new Character(),new Character()); //TODO : Change to not empty chars
engine = new Engine(640, 480, new Vector3f(4.0f, 3.0f));
engine.init();
String path = "textures/Sprite.png";
String pathToBG = "textures/background_beach.png";
ObjectGl background = new ObjectGl(0f,1f,1f,10f, pathToBG, null);
background.setTextureWrap(0,0,621, 224, ObjectGl.DEFAULT);
background.translate(new Vector3f(-3011.0f, 1400.0f, 1.0f));
engine.add_objectGl(background);
p1 = CharacterBlue.generateCharBlue();
p2 = CharacterBlue.generateCharBlue();
objP1 = new Sprite(10f, 5f, path, null);
objP2 = new Sprite(15f, 5f, path, null);
objP2.setColor(new Vector3f(1.0f,0.0f,1.0f));
engine.add_objectGl(objP1);
engine.add_objectGl(objP2);
f = p1.getCurrentframe();
objP1.setTextureWrap(f.getSprite()[0], f.getSprite()[1], f.getSprite()[2], f.getSprite()[3], ObjectGl.STICK_TOP);
f = p2.getCurrentframe();
objP2.setTextureWrap(f.getSprite()[0], f.getSprite()[1], f.getSprite()[2], f.getSprite()[3], ObjectGl.STICK_TOP);
objP2.flipTextureWrapH();
if (Joystick1Present) { if (Joystick1Present) {
gamepad1 = new GamepadInput(GLFW_JOYSTICK_1); gamepad1 = new GamepadInput(GLFW_JOYSTICK_1);
@ -166,10 +192,12 @@ public class match {
gamepad2 = new GamepadInput(GLFW_JOYSTICK_2); gamepad2 = new GamepadInput(GLFW_JOYSTICK_2);
gamepad2.inputRefresh(); gamepad2.inputRefresh();
} }
ac(0);
} }
private void ac(int i) { private static void ac(int i) {
System.out.println(i);
switch (i) { switch (i) {
//initiate a round //initiate a round
@ -182,6 +210,11 @@ public class match {
//checks if one or both of the chars are out of health //checks if one or both of the chars are out of health
case 10: case 10:
oldPosXp1 = p1.getPosX();
oldPosXp2 = p2.getPosX();
oldPosYp1 = p1.getPosY();
oldPosYp2 = p2.getPosY();
if(p1.getCurrentHP() <= 0 && p2.getCurrentHP() <= 0) { ac(11);} if(p1.getCurrentHP() <= 0 && p2.getCurrentHP() <= 0) { ac(11);}
else if(p1.getCurrentHP() <= 0) { ac(12);} else if(p1.getCurrentHP() <= 0) { ac(12);}
else if(p2.getCurrentHP() <= 0) { ac(13);} else if(p2.getCurrentHP() <= 0) { ac(13);}
@ -209,10 +242,12 @@ public class match {
//read both players inputs //read both players inputs
case 20: case 20:
gamepad1.inputRefresh(); if (glfwJoystickPresent(GLFW_JOYSTICK_1) && glfwJoystickPresent(GLFW_JOYSTICK_2)) {
gamepad2.inputRefresh(); gamepad1.inputRefresh();
inputsP1.recordInputsFromGamepad(gamepad1, p1.getPosX() < p2.getPosX()); inputsP1.recordInputsFromGamepad(gamepad1, p1.getPosX() < p2.getPosX());
inputsP2.recordInputsFromGamepad(gamepad2, p2.getPosX() <= p1.getPosX()); gamepad2.inputRefresh();
inputsP2.recordInputsFromGamepad(gamepad2, p2.getPosX() <= p1.getPosX());
}
handleInputs(p1, inputsP1); handleInputs(p1, inputsP1);
handleInputs(p2, inputsP2); handleInputs(p2, inputsP2);
ac(21); ac(21);
@ -220,9 +255,13 @@ public class match {
//start of the handling of hitboxes //start of the handling of hitboxes
case 21: case 21:
handleThrows(p1,p2); try {
handleHits(p1,p2,inputsP2); handleThrows(p1, p2);
handleHits(p2,p1,inputsP1); } catch (IndexOutOfBoundsException e) {}
try {
handleHits(p1, p2, inputsP2);
handleHits(p2, p1, inputsP1);
}catch (IndexOutOfBoundsException e) {};
ac(22); ac(22);
break; break;
@ -238,18 +277,29 @@ public class match {
nextFrame(p2,inputsP2); nextFrame(p2,inputsP2);
updatePos(p1); updatePos(p1);
updatePos(p2); updatePos(p2);
f = p1.getCurrentframe();
objP1.setTextureWrap(f.getSprite()[0], f.getSprite()[1], f.getSprite()[2], f.getSprite()[3], ObjectGl.STICK_TOP);
objP1.translate(new Vector3f(p1.getPosX()-oldPosXp1,p1.getPosY()-oldPosYp1,0));
f = p2.getCurrentframe();
objP2.setTextureWrap(f.getSprite()[0], f.getSprite()[1], f.getSprite()[2], f.getSprite()[3], ObjectGl.STICK_TOP);
objP2.translate(new Vector3f(p2.getPosX()-oldPosXp2,p2.getPosY()-oldPosYp2,0));
boolean p1LooksRight = p1.getPosX() < p2.getPosX(); boolean p1LooksRight = p1.getPosX() < p2.getPosX();
if(p1LooksRight) { if(p1LooksRight) {
Frame f = new Frame(); Frame nf = new Frame();
f.clone(p2.getCurrentframe()); nf.clone(p2.getCurrentframe());
f.invertHitBoxes(); nf.invertHitBoxes();
p2.setCurrentFrame(f); p2.setCurrentFrame(nf);
objP2.flipTextureWrapH();
} else { } else {
Frame f = new Frame(); Frame nf = new Frame();
f.clone(p1.getCurrentframe()); nf.clone(p1.getCurrentframe());
f.invertHitBoxes(); nf.invertHitBoxes();
p1.setCurrentFrame(f); p1.setCurrentFrame(nf);
objP1.flipTextureWrapH();
} }
engine.update();
engine.render();
ac(23); ac(23);
break; break;
@ -472,10 +522,11 @@ public class match {
* @param c the character * @param c the character
* @param in the input buffer corresponding to the character * @param in the input buffer corresponding to the character
*/ */
private void nextFrame(Character c, InputBuffer in) { private static void nextFrame(Character c, InputBuffer in) {
if(!c.getFrames().getNextframe().equals(null)){ try {
//if(!c.getFrames().getNextframe().equals(null)){
c.goToNextFrames(); c.goToNextFrames();
} else { } catch (NullPointerException e) {
switch(c.getStatus()) { switch(c.getStatus()) {
case FALLING:case HITINAIR: case FALLING:case HITINAIR:
if(c.getPosY() > groundLevel){ if(c.getPosY() > groundLevel){
@ -496,7 +547,7 @@ public class match {
} }
} }
private void updatePos(Character c) { private static void updatePos(Character c) {
c.setPos((int)(c.getPosX()+c.getCurrentframe().getMove_x()),(int)(c.getPosY()+c.getCurrentframe().getMove_y())); c.setPos((int)(c.getPosX()+c.getCurrentframe().getMove_x()),(int)(c.getPosY()+c.getCurrentframe().getMove_y()));
} }

27
src/launcher/Launcher.java
View File

@ -9,20 +9,23 @@
package launcher; package launcher;
import engine.TestEngine; import gameplay.match.*;
import javafx.application.Application; import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Parent; import javafx.scene.Parent;
import javafx.scene.Scene; import javafx.scene.Scene;
import javafx.scene.control.ChoiceBox;
import javafx.stage.Stage; import javafx.stage.Stage;
import javafx.stage.StageStyle; import javafx.stage.StageStyle;
import javafx.fxml.*; import javafx.fxml.*;
import java.util.HashMap;
import engine.Engine;
public class Launcher extends Application { public class Launcher extends Application {
public static Launcher pointer; public static Launcher pointer;
private static Settings setter; private static Settings setter;
private HashMap<String, Object> arraysettings;
public Launcher() { public Launcher() {
pointer = this; pointer = this;
@ -32,6 +35,7 @@ public class Launcher extends Application {
e.printStackTrace(); e.printStackTrace();
System.exit(1); System.exit(1);
} }
arraysettings = new HashMap<String, Object>();
} }
/* /*
@ -43,6 +47,17 @@ public class Launcher extends Application {
Scene main = new Scene(root); Scene main = new Scene(root);
@SuppressWarnings("unchecked")
ChoiceBox<String> cb = (ChoiceBox<String>) main.lookup("#resolution");
ObservableList<String> availableres = FXCollections.observableArrayList("640x480", "800x600", "1024x768", "1280x720", "1366x768", "1600x900", "1920x1080");
cb.setItems(availableres);
if (!availableres.contains(setter.getResolution())) {
cb.setValue("640x480");
} else {
cb.setValue(setter.getResolution());
}
primaryStage.initStyle(StageStyle.UNDECORATED); primaryStage.initStyle(StageStyle.UNDECORATED);
primaryStage.setTitle("Boulevard Combattant"); primaryStage.setTitle("Boulevard Combattant");
primaryStage.setScene(main); primaryStage.setScene(main);
@ -53,7 +68,7 @@ public class Launcher extends Application {
public static void runGame() { public static void runGame() {
try { try {
setter.setSettings(); setter.setSettings();
TestEngine.main(null); match.main(null);
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
System.exit(1); System.exit(1);
@ -80,4 +95,8 @@ public class Launcher extends Application {
getHostServices().showDocument("https://gitlab.istic.univ-rennes1.fr/fautin/jeu-de-combat"); getHostServices().showDocument("https://gitlab.istic.univ-rennes1.fr/fautin/jeu-de-combat");
} }
public HashMap<String, Object> getArraysettings() {
return arraysettings;
}
} }

171
src/launcher/Settings.java
View File

@ -3,162 +3,41 @@ package launcher;
import java.io.File; import java.io.File;
import java.io.FileInputStream; import java.io.FileInputStream;
import java.io.FileNotFoundException; import java.io.FileNotFoundException;
import java.util.HashMap;
import configuration.*;
public class Settings { public class Settings {
private class Player { private Config config;
private int controller_id;
private String character;
private int color;
public Player(int cid, String ch, int col) {
controller_id = cid;
character = ch;
color = col;
}
protected int getController_id() {
return controller_id;
}
protected void setController_id(int controller_id) {
this.controller_id = controller_id;
}
protected String getCharacter() {
return character;
}
protected void setCharacter(String character) {
this.character = character;
}
protected int getColor() {
return color;
}
protected void setColor(int color) {
this.color = color;
}
}
private FileInputStream f_is; public Settings() {
private int width, height, r_x, r_y, rounds;
private boolean fullscreen;
private String stage;
private Player p1, p2;
public Settings() throws Exception {
try { try {
f_is = new FileInputStream("game.set"); config = new Config();
} catch (FileNotFoundException e) { } catch (Exception e) {
File f = new File("game.set"); e.printStackTrace();
f.createNewFile(); System.exit(1);
} finally {
f_is = new FileInputStream("game.set");
} }
try {
parseSettings();
} finally {
setDefaultSettings();
}
}
private void parseSettings() throws Exception {
//TODO: parseSettings() (Needs settings syntax fixed)
} }
public void setSettings() throws Exception { public void setSettings() throws Exception {
//TODO: parseSettings() (Needs settings syntax fixed) HashMap<String, Object> set = Launcher.pointer.getArraysettings();
try {
int width = (Integer) set.get("width");
int height = (Integer) set.get("height");
int rounds = (Integer) set.get("rounds");
boolean fullscreen = (Boolean) set.get("fullscreen");
String character1 = (String) set.get("character1");
String character2 = (String) set.get("character2");
String stage = (String) set.get("stage");
config.write(width, height, rounds, fullscreen, character1, character2, stage);
} catch (Exception e) {
config.write(800, 600, 3, false, "default", "default", "default");
System.out.println("Incorrect config file");
}
} }
private void setDefaultSettings() { public String getResolution() {
width = 800; return "" + Integer.toString(config.width) + "x" + Integer.toString(config.height);
height = 600;
r_x = 4;
r_y = 3;
rounds = 3;
fullscreen = false;
p1 = new Player(0, "base", 0);
p2 = new Player(0, "base", 0);
} }
protected FileInputStream getF_is() {
return f_is;
}
protected int getWidth() {
return width;
}
protected int getHeight() {
return height;
}
protected int getR_x() {
return r_x;
}
protected int getR_y() {
return r_y;
}
protected int getRounds() {
return rounds;
}
protected boolean isFullscreen() {
return fullscreen;
}
protected String getStage() {
return stage;
}
protected Player getP1() {
return p1;
}
protected Player getP2() {
return p2;
}
protected void setF_is(FileInputStream f_is) {
this.f_is = f_is;
}
protected void setWidth(int width) {
this.width = width;
}
protected void setHeight(int height) {
this.height = height;
}
protected void setR_x(int r_x) {
this.r_x = r_x;
}
protected void setR_y(int r_y) {
this.r_y = r_y;
}
protected void setRounds(int rounds) {
this.rounds = rounds;
}
protected void setFullscreen(boolean fullscreen) {
this.fullscreen = fullscreen;
}
protected void setStage(String stage) {
this.stage = stage;
}
protected void setP1(Player p1) {
this.p1 = p1;
}
protected void setP2(Player p2) {
this.p2 = p2;
}
} }

4
src/launcher/launcher.fxml
View File

@ -35,8 +35,8 @@
<children> <children>
<Button text="Play" fx:id="btn_launch" onAction="#launch" <Button text="Play" fx:id="btn_launch" onAction="#launch"
prefWidth="110" prefHeight="15"/> prefWidth="110" prefHeight="15"/>
<Button text="Settings" fx:id="btn_settings" onAction="#settings" <Label text="Resolution"/>
prefWidth="110" prefHeight="15"/> <ChoiceBox fx:id="resolution"/>
<Button text="Quit" fx:id="btn_quit" onAction="#quit" <Button text="Quit" fx:id="btn_quit" onAction="#quit"
prefWidth="110" prefHeight="15"/> prefWidth="110" prefHeight="15"/>
</children> </children>

5
src/launcher/style.css
View File

@ -52,4 +52,9 @@ Text, Label {
/* Link to project */ /* Link to project */
Hyperlink:visited { Hyperlink:visited {
-fx-text-fill: #0095c8; -fx-text-fill: #0095c8;
}
.contr_box {
-fx-fill: #000000 !important;
-fx-text-fill: #000000 !important;
} }