1 package net.sourceforge.simplegamenet.framework.model;
2
3 import java.io.IOException;
4 import java.io.Serializable;
5 import net.sourceforge.simplegamenet.framework.gui.ServerGUIFacade;
6 import net.sourceforge.simplegamenet.framework.transport.LoginData;
7 import net.sourceforge.simplegamenet.framework.transport.ServerModem;
8 import net.sourceforge.simplegamenet.specs.model.GameFactory;
9 import net.sourceforge.simplegamenet.specs.model.GameServer;
10 import net.sourceforge.simplegamenet.specs.model.ServerEngine;
11 import net.sourceforge.simplegamenet.specs.to.GameSettings;
12 import net.sourceforge.simplegamenet.specs.to.PlayerSettings;
13 import net.sourceforge.simplegamenet.specs.to.PlayerSettingsMap;
14
15 public class ServerEngineImpl extends EngineImpl implements ServerEngine {
16
17 private ServerGUIFacade serverGUIFacade;
18 private ServerModem serverModem;
19
20 private ChatServer chatServer;
21 private GameServer gameServer;
22
23 private Integer nextPlayerID = new Integer(0x00000001);
24
25 public ServerEngineImpl(ServerGUIFacade serverGUIFacade, int port,
26 boolean badLanguageFiltered, GameFactory gameFactory,
27 GameSettings gameSettings) throws IOException {
28 super(gameFactory, gameSettings, new PlayerSettingsMap());
29 this.serverGUIFacade = serverGUIFacade;
30 serverModem = new ServerModem(this, port);
31 chatServer = new ChatServer(this, badLanguageFiltered);
32 gameServer = gameFactory.createGameServer(this);
33 }
34
35
36
37
38
39
40
41
42
43
44 public boolean receiveChatMessage(Integer playerID, ChatMessage chatMessage) {
45 if (isGamePlaying()
46 && !playerSettingsMap.getPlayerSettings(playerID)
47 .isChattingAllowedDuringGame()) {
48 return true;
49 }
50 chatServer.receiveChatMessage(playerID, chatMessage);
51 return false;
52 }
53
54 public void sendChatMessage(Integer playerID, ChatMessage chatMessage) {
55 serverModem.sendChatMessage(playerID, chatMessage);
56 }
57
58 public void sendChatMessage(ChatMessage chatMessage) {
59 serverModem.sendChatMessage(chatMessage);
60 }
61
62 public void appendGameChatMessage(Integer playerID, String message) {
63 if (!playerSettingsMap.containsPlayerSettings(playerID)) {
64 throw new IllegalArgumentException("Invalid playerID: " + playerID);
65 }
66 chatServer.appendGameChatMessage(playerID, message);
67 }
68
69 public void appendGameChatMessage(String message) {
70 chatServer.appendGameChatMessage(message);
71 }
72
73 public void changeGameSettings(GameSettings changedGameSettings)
74 throws IllegalStateException, IllegalArgumentException {
75 if (isGamePlaying()) {
76 throw new IllegalStateException();
77 }
78 changedGameSettings.setEngine(this);
79 GameSettings currentGameSettings = gameSettings;
80 if (!currentGameSettings.isChangeGameSettingsAllowed(changedGameSettings)) {
81 throw new IllegalArgumentException();
82 }
83 gameSettings = changedGameSettings;
84 serverModem.updateGameSettings(gameSettings);
85 gameServer.gameSettingsUpdated(currentGameSettings, changedGameSettings);
86 serverGUIFacade.gameSettingsUpdated(gameSettings);
87 }
88
89 public void refreshGameSettings() {
90 serverModem.updateGameSettings(gameSettings);
91 serverGUIFacade.gameSettingsUpdated(gameSettings);
92 }
93
94 public LoginData createPlayer(int playerType, String nickname)
95 throws IllegalStateException {
96 Integer playerID = nextPlayerID;
97 nextPlayerID = new Integer(nextPlayerID.intValue() + 1);
98 nickname = chatServer.filterNickname(nickname);
99 if (!gameSettings.isCreateDefaultPlayerSettingsAllowed(playerType)) {
100 throw new IllegalStateException();
101 }
102 PlayerSettings playerSettings = gameSettings.createDefaultPlayerSettings(playerID,
103 playerType, nickname);
104 playerSettingsMap.addPlayerSettings(playerSettings);
105 return new LoginData(playerID, gameSettings,
106 playerSettingsMap.getPlayerSettingsArray(), gameState);
107 }
108
109 public void playerAdded(Integer playerID) {
110 PlayerSettings playerSettings = playerSettingsMap.getPlayerSettings(playerID);
111 gameServer.playerAdded(playerSettings);
112 serverGUIFacade.playerAdded(playerSettingsMap, playerSettings);
113 }
114
115 public void changePlayerSettings(PlayerSettings changedPlayerSettings)
116 throws IllegalStateException, IllegalArgumentException {
117 if (isGamePlaying()) {
118 throw new IllegalStateException();
119 }
120 changedPlayerSettings.setEngine(this);
121 changedPlayerSettings.setNickname(chatServer.filterNickname(
122 changedPlayerSettings.getNickname()));
123 PlayerSettings currentPlayerSettings = playerSettingsMap.getPlayerSettings(
124 changedPlayerSettings.getPlayerID());
125 if (changedPlayerSettings == null
126 || !gameSettings.isChangePlayerSettingsAllowed(currentPlayerSettings,
127 changedPlayerSettings)
128 || !currentPlayerSettings.getPlayerID().equals(changedPlayerSettings.getPlayerID())
129 || currentPlayerSettings.getPlayerType()
130 != changedPlayerSettings.getPlayerType()
131 || !currentPlayerSettings.isChangePlayerSettingsAllowed(changedPlayerSettings)
132 ) {
133 throw new IllegalArgumentException();
134 }
135 playerSettingsMap.updatePlayerSettings(changedPlayerSettings);
136 serverModem.updatePlayerSettings(changedPlayerSettings);
137 gameServer.playerSettingsUpdated(currentPlayerSettings,
138 changedPlayerSettings);
139 serverGUIFacade.playerSettingsUpdated(playerSettingsMap, changedPlayerSettings);
140 }
141
142 public void refreshPlayerSettings(Integer playerID) throws IllegalArgumentException {
143 PlayerSettings changedPlayerSettings = playerSettingsMap
144 .getPlayerSettings(playerID);
145 if (changedPlayerSettings == null) {
146 throw new IllegalArgumentException("Invalid playerID: " + playerID);
147 }
148 serverModem.updatePlayerSettings(changedPlayerSettings);
149 serverGUIFacade.playerSettingsUpdated(playerSettingsMap, changedPlayerSettings);
150 }
151
152 public void kickPlayer(Integer playerID) {
153 serverModem.kickPlayer(playerID);
154 }
155
156 public void banPlayer(Integer playerID) {
157 serverModem.banPlayer(playerID);
158 }
159
160 public void kickProtocolViolatingPlayer(Integer playerID)
161 throws IllegalArgumentException {
162 serverModem.kickProtocolViolatingPlayer(playerID);
163 }
164
165 public void removePlayer(Integer playerID, int removePlayerType) {
166 PlayerSettings playerSettings = playerSettingsMap.removePlayerSettings(playerID);
167 gameServer.playerRemoved(playerSettings);
168 serverGUIFacade.removePlayer(playerSettingsMap, playerSettings, removePlayerType);
169 }
170
171 public void startGame() throws IllegalStateException {
172 if (isGamePlaying() || !gameSettings.isStartGameAllowed()) {
173 throw new IllegalStateException();
174 }
175 gameState = GAME_PLAYING;
176 serverModem.gameStarted();
177 gameServer.gameStarted();
178 serverGUIFacade.gameStarted();
179 }
180
181 public void receiveData(Integer playerID, Serializable data) {
182 if (isGamePlaying()) {
183 gameServer.receiveData(playerID, data);
184 }
185 }
186
187 public void sendData(Integer playerID, Serializable data)
188 throws IllegalArgumentException {
189 if (isGamePlaying()) {
190 serverModem.sendData(playerID, data);
191 }
192 }
193
194 public void sendData(Serializable data) {
195 if (isGamePlaying()) {
196 serverModem.sendData(data);
197 }
198 }
199
200 public void stopGame() {
201 if (isGamePlaying()) {
202 gameState = GAME_STOPPING;
203 serverGUIFacade.gameStopping();
204 serverModem.gameStopping();
205 }
206 }
207
208 public void abortGame() throws IllegalStateException {
209 if (isGamePlaying()) {
210 gameServer.gameAborting();
211 gameState = GAME_ABORTING;
212 serverGUIFacade.gameAborting();
213 serverModem.gameAborting();
214 }
215 }
216
217 public void gameEnded() {
218 gameState = GAME_NOT_PLAYING;
219 serverGUIFacade.gameEnded();
220 }
221
222 public void closeServerInServerThread() {
223 serverModem.closeServerInServerThread();
224 }
225
226 public void hostedGameQuit() {
227 gameServer.close();
228 serverGUIFacade.hostedGameQuit();
229 }
230
231 }