comment executer j2se server sur eclipse

Question

Bonjour, 



je suis debutant en programmation, j'ai le code source d'un serveur (j2se)  contenant 2 methodes nommées init() et start() mais la méthode main() n'existe pas!!!
le code est sans erreurs de compilation!!!
lorsque je clique sur le bouton run, une boite de dialogue s'affiche pour donner la classe  contenant la methode main()
je sais pas comment faire?
merci d'avance de votre aide.

jhonNY · Answer

voici le code source de cette serveur (qui est sans erreurs) :

import java.util.Enumeration;
import java.util.Hashtable;

import org.apache.log4j.Category;
import org.mega.gasp.event.DataEvent;
import org.mega.gasp.event.EndEvent;
import org.mega.gasp.event.JoinEvent;
import org.mega.gasp.event.QuitEvent;
import org.mega.gasp.event.StartEvent;
import org.mega.gasp.event.impl.DataEventImpl;
import org.mega.gasp.server.GASPServer;

import app2.NewPlayer;
import app2.PingPlayer;
import app2.UpdatePlayer;

public class Server extends GASPServer {

public static Category cat;

private int maxActor = 0;

private boolean gameIsStarted = false;

//private Player[] players;
private Hashtable playersTable = new Hashtable();

//private Vector[] pings;
private Hashtable htPlayerPing = new Hashtable();

public Server() {

super();
//thread = new Thread(this);
init();

cat = Category.getInstance("GASPLogging");
cat.debug("Log4J Server Category instanciated");

}

/**
* Initialization of the fields of the server.
*/
private void init() {
}

public void start() {
cat.debug("Server START running!");
//thread.start();
}

public void end() {
cat.debug("Server STOP!");
//thread.stop();
}

/*********************************************************************************/
/** Listenners : onStartEvent, onEndEvent, onJoinEvent, onQuitEvent, onDataEvent**/
/*********************************************************************************/

public void onStartEvent(StartEvent se) {
cat.debug("STARTEVENT received by server: aSID>"
+ se.getActorSessionID());
start();
gameIsStarted = true;
//players = new Player[maxActor + 1];
//pings = new Vector[maxActor + 1];

/*for(int i = 1; i <= maxActor; i++){
pings[i] = new Vector();
}*/
}

public void onEndEvent(EndEvent ee) {
cat.debug("ENDEVENT received by server: aSID>"
+ ee.getActorSessionID());
end();
}

public void onJoinEvent(JoinEvent je) {
cat.debug("JOINEVENT received by server: aSID>"
+ je.getActorSessionID() + " username>" + je.getUsername());

maxActor++;
}

public void onQuitEvent(QuitEvent qe) {
cat.debug("QUITEVENT received by server: aSID>"
+ qe.getActorSessionID());

// for waiting room only
if (!gameIsStarted)
maxActor--;

int aSID = qe.getActorSessionID();
if (gameIsStarted) {
playersTable.remove(""+aSID);
htPlayerPing.remove(""+aSID);
//players[aSID] = null;
}

}

public void onDataEvent(DataEvent de) {
cat.debug("DATAEVENT received by server: aSID>"
+ de.getActorSessionID() + " Hashtable size:"
+ de.getData().size());

Hashtable h1 = de.getData();

int nbObj = h1.size();

for (int i = 0; i < nbObj; i++) {
Object o = (Object) h1.get(i + "");
treatMessage(o, de.getActorSessionID());
}
}

/**
* Treatment of Messages object received.
*
*/
private synchronized void treatMessage(Object o, int senderASID) {
Player p = null;
if (o instanceof NewPlayer) {
NewPlayer np = (NewPlayer) o;
cat.info("*****************************************");
cat.info("BEGIN of the NEW PLAYER TREATMENT");
cat.info("Object New Player received:");
cat.info("ID: " + np.getId());
cat.info("X: " + np.getX());
cat.info("Y: " + np.getY());
cat.info("Username :"+ np.getUsername());

p = new Player(np.getId());
playersTable.put(""+np.getId(),p);
//players[np.getId()]=p;
p.setX(np.getX());
p.setY(np.getY());
p.setUsername(np.getUsername());

cat.info("Player informations received: " + p.getId());
sendInGamePlayersInfos(np.getId());
notifyToAllOtherPlayers(np, np.getId());

cat.info("END of the NEW PLAYER TREATMENT");
cat.info("*****************************************");
}
else if (o instanceof UpdatePlayer){

UpdatePlayer updp = (UpdatePlayer) o;
cat.info("*****************************************");
cat.info("BEGIN of the Update PLAYER TREATMENT");
cat.info("Object Update Player received:");
cat.info("ID: " + updp.getId());
cat.info("X: " + updp.getX());
cat.info("Y: " + updp.getY());
cat.info("SpeedX: " + updp.getSpeedX());
cat.info("SpeedY: " + updp.getSpeedY());

p = (Player) playersTable.get(""+updp.getId());
//p = players[updp.getId()];

if (p!=null){

// Speed and Position Update of the player updp
p.setX(updp.getX());
p.setY(updp.getY());
p.setSpeedX(updp.getSpeedX());
p.setSpeedY(updp.getSpeedY());
notifyToAllOtherPlayers(updp, updp.getId());
}

cat.info("END of the Update PLAYER TREATMENT");
cat.info("*****************************************");
}
else if (o instanceof PingPlayer){
PingPlayer pp = (PingPlayer) o;
cat.info("*****************************************");
cat.info("BEGIN of the Ping PLAYER TREATMENT");
cat.info("Object Ping Player received:");
cat.info("ID Ping: " + pp.getId());
cat.info("Counter " + pp.getPingNum());

// timestamping
pp.setTimestamp(System.currentTimeMillis());

notifyToAllOtherPlayers (pp, pp.getId());
// add to each other players
addPingMessageToEachOtherPlayers(pp);

// send to player each other players pings
sendEachOtherPlayersPings(pp.getId(), System.currentTimeMillis());
cat.info("END of the ping PLAYER TREATMENT");
cat.info("*****************************************");
}
}

private void sendEachOtherPlayersPings(int id, long time) {

Enumeration enume=htPlayerPing.keys();
while (enume.hasMoreElements()){
short pid = Short.parseShort((String) enume.nextElement());
PingPlayer ppl = (PingPlayer) htPlayerPing.get(""+pid);
int desync = (int)(time -ppl.getTimestamp());
ppl.setDesynchronizationWithSender(desync);
}
sendMessagesToPlayer (htPlayerPing,id);
if (!htPlayerPing.isEmpty()){
short pid = Short.parseShort((String) enume.nextElement());
PingPlayer ppl = (PingPlayer) htPlayerPing.get(""+pid);
htPlayerPing.remove(ppl);
}
}
/* Vector v = pings[id];

if (v!=null && !v.isEmpty()){
for(Iterator iter = v.iterator(); iter.hasNext();){
PingPlayer ppl = (PingPlayer) iter.next();

// compute desynchronisation with ping sender
int desync = (int)(time - ppl.getTimestamp());
ppl.setDesynchronizationWithSender(desync);
}

// send all updated pings to the player
sendMessagesToPlayer(v, id);
v.removeAllElements();
}
}*/

/**
* Add a PingPlayer object to vectors of each other players
*
* @param ppl the PingPlayer object to store
*/
private void addPingMessageToEachOtherPlayers(PingPlayer ppl){
Enumeration enume = htPlayerPing.keys();
while (enume.hasMoreElements()){
Hashtable playerPing = new Hashtable();
short pid = Short.parseShort((String) enume.nextElement());
while (enume.hasMoreElements()){
if (pid != ppl.getId()){
playerPing.put(""+pid,ppl);
}
}
htPlayerPing.put(""+pid,playerPing);
}

}

/*Vector v = null;
for(int i = 1; i <= maxActor; i++){
// each other players
if (i != ppl.getId()){
// add PingPlayer object to selected player vector
v = pings[i];
v.addElement(ppl);
}
}
}*/

/**
* Sending to the player (aSID) the object ErrorMessage with the type type
*
* @param type
* @param aSID
*/

private void sendErrorMessage(byte type, int aSID) {

cat.debug("Error message sended, type: " + type);
}

/**
* Send to the player (idJoiner) a newPlayer message for each player in game,
* whose all informations were recovered.
* Only automatic mode
*
* @param idJoiner
*/

private void sendInGamePlayersInfos(int idJoiner) {
// synchronized (monitorActors){
cat.debug("sendInGamePlayersInfos called");
Hashtable h = new Hashtable();
int nbObj = 0;
Player p = null;
showPlayers();

// Build a newPlayer message to all players already in game and add in the hashtable.
Enumeration enume = playersTable.keys();
while (enume.hasMoreElements()){
short pid = Short.parseShort((String) enume.nextElement());
if (idJoiner != pid){
p = (Player) playersTable.get(""+pid);
cat.debug("playerAimed(" + idJoiner + ") playerInfos(" + pid
+ ")");

// new player message to send to idJoiner
NewPlayer np = new NewPlayer();
np.setId((short) p.getId());
np.setX(p.getX());
np.setY(p.getY());
np.setUsername(p.getUsername());
h.put(""+nbObj,np);

nbObj++;
cat.debug("NEW PLAYER message added to"+ idJoiner
+ ": player n?"+ p.getId());
}
}
/*for (int i = 1; i < players.length; i++) {
if (players[i] != null){
if (idJoiner != i) {
p = players[i];
cat.debug("playerAimed(" + idJoiner + ") playerInfos(" + i
+ ")");

//newplayer message to send to idjoiner
NewPlayer np = new NewPlayer();
np.setId((short) p.getId());
np.setX(p.getX());
np.setY(p.getY());
np.setUsername(p.getUsername());
h.put(""+nbObj, np);

nbObj++;
cat.debug("NEW PLAYER message added to " + idJoiner
+ ": player n?" + p.getId());

}
}
}*/

// Build a dataEvent if some newPlayer messages have to be sent.
if (!h.isEmpty()) {
DataEvent de = new DataEventImpl(0, h);
cat.debug("SendDataTo player>" + idJoiner + " de>" + de);
this.sendDataTo(idJoiner, de);
}
// }
}

/**
* Sending a Message Object to all players
* @param o
*
*/
private void notifyToAllPlayers(Object o) {
cat.debug("notifyAllPlayers called");
Hashtable h = new Hashtable();
h.put("0", o);

DataEvent de = new DataEventImpl(0, h);
showPlayers();

Enumeration enume= playersTable.keys();
while (enume.hasMoreElements()){
short pid = Short.parseShort((String) enume.nextElement());
this.sendDataTo(pid,de);
if (o instanceof NewPlayer)
cat.debug("Message NewPlayer sent to aSID");
else if (o instanceof UpdatePlayer)
cat.debug("Message UpdatePlayer sent to aSID");
else if (o instanceof PingPlayer)
cat.debug("Message PingPlayer sent to aSID");
}
/* for (int i = 1; i < players.length; i++){
if (players[i] != null) {
this.sendDataTo(i, de);
if (o instanceof NewPlayer)
cat.debug("Message NewPlayer sent to aSID");
else if (o instanceof UpdatePlayer)
cat.debug("Message UpdatePlayer sent to aSID");
}
}*/
}

/**
* Sending a Message object to each player but not to the sender.
*
* @param o, idSender
*/
private void notifyToAllOtherPlayers(Object o, int idSender) {
cat.debug("notifyAllOtherPlayers called");
Hashtable h = new Hashtable();
h.put("0", o);

DataEvent de = new DataEventImpl(0, h);
showPlayers();

Enumeration enume= playersTable.keys();
while (enume.hasMoreElements()){
short pid = Short.parseShort((String) enume.nextElement());
if ((idSender != pid)){
this.sendDataTo(pid,de);
if (o instanceof NewPlayer)
cat.debug(" Message NewPlayer sent to aSID");
else if ( o instanceof UpdatePlayer)
cat.debug(" Message UpdatePlayer sent to aSID");
else if (o instanceof PingPlayer)
cat.debug(" Message PingPlayer sent to aSID");
}
}

/*for (int i = 1; i < players.length; i++) {
if ((idSender != i) && (players[i] != null)) {
this.sendDataTo(i, de);
if (o instanceof NewPlayer)
cat.debug("Message NewPlayer sent to aSID");
else if (o instanceof UpdatePlayer)
cat.debug("Message UpdatePlayer sent to aSID");
else if (o instanceof PingPlayer)
cat.debug("Message PingPlayer sent to aSID");

}
}*/
}

/**
* Sending a Message object to a specific player.
*
* @param o, playerASID
*/
private void sendMessageToPlayer(Object o, int playerASID) {
cat.debug("sendMessageToPlayer called");
Hashtable h = new Hashtable();
h.put("0", o);

DataEvent de = new DataEventImpl(0, h);
this.sendDataTo(playerASID, de);
}

/**
* Sending a Message to a specific player.
*
* @param v, playerASID
*/
private void sendMessagesToPlayer(Hashtable ht /*Vector v*/, int playerASID) {
cat.debug("sendMessageToPlayer called");
Hashtable h = new Hashtable();

int count = 0;
Enumeration enume = ht.keys();
while (enume.hasMoreElements()){
short pid = Short.parseShort((String) enume.nextElement());
h.put(""+count,ht.get(""+pid));
count++;
}
/*for(Iterator iter = v.iterator(); iter.hasNext();){
h.put(""+count, iter.next());
count++;
}*/
DataEvent de = new DataEventImpl(0, h);
this.sendDataTo(playerASID, de);
}

/**
* Show players state
*
*/
private void showPlayers() {
Enumeration enume= playersTable.keys();
while (enume.hasMoreElements()){
short pid = Short.parseShort((String)enume.nextElement());
cat.debug("playersTable key{"+ pid+"} = "+ playersTable.get(""+pid));
}
/*for (int i = 0; i < players.length; i++) {
cat.debug("players[" + i + "]=" + players[i]);
}*/
}
}

Aidez moi SVP

Comment executer j2se server sur eclipse

1 réponse

Votre réponse

Discussions similaires

Newsletters