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>

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

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

@ -10,9 +10,9 @@ 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 static Status requiredStatus; private Status requiredStatus;
/** /**
@ -20,7 +20,7 @@ public class Attack implements Action {
* 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;
/** /**
@ -28,6 +28,13 @@ public class Attack implements Action {
*/ */
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();}
} }

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

@ -11,7 +11,7 @@ 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;
@ -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;
}
} }

172
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,6 +67,32 @@ 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;
@ -74,104 +100,104 @@ public class Character extends Entity {
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;
} }
} }

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

@ -49,7 +49,9 @@ public class nextFrameBuffer {
} }
public Frame getNextframe() { public Frame getNextframe() {
try {
return this.next.current; 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 void setPosition_x(Double position_x){
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(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);
}
} }

139
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:
if (glfwJoystickPresent(GLFW_JOYSTICK_1) && glfwJoystickPresent(GLFW_JOYSTICK_2)) {
gamepad1.inputRefresh(); gamepad1.inputRefresh();
gamepad2.inputRefresh();
inputsP1.recordInputsFromGamepad(gamepad1, p1.getPosX() < p2.getPosX()); inputsP1.recordInputsFromGamepad(gamepad1, p1.getPosX() < p2.getPosX());
gamepad2.inputRefresh();
inputsP2.recordInputsFromGamepad(gamepad2, p2.getPosX() <= p1.getPosX()); 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; public Settings() {
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;
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

@ -53,3 +53,8 @@ Text, Label {
Hyperlink:visited { Hyperlink:visited {
-fx-text-fill: #0095c8; -fx-text-fill: #0095c8;
} }
.contr_box {
-fx-fill: #000000 !important;
-fx-text-fill: #000000 !important;
}