();
705 | for(Agent agent:agentList){
706 | if(getRole(agent).getTeam() == team){
707 | resultList.add(agent);
708 | }
709 | }
710 | return resultList;
711 | }
712 |
713 |
714 |
715 |
716 | public int nextTalkIdx() {
717 | return talkIdx++;
718 | }
719 |
720 | public int nextWhisperIdx() {
721 | return wisperIdx++;
722 | }
723 |
724 | /**
725 | * 昨夜人狼に襲われ死亡したエージェントを返す．
726 | *
727 | * Returns the agent who died last night because of the attack by werewolf.
728 | *
729 | * @return the attackedDead
730 | */
731 | public Agent getAttackedDead() {
732 | return attackedDead;
733 | }
734 |
735 | /**
736 | * 昨夜人狼に襲われ死亡したエージェントをセットする．
737 | *
738 | * Sets the agent who died last night because of the attack by werewolf.
739 | *
740 | * @param attackedDead
741 | * the attackedDead to set
742 | */
743 | public void setAttackedDead(Agent attackedDead) {
744 | this.attackedDead = attackedDead;
745 | }
746 |
747 | /**
748 | * 呪殺された妖狐を返す．
749 | *
750 | * Returns the fox killed by curse.
751 | *
752 | * @return 呪殺された妖狐
753 | *
754 | * the fox killed by curse
755 | */
756 | public Agent getCursedFox() {
757 | return cursedFox;
758 | }
759 |
760 | /**
761 | * 呪殺された妖狐をセットする．
762 | *
763 | * Sets the fox killed by curse.
764 | *
765 | * @param cursedFox
766 | * 呪殺された妖狐
767 | *
768 | * the fox killed by curse
769 | */
770 | public void setCursedFox(Agent cursedFox) {
771 | this.cursedFox = cursedFox;
772 | }
773 |
774 | /**
775 | * 直近の投票リストを返す
776 | *
777 | * Returns the latest list of votes.
778 | *
779 | * @return 投票リストを表す{@code List}
780 | *
781 | * {@code List} representing the list of votes.
782 | */
783 | public List getLatestVoteList() {
784 | return latestVoteList;
785 | }
786 |
787 | /**
788 | * 直近の投票リストをセットする
789 | *
790 | * Sets the latest list of votes.
791 | *
792 | * @param latestVoteList
793 | * 投票リストを表す{@code List}
794 | *
795 | * {@code List} representing the list of votes.
796 | *
797 | */
798 | public void setLatestVoteList(List latestVoteList) {
799 | this.latestVoteList = latestVoteList;
800 | }
801 |
802 | /**
803 | * 直近の襲撃投票リストを返す
804 | *
805 | * Returns the latest list of votes for attack.
806 | *
807 | * @return 投票リストを表す{@code List}
808 | *
809 | * {@code List} representing the list of votes.
810 | */
811 | public List getLatestAttackVoteList() {
812 | return latestAttackVoteList;
813 | }
814 |
815 | /**
816 | * 直近の襲撃投票リストをセットする
817 | *
818 | * Sets the latest list of votes for attack.
819 | *
820 | * @param latestAttackVoteList
821 | * 投票リストを表す{@code List}
822 | *
823 | * {@code List} representing the list of votes.
824 | *
825 | */
826 | public void setLatestAttackVoteList(List latestAttackVoteList) {
827 | this.latestAttackVoteList = latestAttackVoteList;
828 | }
829 |
830 | /**
831 | *
832 | * 指定エージェントがゲームに含まれているかどうかを調べる
833 | *
834 | * Check whether the agents is joining in game.
835 | *
836 | * @param latestAttackVoteList
837 | * 含まれているかどうか{@code boolean}
838 | *
839 | * {@code boolean} is contains in the game.
840 | */
841 | public boolean contains(Agent target) {
842 | return this.agentRoleMap.containsKey(target);
843 | }
844 |
845 | }
846 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/IllegalPlayerNumException.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server;
2 |
3 | import org.aiwolf.common.AIWolfRuntimeException;
4 |
5 | public class IllegalPlayerNumException extends AIWolfRuntimeException {
6 |
7 | public IllegalPlayerNumException() {
8 | super();
9 | }
10 |
11 | public IllegalPlayerNumException(String arg0, Throwable arg1, boolean arg2,
12 | boolean arg3) {
13 | super(arg0, arg1, arg2, arg3);
14 | }
15 |
16 | public IllegalPlayerNumException(String arg0, Throwable arg1) {
17 | super(arg0, arg1);
18 | }
19 |
20 | public IllegalPlayerNumException(String arg0) {
21 | super(arg0);
22 | }
23 |
24 | public IllegalPlayerNumException(Throwable arg0) {
25 | super(arg0);
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/LostClientException.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server;
2 |
3 | import org.aiwolf.common.AIWolfRuntimeException;
4 | import org.aiwolf.common.data.Agent;
5 |
6 | /**
7 | * throws when the cliend connection is lost
8 | * @author tori
9 | *
10 | */
11 | public class LostClientException extends AIWolfRuntimeException {
12 |
13 | Agent agent;
14 |
15 | // public LostClientException() {
16 | // }
17 | //
18 | // public LostClientException(String arg0) {
19 | // super(arg0);
20 | // }
21 |
22 | public LostClientException(Throwable arg0, Agent agent) {
23 | super(arg0);
24 | this.agent = agent;
25 | }
26 |
27 | // public LostClientException(Throwable arg0) {
28 | // super(arg0);
29 | // }
30 |
31 | // public LostClientException(String arg0, Throwable arg1) {
32 | // super(arg0, arg1);
33 | // }
34 | //
35 | // public LostClientException(String arg0, Throwable arg1, boolean arg2,
36 | // boolean arg3) {
37 | // super(arg0, arg1, arg2, arg3);
38 | // }
39 |
40 | public LostClientException(String arg0, Throwable arg1, Agent agent) {
41 | super(arg0, arg1);
42 | this.agent = agent;
43 | }
44 |
45 | /**
46 | * @return agent
47 | */
48 | public Agent getAgent() {
49 | return agent;
50 | }
51 |
52 | /**
53 | * @param agent セットする agent
54 | */
55 | public void setAgent(Agent agent) {
56 | this.agent = agent;
57 | }
58 |
59 |
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/bin/DirectStarter.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.bin;
2 |
3 | import java.io.File;
4 | import java.io.IOException;
5 | import java.util.ArrayList;
6 |
7 | import java.util.List;
8 | import java.util.Map;
9 | import java.util.Random;
10 |
11 | import org.aiwolf.common.bin.ClientStarter;
12 | import org.aiwolf.common.data.Player;
13 | import org.aiwolf.common.net.GameSetting;
14 | import org.aiwolf.common.util.CalendarTools;
15 | import org.aiwolf.common.util.Counter;
16 | import org.aiwolf.server.AIWolfGame;
17 | import org.aiwolf.server.net.DirectConnectServer;
18 | import org.aiwolf.server.net.GameServer;
19 |
20 | /**
21 | * クライアントを指定して直接シミュレーションを実行する
22 | * @author tori
23 | * @deprecated
24 | */
25 | public class DirectStarter {
26 |
27 | /**
28 | * @param args
29 | * @throws ClassNotFoundException
30 | * @throws IllegalAccessException
31 | * @throws InstantiationException
32 | * @throws IOException
33 | */
34 | public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException {
35 | Counter clsCountMap = new Counter();
36 | String logDir = "./log/";
37 | for(int i = 0; i < args.length; i++){
38 | if(args[i].startsWith("-")){
39 | if(args[i].equals("-c")){
40 | i++;
41 | String clsName = args[i];
42 | i++;
43 | int num = Integer.parseInt(args[i]);
44 |
45 | clsCountMap.put(clsName, num);
46 | }
47 | else if(args[i].equals("-l")){
48 | i++;
49 | logDir = args[i];
50 | }
51 | }
52 | }
53 | if(clsCountMap.isEmpty()){
54 | System.err.println("Usage:"+ClientStarter.class+" -c clientClass num [-c clientClass num ...] [-l logDir]");
55 | return;
56 | }
57 |
58 |
59 | start(clsCountMap, logDir);
60 | }
61 |
62 | /**
63 | *
64 | * @param clsCountMap
65 | * @param logDir
66 | * @throws InstantiationException
67 | * @throws IllegalAccessException
68 | * @throws ClassNotFoundException
69 | * @throws IOException
70 | */
71 | public static void start(Counter clsCountMap, String logDir) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException {
72 | int playerNum = clsCountMap.getTotalCount();
73 | List playerList = new ArrayList();
74 | // for(int i = 0; i < playerNum; i++){
75 | // playerList.add((Player) Class.forName(clsName).newInstance());
76 | // }
77 | for(String clsName:clsCountMap){
78 | int num = clsCountMap.get(clsName);
79 | for(int i = 0; i < num; i++){
80 | playerList.add((Player) Class.forName(clsName).newInstance());
81 | }
82 | }
83 |
84 | String timeString = CalendarTools.toDateTime(System.currentTimeMillis()).replaceAll("[\\s-/:]", "");
85 | File logFile = new File(String.format("%s/aiwolfGame%s.log", logDir, timeString));
86 |
87 | GameServer gameServer = new DirectConnectServer(playerList);
88 | GameSetting gameSetting = GameSetting.getDefaultGame(playerNum);
89 | AIWolfGame game = new AIWolfGame(gameSetting, gameServer);
90 | // game.setLogFile(logFile);
91 | game.setRand(new Random(gameSetting.getRandomSeed()));
92 | // game.init();
93 | game.start();
94 | // game.finish();
95 | }
96 |
97 | }
98 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/bin/RoleRequestStarter.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.bin;
2 |
3 | import java.io.File;
4 | import java.io.IOException;
5 | import java.util.ArrayList;
6 | import java.util.HashMap;
7 | import java.util.LinkedHashMap;
8 | import java.util.List;
9 | import java.util.Map;
10 | import java.util.Random;
11 |
12 | import org.aiwolf.common.data.Player;
13 | import org.aiwolf.common.data.Role;
14 | import org.aiwolf.common.net.GameSetting;
15 | import org.aiwolf.common.util.CalendarTools;
16 | import org.aiwolf.common.util.Pair;
17 | import org.aiwolf.server.AIWolfGame;
18 | import org.aiwolf.server.net.DirectConnectServer;
19 | import org.aiwolf.server.util.GameLogger;
20 |
21 | /**
22 | * 役割を指定してスタートするStarter
23 | * DirectStarter
24 | * @author tori
25 | * @deprecated
26 | */
27 | public class RoleRequestStarter {
28 |
29 | static final private String description =
30 | "このクラスを利用して，自作Playerごとに役職を決めてゲームをスタートできます．\n" +
31 | "Usage:"+RoleRequestStarter.class+" -n agentNum -c playerClass role [-c playerClass role] [-d defaultPlayer]\n"+
32 | "-n\tゲームに参加するエージェント数を決定します．\n"+
33 | "-c 'プレイヤークラス' '設定したい役職' を設定します．\n"+
34 | "-c 'プレイヤークラス' で，役職を指定せずに利用するPlayerを指定します．\n"+
35 | "-d デフォルトのプレイヤークラスを指定します．指定しなければSamplePlayerが使われます．\n"+
36 | "-l ログを保存するディレクトリの指定．デフォルトは./log/\n"+
37 | "例えば，自作のorg.aiwolf.MyPlayerをbodyguardとして12体のエージェントで人狼を実行したければ\n"+
38 | RoleRequestStarter.class+" -n 12 -c org.aiwolf.MyPlayer bodyguard\n"+
39 | "としてください．\n";
40 |
41 | /**
42 | * @param args
43 | * @throws ClassNotFoundException
44 | * @throws IllegalAccessException
45 | * @throws InstantiationException
46 | * @throws IOException
47 | */
48 | public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException {
49 |
50 |
51 | List> playerRoleList = new ArrayList>();
52 | String defaultClsName = Class.forName("org.aiwolf.client.base.smpl.SampleRoleAssignPlayer").getName();
53 | int playerNum = -1;
54 | String logDir = "./log/";
55 | for(int i = 0; i < args.length; i++){
56 | if(args[i].startsWith("-")){
57 | if(args[i].equals("-c")){
58 | i++;
59 | String clsName = args[i];
60 | i++;
61 | try{
62 | if(i > args.length-1 || args[i].startsWith("-")){
63 | i--;
64 | playerRoleList.add(new Pair(clsName, null));
65 | continue;
66 | }
67 | Role role = Role.valueOf(args[i].toUpperCase());
68 | playerRoleList.add(new Pair(clsName, role));
69 | }catch(IllegalArgumentException e){
70 | System.err.println("No such role as "+args[i]);
71 | return;
72 | }
73 | }
74 | else if(args[i].equals("-n")){
75 | i++;
76 | playerNum = Integer.parseInt(args[i]);
77 | }
78 | else if(args[i].equals("-d")){
79 | i++;
80 | defaultClsName = args[i];
81 | }
82 | else if(args[i].equals("-l")){
83 | i++;
84 | logDir = args[i];
85 | }
86 | else if(args[i].equals("-h")){
87 | System.out.println(description);
88 | System.out.println("利用可能な役職");
89 | for(Role role:Role.values()){
90 | System.out.println(role);
91 | }
92 | }
93 | }
94 | }
95 | if(playerNum < 0){
96 | System.err.println("Usage:"+RoleRequestStarter.class+" -n agentNum -c playerClass role [-c playerClass role...] [-d defaultPlayer] [-l logDir]");
97 | return;
98 | }
99 |
100 |
101 | Map playerMap = new HashMap();
102 | for(Pair pair:playerRoleList){
103 | playerMap.put((Player) Class.forName(pair.getKey()).newInstance(), pair.getValue());
104 | }
105 | while(playerMap.size() < playerNum){
106 | playerMap.put((Player) Class.forName(defaultClsName).newInstance(), null);
107 | }
108 |
109 | start(playerMap, logDir);
110 | }
111 |
112 | /**
113 | * 一人のRoleを指定してDirectに実行
114 | * @param player
115 | * @param role
116 | * @param playerNum
117 | * @param defaultClsName
118 | * @param logDir
119 | * @throws InstantiationException
120 | * @throws IllegalAccessException
121 | * @throws ClassNotFoundException
122 | * @throws IOException
123 | */
124 | public static AIWolfGame start(Player player, Role role, int playerNum, String defaultClsName, String logDir) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException{
125 | Map playerMap = new LinkedHashMap();
126 |
127 | playerMap.put(player, role);
128 | while(playerMap.size() < playerNum){
129 | playerMap.put((Player) Class.forName(defaultClsName).newInstance(), null);
130 | }
131 | return start(playerMap, logDir);
132 | }
133 |
134 | /**
135 | * すべてのプレイヤーインスタンスとそのRoleを設定して開始
136 | * @param playerNum
137 | * @param playerMap
138 | * @param logDir
139 | * @throws IOException
140 | */
141 | public static AIWolfGame start(Map playerMap, String logDir) throws IOException {
142 | String timeString = CalendarTools.toDateTime(System.currentTimeMillis()).replaceAll("[\\s-/:]", "");
143 |
144 | DirectConnectServer gameServer = new DirectConnectServer(playerMap);
145 | GameSetting gameSetting = GameSetting.getDefaultGame(playerMap.size());
146 | AIWolfGame game = new AIWolfGame(gameSetting, gameServer);
147 | if(logDir != null){
148 | File logFile = new File(String.format("%s/contest%s.log", logDir, timeString));
149 | game.setLogFile(logFile);
150 | }
151 | game.setRand(new Random());
152 | // game.setShowConsoleLog(false);
153 | game.start();
154 | return game;
155 | }
156 |
157 | /**
158 | * すべてのプレイヤーインスタンスとそのRoleを設定して開始
159 | * @param playerNum
160 | * @param playerMap
161 | * @param logDir
162 | * @throws IOException
163 | */
164 | public static AIWolfGame start(Map playerMap, GameLogger logger) throws IOException {
165 | String timeString = CalendarTools.toDateTime(System.currentTimeMillis()).replaceAll("[\\s-/:]", "");
166 |
167 | DirectConnectServer gameServer = new DirectConnectServer(playerMap);
168 | GameSetting gameSetting = GameSetting.getDefaultGame(playerMap.size());
169 | AIWolfGame game = new AIWolfGame(gameSetting, gameServer);
170 | game.setGameLogger(logger);
171 | game.setRand(new Random());
172 | // game.setShowConsoleLog(false);
173 | game.start();
174 | return game;
175 | }
176 | }
177 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/bin/ServerStarter.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.bin;
2 | import java.io.File;
3 | import java.io.IOException;
4 | import java.net.SocketTimeoutException;
5 | import java.util.Random;
6 |
7 | import org.aiwolf.common.net.GameSetting;
8 | import org.aiwolf.server.AIWolfGame;
9 | import org.aiwolf.server.net.TcpipServer;
10 |
11 | /**
12 | * Main Class to start server application
13 | * @author tori
14 | *
15 | */
16 | public class ServerStarter {
17 |
18 | /**
19 | * @param args
20 | * @throws IOException
21 | * @throws SocketTimeoutException
22 | */
23 | public static void main(String[] args) throws SocketTimeoutException, IOException {
24 | int port = 10000;
25 | int playerNum = 12;
26 | String logFileName = null;
27 |
28 | for(int i = 0; i < args.length; i++){
29 | if(args[i].startsWith("-")){
30 | if(args[i].equals("-p")){
31 | i++;
32 | port = Integer.parseInt(args[i]);
33 | }
34 | else if(args[i].equals("-n")){
35 | i++;
36 | playerNum = Integer.parseInt(args[i]);
37 | }
38 | else if(args[i].equals("-l")){
39 | i++;
40 | logFileName = args[i];
41 | }
42 | }
43 | }
44 |
45 | System.out.printf("Start AiWolf Server port:%d playerNum:%d\n", port, playerNum);
46 | GameSetting gameSetting = GameSetting.getDefaultGame(playerNum);
47 |
48 | TcpipServer gameServer = new TcpipServer(port, playerNum, gameSetting);
49 | gameServer.waitForConnection();
50 |
51 | AIWolfGame game = new AIWolfGame(gameSetting, gameServer);
52 | game.setRand(new Random());
53 | if(logFileName != null){
54 | game.setLogFile(new File(logFileName));
55 | }
56 | game.start();
57 |
58 |
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/net/DirectConnectServer.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.net;
2 |
3 | import java.util.ArrayList;
4 | import java.util.HashMap;
5 | import java.util.LinkedHashMap;
6 | import java.util.List;
7 | import java.util.Map;
8 |
9 | import org.aiwolf.common.AIWolfAgentException;
10 | import org.aiwolf.common.data.Agent;
11 | import org.aiwolf.common.data.Player;
12 | import org.aiwolf.common.data.Role;
13 | import org.aiwolf.common.net.GameSetting;
14 | import org.aiwolf.server.GameData;
15 |
16 | /**
17 | * Connect player and server directry
18 | * @author tori
19 | * @deprecated
20 | */
21 | public class DirectConnectServer implements GameServer {
22 |
23 | /**
24 | * Agents connected to the server
25 | */
26 | protected Map agentPlayerMap;
27 |
28 | /**
29 | * Agents connected to the server
30 | */
31 | protected Map playerAgentMap;
32 |
33 |
34 | protected Map requestRoleMap;
35 |
36 |
37 | /**
38 | * GameData
39 | */
40 | protected GameData gameData;
41 |
42 | /**
43 | * Game Setting
44 | */
45 | protected GameSetting gameSetting;
46 |
47 | public DirectConnectServer(List playerList){
48 | agentPlayerMap = new LinkedHashMap();
49 | playerAgentMap = new LinkedHashMap();
50 | int idx = 1;
51 | for(Player player:playerList){
52 | Agent agent = Agent.getAgent(idx++);
53 | agentPlayerMap.put(agent, player);
54 | playerAgentMap.put(player, agent);
55 | }
56 | requestRoleMap = new HashMap();
57 |
58 | }
59 |
60 | public DirectConnectServer(Map playerMap){
61 | agentPlayerMap = new LinkedHashMap();
62 | playerAgentMap = new LinkedHashMap();
63 | requestRoleMap = new HashMap();
64 |
65 | int idx = 1;
66 | for(Player player:playerMap.keySet()){
67 | Agent agent = Agent.getAgent(idx++);
68 | agentPlayerMap.put(agent, player);
69 | playerAgentMap.put(player, agent);
70 | requestRoleMap.put(agent, playerMap.get(player));
71 | }
72 |
73 |
74 | }
75 |
76 | @Override
77 | public List getConnectedAgentList() {
78 | return new ArrayList(agentPlayerMap.keySet());
79 | }
80 |
81 | @Override
82 | public void setGameData(GameData gameData) {
83 | this.gameData = gameData;
84 | }
85 |
86 | @Override
87 | public void setGameSetting(GameSetting gameSetting){
88 | this.gameSetting = gameSetting;
89 | }
90 |
91 |
92 | @Override
93 | public void init(Agent agent) {
94 | try{
95 | agentPlayerMap.get(agent).initialize(gameData.getGameInfo(agent), gameSetting.clone());
96 | }catch(Throwable e){
97 | e.printStackTrace();
98 | throw new AIWolfAgentException(agent, "init", e);
99 | }
100 | }
101 |
102 | @Override
103 | public String requestName(Agent agent) {
104 | try{
105 | String name = agentPlayerMap.get(agent).getName();
106 | if(name != null){
107 | return name;
108 | }
109 | else{
110 | return agentPlayerMap.get(agent).getClass().getSimpleName();
111 | }
112 | }catch(Throwable e){
113 | throw new AIWolfAgentException(agent, "requestName", e);
114 | }
115 | }
116 |
117 | @Override
118 | public Role requestRequestRole(Agent agent) {
119 | try{
120 | return requestRoleMap.get(agent);
121 | }catch(Throwable e){
122 | throw new AIWolfAgentException(agent, "requestRequestRole", e);
123 | }
124 | }
125 |
126 | @Override
127 | public void dayStart(Agent agent) {
128 | try{
129 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
130 | agentPlayerMap.get(agent).dayStart();
131 | }catch(Throwable e){
132 | throw new AIWolfAgentException(agent, "dayStart", e);
133 | }
134 | }
135 |
136 | @Override
137 | public void dayFinish(Agent agent) {
138 | try{
139 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
140 | // agentPlayerMap.get(agent).dayStart();
141 | }catch(Throwable e){
142 | throw new AIWolfAgentException(agent, "dayFinish", e);
143 | }
144 | }
145 |
146 | @Override
147 | public String requestTalk(Agent agent) {
148 | try{
149 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
150 | String talk = agentPlayerMap.get(agent).talk();
151 | return talk;
152 | // if(talk == null){
153 | // throw new NoReturnObjectException();
154 | // }
155 | // else{
156 | // return talk;
157 | // }
158 | }catch(Throwable e){
159 | throw new AIWolfAgentException(agent, "requestTalk", e);
160 | }
161 | }
162 |
163 | @Override
164 | public String requestWhisper(Agent agent) {
165 | try{
166 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
167 | String whisper = agentPlayerMap.get(agent).whisper();
168 | return whisper;
169 | // if(whisper == null){
170 | // throw new NoReturnObjectException();
171 | // }
172 | // else{
173 | // return whisper;
174 | // }
175 | }catch(Throwable e){
176 | throw new AIWolfAgentException(agent, "requestWhisper", e);
177 | }
178 | }
179 |
180 | @Override
181 | public Agent requestVote(Agent agent) {
182 | try{
183 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
184 | Agent target = agentPlayerMap.get(agent).vote();
185 | return target;
186 | // if(target == null){
187 | // throw new NoReturnObjectException();
188 | // }
189 | // else{
190 | // return target;
191 | // }
192 | }catch(Throwable e){
193 | throw new AIWolfAgentException(agent, "requestVote", e);
194 | }
195 | }
196 |
197 | @Override
198 | public Agent requestDivineTarget(Agent agent) {
199 | try{
200 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
201 | Agent target = agentPlayerMap.get(agent).divine();
202 | return target;
203 | // if(target == null){
204 | // throw new NoReturnObjectException();
205 | // }
206 | // else{
207 | // return target;
208 | // }
209 | }catch(Throwable e){
210 | throw new AIWolfAgentException(agent, "requestDivineTarget", e);
211 | }
212 | }
213 |
214 | @Override
215 | public Agent requestGuardTarget(Agent agent) {
216 | try{
217 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
218 | Agent target = agentPlayerMap.get(agent).guard();
219 | return target;
220 | // if(target == null){
221 | // throw new NoReturnObjectException();
222 | // }
223 | // else{
224 | // return target;
225 | // }
226 | }catch(Throwable e){
227 | throw new AIWolfAgentException(agent, "requestGuardTarget", e);
228 | }
229 | }
230 |
231 | @Override
232 | public Agent requestAttackTarget(Agent agent) {
233 | try{
234 | agentPlayerMap.get(agent).update(gameData.getGameInfo(agent));
235 | Agent target = agentPlayerMap.get(agent).attack();
236 | return target;
237 | // if(target == null){
238 | // throw new NoReturnObjectException();
239 | // }
240 | // else{
241 | // return target;
242 | // }
243 | }catch(Throwable e){
244 | throw new AIWolfAgentException(agent, "requestAttackTarget", e);
245 | }
246 | }
247 |
248 | @Override
249 | public void finish(Agent agent){
250 | try{
251 | agentPlayerMap.get(agent).update(gameData.getFinalGameInfo(agent));
252 | agentPlayerMap.get(agent).finish();
253 | }catch(Throwable e){
254 | throw new AIWolfAgentException(agent, "finish", e);
255 | }
256 | }
257 |
258 | @Override
259 | public void close() {
260 | }
261 |
262 | public Agent getAgent(Player player) {
263 | return playerAgentMap.get(player);
264 | }
265 |
266 |
267 | public Player getPlayer(Agent agent){
268 | return agentPlayerMap.get(agent);
269 | }
270 |
271 |
272 |
273 |
274 |
275 | }
276 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/net/GameServer.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.net;
2 |
3 | import java.util.List;
4 |
5 |
6 | import org.aiwolf.common.data.Agent;
7 | import org.aiwolf.common.data.Role;
8 | import org.aiwolf.common.net.GameSetting;
9 | import org.aiwolf.server.GameData;
10 |
11 | public interface GameServer {
12 |
13 | /**
14 | *
15 | * @return
16 | */
17 | List getConnectedAgentList();
18 |
19 | /**
20 | * set GameSetting
21 | * @param gameSetting
22 | */
23 | void setGameSetting(GameSetting gameSetting);
24 |
25 | /**
26 | *
27 | * @param agent
28 | */
29 | void init(Agent agent);
30 |
31 | /**
32 | * Request agent's name
33 | * @param agent
34 | * @return
35 | */
36 | String requestName(Agent agent);
37 |
38 | /**
39 | * Request roles that agent request
40 | * @param agent
41 | * @return
42 | */
43 | Role requestRequestRole(Agent agent);
44 |
45 | /**
46 | *
47 | * @param agent
48 | * @return
49 | */
50 | String requestTalk(Agent agent);
51 |
52 | /**
53 | *
54 | * @param agent
55 | * @return
56 | */
57 | String requestWhisper(Agent agent);
58 |
59 |
60 | /**
61 | *
62 | * @param agent
63 | * @return
64 | */
65 | Agent requestVote(Agent agent);
66 |
67 |
68 | /**
69 | *
70 | * @param agent
71 | * @return
72 | */
73 | Agent requestDivineTarget(Agent agent);
74 |
75 | /**
76 | *
77 | * @param agent
78 | * @return
79 | */
80 | Agent requestGuardTarget(Agent agent);
81 |
82 |
83 | /**
84 | *
85 | * @param agent
86 | * @return
87 | */
88 | Agent requestAttackTarget(Agent agent);
89 |
90 | /**
91 | *
92 | * @param gameInfo
93 | */
94 | void setGameData(GameData gameData);
95 |
96 | /**
97 | * called when day started
98 | * @param agent
99 | */
100 | void dayStart(Agent agent);
101 |
102 | /**
103 | * called when day finished
104 | * @param agent
105 | */
106 | void dayFinish(Agent agent);
107 |
108 | /**
109 | * send finished message
110 | */
111 | void finish(Agent agent);
112 |
113 | /**
114 | * close connections
115 | */
116 | void close();
117 |
118 | }
119 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/net/ServerListener.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.net;
2 |
3 | import java.net.Socket;
4 |
5 | import org.aiwolf.common.data.Agent;
6 |
7 | public interface ServerListener {
8 | public void connected(Socket socket, Agent agent, String name);
9 |
10 | public void unconnected(Socket socket, Agent agent, String name);
11 |
12 | }
13 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/net/TcpipServer.java:
--------------------------------------------------------------------------------
1 | /**
2 | * TcpipServer.java
3 | *
4 | * Copyright (c) 2014 人狼知能プロジェクト
5 | */
6 | package org.aiwolf.server.net;
7 |
8 | import java.io.BufferedReader;
9 | import java.io.BufferedWriter;
10 | import java.io.IOException;
11 | import java.io.InputStreamReader;
12 | import java.io.OutputStreamWriter;
13 | import java.net.ServerSocket;
14 | import java.net.Socket;
15 | import java.net.SocketTimeoutException;
16 | import java.util.ArrayList;
17 | import java.util.Collections;
18 | import java.util.HashMap;
19 | import java.util.HashSet;
20 | import java.util.List;
21 | import java.util.Map;
22 | import java.util.Set;
23 | import java.util.concurrent.Callable;
24 | import java.util.concurrent.ExecutionException;
25 | import java.util.concurrent.ExecutorService;
26 | import java.util.concurrent.Executors;
27 | import java.util.concurrent.Future;
28 | import java.util.concurrent.TimeUnit;
29 | import java.util.concurrent.TimeoutException;
30 |
31 | //import net.arnx.jsonic.JSON;
32 |
33 | import org.aiwolf.common.data.Agent;
34 | import org.aiwolf.common.data.Request;
35 | import org.aiwolf.common.data.Role;
36 | import org.aiwolf.common.net.DataConverter;
37 | import org.aiwolf.common.net.GameSetting;
38 | import org.aiwolf.common.net.Packet;
39 | import org.aiwolf.common.net.TalkToSend;
40 | import org.aiwolf.common.util.BidiMap;
41 | import org.aiwolf.server.GameData;
42 | import org.aiwolf.server.IllegalPlayerNumException;
43 | import org.aiwolf.server.LostClientException;
44 |
45 | /**
46 | * Game server which communicates with clients via TCP/IP connections.
47 | *
48 | * @author tori and otsuki
49 | *
50 | */
51 | public class TcpipServer implements GameServer {
52 |
53 |
54 |
55 |
56 | /**
57 | * Server Port
58 | */
59 | protected int port;
60 |
61 | /**
62 | * connection limit
63 | */
64 | protected int limit;
65 |
66 | /**
67 | *
68 | */
69 | protected boolean isWaitForClient;
70 |
71 | /**
72 | *
73 | */
74 | protected BidiMap socketAgentMap;
75 |
76 |
77 | /**
78 | * Current game data
79 | */
80 | protected GameData gameData;
81 |
82 | /**
83 | * Game Setting
84 | */
85 | protected GameSetting gameSetting;
86 |
87 | /**
88 | *
89 | */
90 | // Logger serverLogger;
91 |
92 | /**
93 | *
94 | */
95 | protected Map nameMap;
96 |
97 | protected Set serverListenerSet;
98 |
99 | protected Map lastTalkIdxMap;
100 | protected Map lastWhisperIdxMap;
101 |
102 | protected ServerSocket serverSocket;
103 |
104 | /**
105 | * Time limit for waiting request
106 | */
107 | protected int timeLimit = 1000;
108 |
109 | /**
110 | *
111 | * @param port
112 | * @param limit
113 | */
114 | public TcpipServer(int port, int limit, GameSetting gameSetting){
115 | this.gameSetting = gameSetting;
116 | this.port = port;
117 | this.limit = limit;
118 | if (gameSetting.getTimeLimit() != -1) {
119 | timeLimit = gameSetting.getTimeLimit();
120 | }
121 |
122 | socketAgentMap = new BidiMap();
123 | String loggerName = this.getClass().getSimpleName();
124 | // serverLogger = Logger.getLogger(loggerName);
125 | nameMap = new HashMap<>();
126 | serverListenerSet = new HashSet<>();
127 | // serverLogger = AiWolfLoggerFactory.getLogger(loggerName);
128 | // serverLogger.setLevel(Level.FINER);
129 | // try {
130 | // serverLogger = AiWolfLoggerFactory.getLogger(loggerName, new File(loggerName+".log"));
131 | // serverLogger.setLevel(Level.FINER);
132 | // } catch (IOException e) {
133 | // e.printStackTrace();
134 | // serverLogger = AiWolfLoggerFactory.getLogger(loggerName);
135 | // }
136 |
137 | lastTalkIdxMap = new HashMap();
138 | lastWhisperIdxMap = new HashMap();
139 | }
140 |
141 | /**
142 | *
143 | * @throws IOException
144 | * @throws SocketTimeoutException
145 | */
146 | public void waitForConnection() throws IOException, SocketTimeoutException{
147 | // int timeout_msec = 1000*60*10; // time out in 10 miniutes
148 | // serverLogger.info(String.format("Start Server@port %d\n", port));
149 |
150 | for(Socket sock:socketAgentMap.keySet()){
151 | if(sock != null && sock.isConnected()){
152 | sock.close();
153 | }
154 | }
155 |
156 | socketAgentMap.clear();
157 | nameMap.clear();
158 |
159 | // serverLogger.info(String.format("Waiting for connection...\n"));
160 | System.out.println("Waiting for connection...\n");
161 |
162 | serverSocket = new ServerSocket(port);
163 |
164 | isWaitForClient = true;
165 |
166 | List shuffledAgentList = new ArrayList<>();
167 | for(int i = 1; i <= limit; i++) {
168 | shuffledAgentList.add(Agent.getAgent(i));
169 | }
170 | Collections.shuffle(shuffledAgentList);
171 |
172 | while(socketAgentMap.size() < limit && isWaitForClient){
173 | Socket socket = serverSocket.accept();
174 |
175 | synchronized (socketAgentMap) {
176 | Agent agent = null;
177 | for (int i = 0; i < limit; i++) {
178 | if(!socketAgentMap.containsValue(shuffledAgentList.get(i))){
179 | agent = shuffledAgentList.get(i);
180 | break;
181 | }
182 | }
183 | if(agent == null){
184 | throw new IllegalPlayerNumException("Fail to create agent");
185 | }
186 | socketAgentMap.put(socket, agent);
187 | String name = requestName(agent);
188 | nameMap.put(agent, name);
189 |
190 | for(ServerListener listener:serverListenerSet){
191 | listener.connected(socket, agent, name);
192 | }
193 | }
194 |
195 | }
196 | isWaitForClient = false;
197 | serverSocket.close();
198 | }
199 |
200 | /**
201 | *
202 | */
203 | public void stopWaitingForConnection() {
204 | isWaitForClient = false;
205 | try {
206 | if(serverSocket != null){
207 | serverSocket.close();
208 | }
209 | } catch (IOException e) {
210 | e.printStackTrace();
211 | }
212 | for(Socket s:socketAgentMap.keySet()){
213 | try {
214 | s.close();
215 | } catch (IOException e) {
216 | e.printStackTrace();
217 | }
218 | }
219 | socketAgentMap.clear();
220 | }
221 |
222 |
223 |
224 | @Override
225 | public List getConnectedAgentList() {
226 | synchronized (socketAgentMap) {
227 | return new ArrayList(socketAgentMap.values());
228 | }
229 | }
230 |
231 | /**
232 | * send data to client
233 | * @param agent
234 | * @param sendText
235 | * @TODO Whisperの際に毎回GameInfoを毎回送ってしまう問題の解決．必要が無ければGameInfoを送らなくする
236 | */
237 | protected void send(Agent agent, Request request){
238 | try{
239 | String message;
240 | if(request == Request.INITIALIZE){
241 | lastTalkIdxMap.clear();
242 | lastWhisperIdxMap.clear();
243 | Packet packet = new Packet(request, gameData.getGameInfoToSend(agent), gameSetting);
244 | message = DataConverter.getInstance().convert(packet);
245 | }
246 | else if(request == Request.DAILY_INITIALIZE){
247 | lastTalkIdxMap.clear();
248 | lastWhisperIdxMap.clear();
249 | Packet packet = new Packet(request, gameData.getGameInfoToSend(agent));
250 | message = DataConverter.getInstance().convert(packet);
251 | }
252 | else if(request == Request.NAME || request == Request.ROLE){
253 | Packet packet = new Packet(request);
254 | message = DataConverter.getInstance().convert(packet);
255 | }
256 | else if (request != Request.FINISH) {
257 | // Packet packet = new Packet(request, gameData.getGameInfoToSend(agent), gameSetting);
258 | // message = DataConverter.getInstance().convert(packet);
259 | if (request == Request.VOTE && !gameData.getLatestVoteList().isEmpty()) {
260 | // 追放再投票の場合，latestVoteListで直前の投票状況を知らせるためGameInfo入りのパケットにする
261 | Packet packet = new Packet(request, gameData.getGameInfoToSend(agent));
262 | message = DataConverter.getInstance().convert(packet);
263 | } else if (request == Request.ATTACK && !gameData.getLatestAttackVoteList().isEmpty()) {
264 | // 襲撃再投票の場合，latestAttackVoteListで直前の投票状況を知らせるためGameInfo入りのパケットにする
265 | Packet packet = new Packet(request, gameData.getGameInfoToSend(agent));
266 | message = DataConverter.getInstance().convert(packet);
267 | } else if (gameData.getExecuted() != null
268 | && (request == Request.DIVINE || request == Request.GUARD || request == Request.WHISPER || request == Request.ATTACK)) {
269 | // 追放後の各リクエストではlatestExecutedAgentで追放者を知らせるためGameInfo入りのパケットにする
270 | Packet packet = new Packet(request, gameData.getGameInfoToSend(agent));
271 | message = DataConverter.getInstance().convert(packet);
272 | } else {
273 | List talkList = gameData.getGameInfoToSend(agent).getTalkList();
274 | List whisperList = gameData.getGameInfoToSend(agent).getWhisperList();
275 |
276 | talkList = minimize(agent, talkList, lastTalkIdxMap);
277 | whisperList = minimize(agent, whisperList, lastWhisperIdxMap);
278 |
279 | Packet packet = new Packet(request, talkList, whisperList);
280 | message = DataConverter.getInstance().convert(packet);
281 | }
282 | } else {
283 | Packet packet = new Packet(request, gameData.getFinalGameInfoToSend(agent));
284 | message = DataConverter.getInstance().convert(packet);
285 | }
286 | // serverLogger.info("=>"+agent+":"+message);
287 |
288 | Socket sock = socketAgentMap.getKey(agent);
289 | BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));
290 | bw.append(message);
291 | bw.append("\n");
292 | bw.flush();
293 | }catch(IOException e){
294 | // serverLogger.severe(e.getMessage());
295 | throw new LostClientException(e, agent);
296 | }
297 | }
298 |
299 | /**
300 | * delete talks already sent
301 | * @param agent
302 | * @param list
303 | * @param lastIdxMap
304 | * @return
305 | */
306 | protected List minimize(Agent agent, List list, Map lastIdxMap) {
307 | int lastIdx = list.size();
308 | if(lastIdxMap.containsKey(agent) && list.size() >= lastIdxMap.get(agent)){
309 | list = list.subList(lastIdxMap.get(agent), list.size());
310 | }
311 | lastIdxMap.put(agent, lastIdx);
312 | return list;
313 | }
314 |
315 | /**
316 | * send data to client
317 | * @param agent
318 | * @param sendText
319 | */
320 | protected Object request(Agent agent, Request request){
321 | try{
322 | Socket sock = socketAgentMap.getKey(agent);
323 | final BufferedReader br = new BufferedReader(new InputStreamReader(sock.getInputStream()));
324 | send(agent, request);
325 |
326 | String line = null;
327 | ExecutorService pool = Executors.newSingleThreadExecutor();
328 | RequestReadCallable task = new RequestReadCallable(br);
329 | try {
330 | Future future = pool.submit(task);
331 | try{
332 | line = future.get(timeLimit, TimeUnit.MILLISECONDS); //1秒でタイムアウト
333 | } catch (InterruptedException | ExecutionException e) {
334 | throw e;
335 | } catch (TimeoutException e) {
336 | sock.close();
337 | throw e;
338 | }
339 | } finally {
340 | pool.shutdownNow();
341 | }
342 |
343 | // String line = br.readLine();
344 | if(!task.isSuccess()){
345 | throw task.getIOException();
346 | }
347 | // serverLogger.info("<="+agent+":"+line);
348 |
349 | if(line != null && line.isEmpty()){
350 | line = null;
351 | }
352 | if (request == Request.NAME || request == Request.ROLE) {
353 | return line;
354 | } else if (request == Request.TALK || request == Request.WHISPER) {
355 | return line;
356 | } else if (request == Request.ATTACK || request == Request.DIVINE || request == Request.GUARD
357 | || request == Request.VOTE) {
358 | Agent target = DataConverter.getInstance().toAgent(line);
359 | if(gameData.contains(target)) {
360 | return target;
361 | }
362 | else {
363 | return null;
364 | }
365 | }
366 | else{
367 | return null;
368 | }
369 |
370 |
371 | }catch(InterruptedException | ExecutionException | IOException e){
372 | throw new LostClientException("Lost connection with "+agent+"\t"+getName(agent), e, agent);
373 | }catch(TimeoutException e){
374 | throw new LostClientException(String.format("Timeout %s(%s) %s", agent, getName(agent), request), e, agent);
375 | }
376 | }
377 |
378 | @Override
379 | public void init(Agent agent) {
380 | send(agent, Request.INITIALIZE);
381 | }
382 |
383 | @Override
384 | public void dayStart(Agent agent) {
385 | send(agent, Request.DAILY_INITIALIZE);
386 | }
387 |
388 | @Override
389 | public void dayFinish(Agent agent){
390 | send(agent, Request.DAILY_FINISH);
391 | }
392 |
393 | @Override
394 | public String requestName(Agent agent) {
395 | if(nameMap.containsKey(agent)){
396 | return nameMap.get(agent);
397 | }
398 | else{
399 | String name = (String)request(agent, Request.NAME);
400 | nameMap.put(agent, name);
401 | return name;
402 | }
403 | }
404 |
405 |
406 | @Override
407 | public Role requestRequestRole(Agent agent) {
408 | String roleString = (String)request(agent, Request.ROLE);
409 | try{
410 | return Role.valueOf(roleString);
411 | }catch(IllegalArgumentException e){
412 | return null;
413 | }
414 | }
415 |
416 |
417 | @Override
418 | public String requestTalk(Agent agent) {
419 | return (String)request(agent, Request.TALK);
420 | }
421 |
422 | @Override
423 | public String requestWhisper(Agent agent) {
424 | return (String)request(agent, Request.WHISPER);
425 | }
426 |
427 | @Override
428 | public Agent requestVote(Agent agent) {
429 | return (Agent)request(agent, Request.VOTE);
430 | // return JSON.decode(result);
431 | }
432 |
433 | @Override
434 | public Agent requestDivineTarget(Agent agent) {
435 | return (Agent)request(agent, Request.DIVINE);
436 | // return JSON.decode(result);
437 | }
438 |
439 | @Override
440 | public Agent requestGuardTarget(Agent agent) {
441 | return (Agent)request(agent, Request.GUARD);
442 | // return JSON.decode(result);
443 | }
444 |
445 | @Override
446 | public Agent requestAttackTarget(Agent agent) {
447 | return (Agent)request(agent, Request.ATTACK);
448 | // return JSON.decode(result);
449 | }
450 |
451 |
452 | @Override
453 | public void finish(Agent agent) {
454 | send(agent, Request.FINISH);
455 | // send(agent, Request.FINISH);
456 | }
457 |
458 | @Override
459 | public void setGameData(GameData gameData) {
460 | this.gameData = gameData;
461 | }
462 |
463 |
464 | @Override
465 | public void setGameSetting(GameSetting gameSetting) {
466 | this.gameSetting = gameSetting;
467 | }
468 |
469 |
470 | /**
471 | * @return isWaitForClient
472 | */
473 | public boolean isWaitForClient() {
474 | return isWaitForClient;
475 | }
476 |
477 | /**
478 | * @param isWaitForClient セットする isWaitForClient
479 | */
480 | public void setWaitForClient(boolean isWaitForClient) {
481 | this.isWaitForClient = isWaitForClient;
482 | }
483 |
484 | @Override
485 | public void close(){
486 | try {
487 | if(serverSocket != null && !serverSocket.isClosed()){
488 | serverSocket.close();
489 | }
490 | } catch (IOException e1) {
491 | e1.printStackTrace();
492 | }
493 | for(Socket socket:socketAgentMap.keySet()){
494 | try {
495 | socket.close();
496 | } catch (IOException e) {
497 | e.printStackTrace();
498 | }
499 | }
500 | socketAgentMap.clear();
501 | }
502 |
503 | /**
504 | * @return serverLogger
505 | */
506 | // public Logger getServerLogger() {
507 | // return serverLogger;
508 | // }
509 | //
510 | // /**
511 | // * @param serverLogger セットする serverLogger
512 | // */
513 | // public void setServerLogger(Logger serverLogger) {
514 | // this.serverLogger = serverLogger;
515 | // }
516 |
517 | /**
518 | * add server listener
519 | * @param e
520 | * @return
521 | * @see java.util.Set#add(java.lang.Object)
522 | */
523 | public boolean addServerListener(ServerListener e) {
524 | return serverListenerSet.add(e);
525 | }
526 |
527 | /**
528 | * remove server listener
529 | * @param o
530 | * @return
531 | * @see java.util.Set#remove(java.lang.Object)
532 | */
533 | public boolean removeServerListener(ServerListener e) {
534 | return serverListenerSet.remove(e);
535 | }
536 |
537 | public String getName(Agent agent) {
538 | return nameMap.get(agent);
539 | }
540 |
541 | /**
542 | * @return timeLimit
543 | */
544 | public int getTimeLimit() {
545 | return timeLimit;
546 | }
547 |
548 | /**
549 | * @param timeLimit セットする timeLimit
550 | */
551 | public void setTimeLimit(int timeLimit) {
552 | this.timeLimit = timeLimit;
553 | }
554 |
555 |
556 | }
557 |
558 |
559 | class RequestReadCallable implements Callable {
560 | private final BufferedReader br;
561 | IOException ioException;
562 | RequestReadCallable(BufferedReader br) {
563 | this.br = br;
564 | }
565 |
566 | @Override
567 | public String call() {
568 | try{
569 | String line = br.readLine();
570 | return line;
571 | }catch(IOException e){
572 | ioException = e;
573 | return null;
574 | }
575 | }
576 |
577 | public boolean isSuccess(){
578 | return ioException == null;
579 | }
580 |
581 | public IOException getIOException(){
582 | return ioException;
583 | }
584 | }
--------------------------------------------------------------------------------
/src/org/aiwolf/server/util/FileGameLogger.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.util;
2 |
3 | import java.io.BufferedWriter;
4 | import java.io.File;
5 | import java.io.FileOutputStream;
6 | import java.io.FileWriter;
7 | import java.io.IOException;
8 | import java.io.OutputStreamWriter;
9 | import java.util.zip.GZIPOutputStream;
10 |
11 | import org.aiwolf.common.net.GameInfo;
12 | import org.aiwolf.common.util.CalendarTools;
13 |
14 | /**
15 | * GameLogger using File
16 | * @author tori
17 | *
18 | */
19 | public class FileGameLogger implements GameLogger {
20 |
21 | protected File logFile;
22 | protected BufferedWriter bw;
23 |
24 | protected FileGameLogger(){
25 |
26 | }
27 |
28 | /**
29 | *
30 | * @param logFile
31 | * @throws IOException
32 | */
33 | public FileGameLogger(String logFile) throws IOException {
34 | this(new File(logFile));
35 | }
36 |
37 | /**
38 | *
39 | * @param logFile
40 | * @throws IOException
41 | */
42 | public FileGameLogger(File logFile) throws IOException {
43 | super();
44 |
45 | if(logFile != null){
46 | if(logFile.isDirectory()){
47 | String timeString = CalendarTools.toDateTime(System.currentTimeMillis()).replaceAll("[\\s-/:]", "");
48 | logFile = new File(logFile.getAbsolutePath()+"/"+timeString+".log");
49 | }
50 | this.logFile = logFile;
51 |
52 | logFile.getParentFile().mkdirs();
53 | try{
54 | if(!logFile.getPath().endsWith(".gz")){
55 | bw = new BufferedWriter(new FileWriter(logFile));
56 | }
57 | else{
58 | bw = new BufferedWriter(new OutputStreamWriter(new GZIPOutputStream(new FileOutputStream(logFile), true)));
59 | }
60 | return;
61 | }catch(IOException e){
62 | e.printStackTrace();
63 | System.err.println("Fail to create logfile. Output log to system.out");
64 | }
65 | }
66 | bw = new BufferedWriter(new OutputStreamWriter(System.out));
67 | }
68 |
69 | /**
70 | * Save log
71 | * @param text
72 | * @param gameInfo
73 | */
74 | public void log(String text){
75 | try{
76 | bw.append(text);
77 | bw.append("\n");
78 | }catch(IOException e){
79 | }
80 | // System.out.println(text);
81 | }
82 |
83 | public void flush(){
84 | try {
85 | bw.flush();
86 | } catch (IOException e) {
87 | }
88 | }
89 |
90 | public void close(){
91 | try {
92 | bw.close();
93 | } catch (IOException e) {
94 | e.printStackTrace();
95 | }
96 | }
97 |
98 | }
99 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/util/GameLogger.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.util;
2 |
3 | import org.aiwolf.common.net.GameInfo;
4 |
5 | public interface GameLogger {
6 | public void log(String log);
7 | public void flush();
8 | public void close();
9 | }
10 |
--------------------------------------------------------------------------------
/src/org/aiwolf/server/util/MultiGameLogger.java:
--------------------------------------------------------------------------------
1 | package org.aiwolf.server.util;
2 |
3 | import java.util.HashSet;
4 | import java.util.Set;
5 |
6 | import org.aiwolf.common.net.GameInfo;
7 |
8 |
9 | /**
10 | *
11 | * @author tori
12 | *
13 | */
14 | public class MultiGameLogger implements GameLogger {
15 |
16 | protected Set gameLoggerSet;
17 |
18 | public MultiGameLogger(){
19 | gameLoggerSet = new HashSet();
20 | }
21 |
22 | public MultiGameLogger(GameLogger... loggers){
23 | gameLoggerSet = new HashSet();
24 | for(GameLogger gl:loggers){
25 | gameLoggerSet.add(gl);
26 | }
27 | }
28 |
29 |
30 | public void add(GameLogger gameLogger){
31 | gameLoggerSet.add(gameLogger);
32 | }
33 |
34 | public void remove(GameLogger gameLogger){
35 | gameLoggerSet.remove(gameLogger);
36 | }
37 |
38 |
39 | @Override
40 | public void log(String log) {
41 | for(GameLogger gl:gameLoggerSet){
42 | gl.log(log);
43 | }
44 |
45 | }
46 |
47 | @Override
48 | public void flush() {
49 | for(GameLogger gl:gameLoggerSet){
50 | gl.flush();
51 | }
52 | }
53 |
54 | @Override
55 | public void close() {
56 | for(GameLogger gl:gameLoggerSet){
57 | gl.close();
58 | }
59 | }
60 |
61 | }
62 |
--------------------------------------------------------------------------------