1 package net.sourceforge.simplegamenet.framework.model;
2
3 import java.io.Serializable;
4 import net.sourceforge.simplegamenet.framework.gui.ClientGUIFacade;
5 import net.sourceforge.simplegamenet.framework.transport.ClientConnectionData;
6 import net.sourceforge.simplegamenet.framework.transport.ClientModem;
7 import net.sourceforge.simplegamenet.specs.model.ClientEngine;
8 import net.sourceforge.simplegamenet.specs.model.GamePlayerClient;
9 import net.sourceforge.simplegamenet.specs.to.GameSettings;
10 import net.sourceforge.simplegamenet.specs.to.PlayerSettings;
11 import net.sourceforge.simplegamenet.specs.to.PlayerSettingsMap;
12
13 public class ClientEngineImpl extends EngineImpl implements ClientEngine {
14
15 private ClientGUIFacade clientGUIFacade;
16 private ClientModem clientModem;
17
18 private Integer playerID;
19
20 private GamePlayerClient gamePlayerClient;
21
22 public ClientEngineImpl(ClientGUIFacade clientGUIFacade,
23 ClientConnectionData clientConnectionData) {
24 super(clientConnectionData.getGameFactory(),
25 clientConnectionData.getLoginData().getGameSettings(),
26 null);
27 this.playerSettingsMap = new PlayerSettingsMap(this,
28 clientConnectionData.getLoginData().getPlayerSettingsArray());
29 this.clientGUIFacade = clientGUIFacade;
30 this.playerID = clientConnectionData.getLoginData().getPlayerID();
31 gameState = clientConnectionData.getLoginData().getGameState();
32 clientModem = new ClientModem(this, clientConnectionData.getSocket(),
33 clientConnectionData.getObjectInputStream(),
34 clientConnectionData.getObjectOutputStream());
35 gamePlayerClient = gameFactory.createGamePlayerClient(this);
36 }
37
38
39
40
41
42
43
44 public void receiveChatMessage(ChatMessage chatMessage) {
45 switch (chatMessage.getType()) {
46 case ChatMessage.SYSTEM_MESSAGE:
47 case ChatMessage.GAME_MESSAGE:
48 clientGUIFacade.receiveChatMessage(chatMessage.getType(),
49 chatMessage.getMessage());
50 break;
51 case ChatMessage.PLAYER_MESSAGE:
52 case ChatMessage.PLAYER_EMOTE:
53 clientGUIFacade.receiveChatMessage(chatMessage.getType(),
54 chatMessage.getMessage(),
55 playerSettingsMap.getPlayerSettings(chatMessage.getPlayerID())
56 .getNickname());
57 break;
58 }
59 }
60
61 public void sendChatMessage(int type, String message) throws IllegalStateException {
62 if (isGamePlaying()
63 && !playerSettingsMap.getPlayerSettings(playerID)
64 .isChattingAllowedDuringGame()) {
65 throw new IllegalStateException();
66 }
67 clientModem.sendChatMessage(new ChatMessage(type, message, playerID));
68 }
69
70 public void changeGameSettings(GameSettings changedGameSettings)
71 throws IllegalStateException, IllegalArgumentException {
72 if (isGamePlaying()) {
73 throw new IllegalStateException();
74 }
75 changedGameSettings.setEngine(this);
76 GameSettings currentGameSettings = gameSettings;
77 if (!currentGameSettings.isChangeGameSettingsAllowed(changedGameSettings)) {
78 throw new IllegalArgumentException();
79 }
80 clientModem.changeGameSettings(changedGameSettings);
81 }
82
83 public void updateGameSettings(GameSettings updatedGameSettings) {
84 updatedGameSettings.setEngine(this);
85 GameSettings outdatedGameSettings = gameSettings;
86 gameSettings = updatedGameSettings;
87 gamePlayerClient.gameSettingsUpdated(outdatedGameSettings, updatedGameSettings);
88 clientGUIFacade.gameSettingsUpdated(outdatedGameSettings, updatedGameSettings);
89 }
90
91 public void addPlayer(PlayerSettings playerSettings) {
92 playerSettings.setEngine(this);
93 playerSettingsMap.addPlayerSettings(playerSettings);
94 gamePlayerClient.playerAdded(playerSettings);
95 clientGUIFacade.playerAdded(playerSettingsMap, playerSettings);
96 }
97
98 public void changePlayerSettings(PlayerSettings changedPlayerSettings)
99 throws IllegalStateException, IllegalArgumentException {
100 if (isGamePlaying()) {
101 throw new IllegalStateException();
102 }
103 changedPlayerSettings.setEngine(this);
104 PlayerSettings currentPlayerSettings = playerSettingsMap.getPlayerSettings(
105 changedPlayerSettings.getPlayerID());
106 if (!gameSettings.isChangePlayerSettingsAllowed(currentPlayerSettings,
107 changedPlayerSettings)
108 || !currentPlayerSettings.getPlayerID().equals(changedPlayerSettings.getPlayerID())
109 || currentPlayerSettings.getPlayerType() != changedPlayerSettings.getPlayerType()
110 || !currentPlayerSettings.isChangePlayerSettingsAllowed(changedPlayerSettings)) {
111 throw new IllegalArgumentException();
112 }
113 clientModem.changePlayerSettings(changedPlayerSettings);
114 }
115
116 public void updatePlayerSettings(PlayerSettings updatedPlayerSettings) {
117 updatedPlayerSettings.setEngine(this);
118 PlayerSettings outdatedPlayerSettings = playerSettingsMap.getPlayerSettings(
119 updatedPlayerSettings.getPlayerID());
120 playerSettingsMap.updatePlayerSettings(updatedPlayerSettings);
121 gamePlayerClient.playerSettingsUpdated(outdatedPlayerSettings,
122 updatedPlayerSettings);
123 clientGUIFacade.playerSettingsUpdated(playerSettingsMap, outdatedPlayerSettings,
124 updatedPlayerSettings);
125 }
126
127 public void removePlayer(Integer playerID, int removePlayerType) {
128 PlayerSettings playerSettings = playerSettingsMap.removePlayerSettings(playerID);
129 gamePlayerClient.playerRemoved(playerSettings);
130 clientGUIFacade.removePlayer(playerSettingsMap, playerSettings, removePlayerType);
131 }
132
133 public void startGame() throws IllegalStateException {
134 if (isGamePlaying() || !gameSettings.isStartGameAllowed()) {
135 throw new IllegalStateException();
136 }
137 gameState = GAME_STARTING;
138 clientModem.startGame();
139 }
140
141 public void gameStarted() {
142 gameState = GAME_PLAYING;
143 gamePlayerClient.gameStarted();
144 clientGUIFacade.gameStarted();
145 }
146
147 public void receiveData(Serializable data) {
148 if (isGamePlaying()) {
149 gamePlayerClient.receiveData(data);
150 }
151 }
152
153 public void sendData(Serializable data) {
154 if (isGamePlaying()) {
155 clientModem.sendData(data);
156 }
157 }
158
159 public void abortGame() throws IllegalStateException {
160 if (!isGamePlaying()) {
161 throw new IllegalStateException();
162 }
163 gameState = GAME_ABORTING;
164 clientModem.abortGame();
165 }
166
167 public void gameStopping() {
168 gameState = GAME_STOPPING;
169 gamePlayerClient.gameStopping();
170 clientGUIFacade.gameStopping();
171 }
172
173 public void gameAborting() {
174 gameState = GAME_ABORTING;
175 gamePlayerClient.gameAborting();
176 clientGUIFacade.gameAborting();
177 }
178
179 public void gameEnded() {
180 gameState = GAME_NOT_PLAYING;
181 gamePlayerClient.gameEnded();
182 clientGUIFacade.gameEnded();
183 }
184
185 public void leaveServer() {
186 clientModem.leaveServer();
187 }
188
189 public void leaveProtocolViolatingServer() {
190 clientModem.leaveProtocolViolatingServer();
191 }
192
193 public void joinedGameQuit(int removePlayerType) {
194 gamePlayerClient.close();
195 clientGUIFacade.joinedGameQuit(removePlayerType);
196 }
197
198 public GamePlayerClient getGamePlayerClient() {
199 return gamePlayerClient;
200 }
201
202 public Integer getPlayerID() {
203 return playerID;
204 }
205
206 public PlayerSettings getPlayerSettings() {
207 return playerSettingsMap.getPlayerSettings(playerID);
208 }
209
210 }