Skip to content
Snippets Groups Projects
Commit f98b5f9e authored by Azurlors's avatar Azurlors
Browse files

Trie

parent 6e7fd266
No related branches found
No related tags found
No related merge requests found
Showing
with 32 additions and 535 deletions
# Default ignored files
/shelf/
/workspace.xml
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager">
<output url="file://$PROJECT_DIR$/classes" />
</component>
</project>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/acl-project.iml" filepath="$PROJECT_DIR$/acl-project.iml" />
</modules>
</component>
</project>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
</component>
</project>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>acl-project</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
</buildSpec>
<natures>
</natures>
</projectDescription>
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="output" path="bin"/>
</classpath>
/bin/
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>Cyberpac2077JavaProject</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
package engine;
/**
* @author Horatiu Cirstea
*
*/
public enum Cmd {
LEFT,RIGHT,UP,DOWN,IDLE;
}
package engine;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
*/
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import javax.swing.JPanel;
public class DrawingPanel extends JPanel {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* la clase chargee de Dessiner
*/
private GamePainter painter;
/**
* image suivante est l'image cachee sur laquelle dessiner
*/
private BufferedImage nextImage;
/**
* image en cours est l'image entrain d'etre affichee
*/
private BufferedImage currentImage;
/**
* la taille des images
*/
private int width, height;
/**
* constructeur Il construit les images pour doublebuffering ainsi que le
* Panel associe. Les images stockent le painter et on demande au panel la
* mise a jour quand le painter est fini
*
* @param width
* largeur de l'image
* @param height
* hauteur de l'image
*/
public DrawingPanel(GamePainter painter) {
super();
this.width = painter.getWidth();
this.height = painter.getHeight();
this.setPreferredSize(new Dimension(this.width, this.height));
this.painter=painter;
// cree l'image buffer et son graphics
this.nextImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
this.currentImage = new BufferedImage(width, height,
BufferedImage.TYPE_INT_RGB);
}
/**
* demande de mettre a jour le rendu de l'image sur le Panel. Creer une
* nouvelle image vide sur laquelle dessiner
*/
public void drawGame() {
// generer la nouvelle image
this.painter.draw(this.nextImage);
// inverses les images doublebuffereing
BufferedImage temp = this.currentImage;
// l'image a dessiner est celle qu'on a construite
this.currentImage = this.nextImage;
// l'ancienne image est videe
this.nextImage = temp;
this.nextImage.getGraphics()
.fillRect(0, 0, this.width, this.height);
// met a jour l'image a afficher sur le panel
this.repaint();
}
/**
* redefinit la methode paint consiste a dessiner l'image en cours
*
* @param g
* graphics pour dessiner
*/
public void paint(Graphics g) {
super.paint(g);
g.drawImage(this.currentImage, 0, 0, getWidth(), getHeight(), 0, 0,
getWidth(), getHeight(), null);
}
}
package engine;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* un jeu qui peut evoluer (avant de se terminer) sur un plateau width x
* height
*/
public interface Game {
/**
* methode qui contient l'evolution du jeu en fonction de la commande
*
* @param userCmd
* commande utilisateur
*/
public void evolve(Cmd userCmd);
/**
* @return true si et seulement si le jeu est fini
*/
public boolean isFinished();
}
package engine;
import java.awt.event.KeyListener;
/**
* @author Horatiu Cirstea
*
* controleur qui envoie des commandes au jeu
*
*/
public interface GameController extends KeyListener {
/**
* quand on demande les commandes, le controleur retourne la commande en
* cours
*
* @return commande faite par le joueur
*/
public Cmd getCommand();
}
package engine;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* moteur de game generique.
* On lui passe un game et un afficheur et il permet d'executer un game.
*/
public class GameEngineGraphical {
/**
* le game a executer
*/
private Game game;
/**
* l'afficheur a utiliser pour le rendu
*/
private GamePainter gamePainter;
/**
* le controlleur a utiliser pour recuperer les commandes
*/
private GameController gameController;
/**
* l'interface graphique
*/
private GraphicalInterface gui;
/**
* construit un moteur
*
* @param game
* game a lancer
* @param gamePainter
* afficheur a utiliser
* @param gameController
* controlleur a utiliser
*
*/
public GameEngineGraphical(Game game, GamePainter gamePainter, GameController gameController) {
// creation du game
this.game = game;
this.gamePainter = gamePainter;
this.gameController = gameController;
}
/**
* permet de lancer le game
*/
public void run() throws InterruptedException {
// creation de l'interface graphique
this.gui = new GraphicalInterface(this.gamePainter,this.gameController);
// boucle de game
while (!this.game.isFinished()) {
// demande controle utilisateur
Cmd c = this.gameController.getCommand();
// fait evoluer le game
this.game.evolve(c);
// affiche le game
this.gui.paint();
// met en attente
Thread.sleep(100);
}
}
}
package engine;
import java.awt.image.BufferedImage;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* represente la maniere de dessiner sur un JPanel
*
*/
public interface GamePainter {
/**
* methode dessiner a completer. Elle construit une image correspondant au
* jeu. Game est un attribut de l'afficheur
*
* @param image
* image sur laquelle dessiner
*/
public abstract void draw(BufferedImage image);
public abstract int getWidth();
public abstract int getHeight();
}
package engine;
import javax.swing.JFrame;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* interface graphique avec son controller et son afficheur
*
*/
public class GraphicalInterface {
/**
* le Panel pour l'afficheur
*/
private DrawingPanel panel;
/**
* la construction de l'interface graphique: JFrame avec panel pour le game
*
* @param gamePainter l'afficheur a utiliser dans le moteur
* @param gameController l'afficheur a utiliser dans le moteur
*
*/
public GraphicalInterface(GamePainter gamePainter, GameController gameController){
JFrame f=new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// attacher le panel contenant l'afficheur du game
this.panel=new DrawingPanel(gamePainter);
f.setContentPane(this.panel);
// attacher controller au panel du game
this.panel.addKeyListener(gameController);
f.pack();
f.setVisible(true);
f.getContentPane().setFocusable(true);
f.getContentPane().requestFocus();
}
/**
* mise a jour du dessin
*/
public void paint() {
this.panel.drawGame();
}
}
package model;
import java.awt.event.KeyEvent;
import engine.Cmd;
import engine.GameController;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* controleur de type KeyListener
*
*/
public class PacmanController implements GameController {
/**
* commande en cours
*/
private Cmd commandeEnCours;
/**
* construction du controleur par defaut le controleur n'a pas de commande
*/
public PacmanController() {
this.commandeEnCours = Cmd.IDLE;
}
/**
* quand on demande les commandes, le controleur retourne la commande en
* cours
*
* @return commande faite par le joueur
*/
public Cmd getCommand() {
return this.commandeEnCours;
}
@Override
/**
* met a jour les commandes en fonctions des touches appuyees
*/
public void keyPressed(KeyEvent e) {
switch (e.getKeyChar()) {
// si on appuie sur 'q',commande joueur est gauche
case 'l':
case 'L':
this.commandeEnCours = Cmd.LEFT;
break;
}
}
@Override
/**
* met a jour les commandes quand le joueur relache une touche
*/
public void keyReleased(KeyEvent e) {
this.commandeEnCours = Cmd.IDLE;
}
@Override
/**
* ne fait rien
*/
public void keyTyped(KeyEvent e) {
}
}
package model;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import engine.Cmd;
import engine.Game;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* Version avec personnage qui peut se deplacer. A completer dans les
* versions suivantes.
*
*/
public class PacmanGame implements Game {
/**
* constructeur avec fichier source pour le help
*
*/
public PacmanGame(String source) {
BufferedReader helpReader;
try {
helpReader = new BufferedReader(new FileReader(source));
String ligne;
while ((ligne = helpReader.readLine()) != null) {
System.out.println(ligne);
}
helpReader.close();
} catch (IOException e) {
System.out.println("Help not available");
}
}
/**
* faire evoluer le jeu suite a une commande
*
* @param commande
*/
@Override
public void evolve(Cmd commande) {
System.out.println("Execute "+commande);
}
/**
* verifier si le jeu est fini
*/
@Override
public boolean isFinished() {
// le jeu n'est jamais fini
return false;
}
}
package model;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import engine.GamePainter;
/**
* @author Horatiu Cirstea, Vincent Thomas
*
* afficheur graphique pour le game
*
*/
public class PacmanPainter implements GamePainter {
/**
* la taille des cases
*/
protected static final int WIDTH = 100;
protected static final int HEIGHT = 100;
/**
* appelle constructeur parent
*
* @param game
* le jeutest a afficher
*/
public PacmanPainter() {
}
/**
* methode redefinie de Afficheur retourne une image du jeu
*/
@Override
public void draw(BufferedImage im) {
Graphics2D crayon = (Graphics2D) im.getGraphics();
crayon.setColor(Color.blue);
crayon.fillOval(0,0,10,10);
}
@Override
public int getWidth() {
return WIDTH;
}
@Override
public int getHeight() {
return HEIGHT;
}
}
package start;
import model.PacmanPainter;
import engine.GameEngineGraphical;
import model.PacmanController;
import model.PacmanGame;
/**
* lancement du moteur avec le jeu
*/
public class Main {
public static void main(String[] args) throws InterruptedException {
// creation du jeu particulier et de son afficheur
PacmanGame game = new PacmanGame("helpFilePacman.txt");
PacmanPainter painter = new PacmanPainter();
PacmanController controller = new PacmanController();
// classe qui lance le moteur de jeu generique
GameEngineGraphical engine = new GameEngineGraphical(game, painter, controller);
engine.run();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager">
<output url="file://$MODULE_DIR$/bin" />
<exclude-output />
<content url="file://$MODULE_DIR$" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>
\ No newline at end of file
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment