package net.shipshoot.client.gui;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.DisplayMode;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import net.shipshoot.client.gui.control.GameFrameController;
import net.shipshoot.client.gui.pane.JConsole;
import net.shipshoot.client.gui.pane.MainMenu;
import net.shipshoot.client.instance.ObjektDao;
import net.shipshoot.client.runner.Client;
import net.shipshoot.client.tcp.send.SendScreenSize;
import net.shipshoot.client.util.ClientFactory;
import net.shipshoot.lib.model.Objekt;
import net.shipshoot.lib.model.PaintAble;
import net.shipshoot.lib.util.Config;
import net.shipshoot.lib.util.Util;
import net.shipshoot.lib.util.MainConfig;
import net.shipshoot.protocol.io.IOSession;
import net.shipshoot.protocol.model.IPacket;
import net.shipshoot.protocol.send.SendModelPacket;
import net.shipshoot.protocol.util.ProtocolFactory;
import org.apache.log4j.Logger;
public class GameFrame extends JPanel {
private static final long serialVersionUID = -688051311618433062L;
/** Die Instance fuer die Singolton */
private static final GameFrame INSTANCE = new GameFrame();
/** Logger um informationen mit zu Loggen */
private Logger log = Logger.getLogger(GameFrame.class);
/** Ob das Glass JPnale Schon benutzt wird oder nicht */
private boolean glassPanelLock = false;
/** Wenn das GameFrame im full Screen leuft */
private boolean isFullScreen = false;
/** Um eine Durschnitt frps rate zu berechnen */
private int frpsIndex = 0;
/** Liste mit alle frps */
private long[] frps = new long[100];
/** Der JFrame */
private JFrame f = null;
/** Die JConsole fuer die JTextArea zum Loggen */
private JConsole console = null;
/** Das Glass Pnael fuer Score + Map */
private JPanel glassPanel = null;
/** Die {@link IOSession} zum verschiechen von {@link IPacket} */
private IOSession session = null;
/** Das GrapicsDevise fuer den FullScreen */
private GraphicsDevice gd = null;
/** Der Controller fuer MVC */
private GameFrameController gController = null;
/** Das Main Menu um es anzuzeigen */
private MainMenu mainMenu = null;
/**
* Konstruktor - I <bR>
* Erzeugt das GameFrame fuer das Spiel
*/
private GameFrame() {
/* Erzeugt den Controller MVC */
gController = new GameFrameController(this);
/* Setzt due GUI up */
makeGUI();
}
private void makeGUI() {
gd = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
f = new JFrame(gd.getDefaultConfiguration());
f.setTitle("ShipShoot Client " + Client.VERSION + " : " + MainConfig.getInstance().getConfig().getProperty("last.play.name"));
f.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
f.setName("GameFrame");
f.getContentPane().setLayout(new BorderLayout());
f.setFocusTraversalKeysEnabled(false);
addListeners();
setMainPanelUP();
f.getContentPane().add(this, BorderLayout.CENTER);
console = new JConsole();
f.getContentPane().add(console, BorderLayout.SOUTH);
mainMenu = new MainMenu(this);
Util.sleep(120);
}
/* ------------- repaint() ----------- */
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// ClientFactory.drawGrid(g, this.getWidth(), this.getHeight(), 25);
drawObjekts(g);
drawReadomObjekts(g);
drawRenderStats(g);
}
private void drawRenderStats(Graphics g) {
if (!MainConfig.getInstance().getConfig().getPropertyAsBoolean("render_stats")) {
return;
}
FontMetrics m = g.getFontMetrics();
g.setColor(Color.WHITE);
g.setFont(ClientFactory.NORMAL_FONT);
String frpPing = "Frps: " + getFrps() + " Ping: " + MainConfig.getInstance().getLatenz();
g.drawString(frpPing, this.getWidth() / 2 - m.stringWidth(frpPing) / 2, this.getHeight() - m.getHeight() * 2);
String position = "Position: " + ClientFactory.getPlayerPosition();
g.drawString(position, this.getWidth() / 2 - m.stringWidth(position) / 2, this.getHeight() - m.getHeight());
}
/**
* Zeichnet alle Spiel Obejkte aus der objektMap auf das JPanel
*
* @param g
* - um zu zeichnen
*/
private void drawObjekts(Graphics g) {
Map<Integer, Objekt> tmpMap = ObjektDao.getInstance().getGameObjekts();
List<Objekt> ob = null;
synchronized (tmpMap) {
ob = new ArrayList<Objekt>(tmpMap.values());
}
Collections.sort(ob);
for (Objekt objekt : ob) {
if (objekt == null) {
continue;
}
objekt.paintObjekt(g);
}
tmpMap = ObjektDao.getInstance().getTempObjekts();
synchronized (tmpMap) {
ob = new ArrayList<Objekt>(tmpMap.values());
}
for (Objekt objekt : ob) {
if (objekt == null) {
continue;
}
objekt.paintObjekt(g);
}
}
/**
* Zeichnet alle ReadomObjekts aus der Liste auf das JPanel
*
* @param g
* - um zu zeichnen
*/
private void drawReadomObjekts(Graphics g) {
List<Objekt> readomObjekts = ObjektDao.getInstance().getReadomObjekts();
for (int i = 0; i < readomObjekts.size(); i++) {
PaintAble<Objekt> objekt = readomObjekts.get(i);
if (objekt == null) {
continue;
}
objekt.paintObjekt(g);
}
}
/* ------------- Handlers ---------------- */
/**
* Wenn die greosse des JPanels veraendert wird, schickt er die neue groesse
* an den Server
*/
public void resizeJPanel() {
Dimension d = new Dimension(this.getWidth(), this.getHeight());
Util.getMainConfig().setPropertyAsInt("display_mode_width", this.getWidth());
Util.getMainConfig().setPropertyAsInt("display_mode_height", this.getHeight());
if (session != null) {
Util.sendData(new SendScreenSize(d.width, d.height, session));
}
log.info("JPanel.Dimension[width=" + d.width + ",height=" + d.height + "]");
}
/**
* Wenn Tab gedrueck wird, um die Socre zu bekommen
*/
public void sendNeedScore() {
if (session != null) {
Util.sendData(new SendModelPacket(ProtocolFactory.NEED_SCORE, 0, session));
}
}
/**
* wenn M gedrueck wierd um die MiniMap zu bekommen
*/
public void sendNeedMiniMap() {
if (session != null) {
Util.sendData(new SendModelPacket(ProtocolFactory.NEED_MINI_MAP, 0, session));
}
}
/**
* Raumt das glassePanel auf
*/
public void clearGlassPanel() {
glassPanel.removeAll();
glassPanelLock = false;
glassPanel.setVisible(false);
f.requestFocus();
}
/**
* Schliesst den JFrame
*/
public void close() {
if(f != null && f.isVisible()){
f.setVisible(false);
//f.dispose();
}
}
/**
* Oeffnet die Map
*/
public void openMap() {
if (mainMenu.isVisible()) {
return;
}
if (!gController.map) {
gController.map = !gController.map;
sendNeedMiniMap();
}
}
/**
* Schliesst die Map wieder
*/
public void closeMap() {
if (mainMenu.isVisible()) {
return;
}
if (gController.map) {
gController.map = !gController.map;
clearGlassPanel();
}
}
/**
* Oeffnet das ScoreBoard
*/
public void openScore() {
if (mainMenu.isVisible()) {
return;
}
if (!gController.tab) {
gController.tab = !gController.tab;
sendNeedScore();
}
}
/**
* Schliesst das ScoreBoard
*/
public void closeScore() {
if (mainMenu.isVisible()) {
return;
}
if (gController.tab) {
gController.tab = !gController.tab;
clearGlassPanel();
}
}
/*------------- Getter / Setter -----------*/
public void setSession(IOSession session) {
this.session = session;
}
public boolean isLeft() {
return gController.left;
}
public boolean isRigth() {
return gController.rigth;
}
public boolean isUp() {
return gController.up;
}
public boolean isDown() {
return gController.down;
}
public boolean isFire() {
return gController.fire;
}
public boolean isTab() {
return gController.tab;
}
public boolean isMap() {
return gController.map;
}
public void setFire(boolean b) {
gController.fire = b;
}
private long getFrps() {
long d = 0;
for (int i = 0; i < frps.length; i++) {
d += frps[i];
}
return (int) (d / (frps.length - 1));
}
/**
* Fuegt auf das GlassPanel eine {@link JComponent} hinzu
*
* @param com
* - die {@link JComponent}
*/
public void addComponent(JComponent com) {
if (glassPanelLock) {
return;
}
glassPanelLock = true;
GridBagConstraints c = new GridBagConstraints();
c.gridx = 0;
c.gridy = 0;
c.fill = GridBagConstraints.NONE;
glassPanel.add(com, c);
glassPanel.setPreferredSize(com.getPreferredSize());
glassPanel.setVisible(true);
validateGlassPanel();
}
/**
* Zeichnet das GlassPanel neu
*/
public void validateGlassPanel() {
glassPanel.validate();
glassPanel.repaint();
f.requestFocus();
}
/* --------- Util ----------- */
/**
* Addet alle Liseners
*/
private void addListeners() {
f.addKeyListener(gController);
f.addFocusListener(gController);
f.addMouseListener(gController);
f.addWindowListener(gController);
this.addComponentListener(gController);
}
/**
* Setzt das Main JPanel up, unf fuegt das glassPanel hinzu
*/
private void setMainPanelUP() {
this.setLayout(new BorderLayout());
this.setBackground(Color.black);
this.setPreferredSize(getScreenSize());
glassPanel = new JPanel();
glassPanel.setLayout(new GridBagLayout());
glassPanel.setFocusable(false);
glassPanel.setOpaque(false);
glassPanel.setVisible(false);
this.add(glassPanel, BorderLayout.CENTER);
}
/**
* Addet ein neue Frp in die list um besser die Frps zu berechnen
*
* @param frp
* - der Neue frps
*/
public void addFrp(long frp) {
if (frpsIndex < frps.length - 1) {
frpsIndex++;
} else {
frpsIndex = 0;
}
frps[frpsIndex] = frp;
}
/**
* Gibt die Instance von {@link GameFrame} zuruck, wegen Singolton
*
* @return - das einzige {@link GameFrame}
*/
public static GameFrame getInstance() {
return INSTANCE;
}
@Override
public void show() {
/* prueft od full screnn mode an ist */
isFullScreen = MainConfig.getInstance().getConfig().getPropertyAsBoolean("display_full_screen");
if (isFullScreen) {
// pruft ob full screen Supported ist
isFullScreen = gd.isFullScreenSupported();
}
/* Setzt das Frame auf die Einstellungen */
f.setUndecorated(isFullScreen);
f.setResizable(!isFullScreen);
f.setIgnoreRepaint(isFullScreen);
if (isFullScreen) {
gd.setFullScreenWindow(f);
gd.setDisplayMode(getDisplayMode());
} else {
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
}
}
/**
* Oeffnet das MainMenu und schliesstes auch wieder
*/
public void doMainMenu() {
if (mainMenu.isVisible()) {
mainMenu.setVisible(false);
mainMenu.clearMenu();
clearGlassPanel();
} else {
if (glassPanelLock == false) {
mainMenu.setVisible(true);
addComponent(mainMenu);
}
}
}
/**
* Liest aus der config die Screen groesse und gibt sie zurueck.
*
* @return die Screen groesse als {@link Dimension}
*/
private Dimension getScreenSize() {
Config config = MainConfig.getInstance().getConfig();
int width = 800;
int height = 600;
try {
width = config.getPropertyAsInt("display_mode_width");
height = config.getPropertyAsInt("display_mode_height");
} catch (Exception e) {
log.error(e);
}
return new Dimension(width, height);
}
/**
* Hold sie aus der Config das {@link DisplayMode} unf gibt es zurueck
*
* @return das {@link DisplayMode}
*/
private DisplayMode getDisplayMode() {
Config config = MainConfig.getInstance().getConfig();
Dimension d = getScreenSize();
int depth = 16;
try {
depth = config.getPropertyAsInt("display_color_depth");
} catch (Exception e) {
log.error(e);
}
return new DisplayMode(d.width, d.height, depth, DisplayMode.REFRESH_RATE_UNKNOWN);
}
}
