← Back to branch summary

~vedu/mafia-android/master

« back to all changes in this revision

Viewing changes to src/com/vedant/mafia/backend/GameRules.java

  • Committer: Vedant Agrwala
  • Date: 2013-11-14 09:10:05 UTC
  • Revision ID: vedant.kota@gmail.com-20131114091005-mv8oabe8o4fugzo8
Initial work

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/com/vedant/mafia/backend/GameRules.java
 
1
package com.vedant.mafia.backend;
 
2
 
 
3
import java.util.ArrayList;
 
4
import java.util.Set;
 
5
 
 
6
import com.vedant.mafia.GameController;
 
7
import com.vedant.mafia.Message;
 
8
import com.vedant.mafia.MessageCentre;
 
9
 
 
10
public class GameRules {
 
11
        public enum GameEnd{
 
12
                GAME_DOES_NOT_END,
 
13
                MAFIA_WIN,
 
14
                NON_MAFIA_WIN
 
15
        }
 
16
        private static final String SUGGESTIONS_TO_HITMAN = " suggested to kill ",
 
17
                HITMAN_KILLED = " has already been killed. You may suggest a player for the next round";
 
18
        
 
19
        public static GameEnd doesGameEnd(String votedOut){
 
20
                Person roleVotedOut = GameController.db().getRole(votedOut);
 
21
                GameController.db().remove(votedOut);
 
22
                switch(roleVotedOut){
 
23
                case GODFATHER:
 
24
                case HITMAN:
 
25
                        int index = GameController.db().types.indexOf(Person.MAFIA);
 
26
                        if(index < 0){
 
27
                                index = GameController.db().types.indexOf(Person.WITCH);
 
28
                                if(index < 0)
 
29
                                        return GameEnd.NON_MAFIA_WIN;
 
30
                        }
 
31
                        GameController.db().types.remove(index);
 
32
                        GameController.db().types.add(index, Person.HITMAN);
 
33
                case MAFIA:
 
34
                case WITCH:
 
35
                        break;
 
36
                default: // for non mafia
 
37
                        int numNonMafia = 0;
 
38
                        for(Person person: GameController.db().types)
 
39
                                if(!person.isMafia())
 
40
                                        numNonMafia++;
 
41
                        switch(2*numNonMafia - GameController.db().types.size()){// ie difference between mafia and non mafia
 
42
                        case 1:
 
43
                                if(GameController.db().types.contains(Person.ANGEL))
 
44
                                        break;
 
45
                        case 0:
 
46
                                return GameEnd.MAFIA_WIN;
 
47
                        }
 
48
                }
 
49
                return GameEnd.GAME_DOES_NOT_END;
 
50
        }
 
51
        
 
52
        public static Message processRoundEndMessage(Set<Message> gameMessages, Message msg){
 
53
                switch(GameController.db().getRole(msg.from).action){
 
54
                case CHECK:
 
55
                        String message;
 
56
                        if (isSleeping(gameMessages, msg.from))
 
57
                                message = String.valueOf(ReplyFromGod.CANT_SAY.ordinal());
 
58
                        else if (GameController.db().getRole(msg.to).thumbsUp())
 
59
                                message = String.valueOf(ReplyFromGod.YES.ordinal());
 
60
                        else
 
61
                                message = String.valueOf(ReplyFromGod.NO.ordinal());
 
62
                        return new Message(Message.GOD, msg.from, message);
 
63
                }
 
64
                throw new IllegalArgumentException("Cant process round end message: "+msg.toString());
 
65
        }
 
66
        
 
67
        public static String cityRisesToDeathOf(Set<Message> gameMessages){
 
68
                for(Message msg: gameMessages){
 
69
                        if(msg.from.equals(GameController.db().getHitman())){
 
70
                                if(isSaved(gameMessages, msg.to))
 
71
                                        return null;
 
72
                                else
 
73
                                        return msg.to;
 
74
                        }
 
75
                }
 
76
                throw new IllegalArgumentException("No message from hitman");
 
77
        }
 
78
        
 
79
        private static boolean isSaved(Set<Message> messages, String victim){
 
80
                for(Message msg: messages){
 
81
                        if(GameController.db().getRole(msg.from).equals(Person.ANGEL)
 
82
                                && msg.to.equals(victim) && !isSleeping(messages, msg.from))
 
83
                                return true;
 
84
                }
 
85
                return false;
 
86
        }
 
87
        
 
88
        private static boolean isSleeping(Set<Message> messages, String player) {
 
89
                for(Message msg: messages){
 
90
                        if(GameController.db().getRole(msg.from).equals(Person.WITCH)
 
91
                                && msg.to.equals(player))
 
92
                                return true;
 
93
                }
 
94
                return false;
 
95
        }
 
96
 
 
97
        public static boolean isGameMessage(String from){
 
98
                switch(GameController.db().getRole(from).action){
 
99
                case CHECK:
 
100
                case SUGGEST:
 
101
                        return false;
 
102
                }
 
103
                return true;
 
104
        }
 
105
        
 
106
        public static Message processMessage(Message message){
 
107
                switch(GameController.db().getRole(message.from)){
 
108
                case MAFIA:
 
109
                        return new Message(message.from, GameController.db().getHitman(), message.to);
 
110
                case CIVILIAN:
 
111
                        return null;
 
112
                case HITMAN:
 
113
                case GODFATHER:
 
114
                        for(String player: GameController.db().names)
 
115
                                if(GameController.db().getRole(player).equals(Person.MAFIA))
 
116
                                        MessageCentre.newProcessedMessage(new Message(message.from, player, message.to));
 
117
                default:
 
118
                        return message;
 
119
                }
 
120
        }
 
121
        
 
122
        public static String generateInfo(Message message){
 
123
                switch(GameController.db().getRole(message.to).action){
 
124
                case KILL:
 
125
                        String[] mafia = message.from.split(Message.SEPARATOR);
 
126
                        String[] victims = message.message.split(Message.SEPARATOR);
 
127
                        StringBuilder userMsg = new StringBuilder();
 
128
                        for(int i = 0 ; i < mafia.length; i++){
 
129
                                userMsg.append(mafia[i]).append(SUGGESTIONS_TO_HITMAN).append(victims[i]);
 
130
                                if(i < mafia.length - 1)
 
131
                                        userMsg.append("\n");
 
132
                        }
 
133
                        return userMsg.toString();
 
134
                        
 
135
                case SUGGEST:
 
136
                        return message.message + HITMAN_KILLED;
 
137
                }
 
138
                throw new UnsupportedOperationException("cannot generate for message" + message.toString());
 
139
        }
 
140
 
 
141
        public static Message combineMessage(Message newMessage, Message oldMessage) {
 
142
                switch(GameController.db().getRole(oldMessage.to)){
 
143
                case GODFATHER:
 
144
                        return new Message(oldMessage.from + Message.SEPARATOR + newMessage.from , oldMessage.to,
 
145
                                        oldMessage.message + Message.SEPARATOR + newMessage.message);
 
146
                }
 
147
                throw new UnsupportedOperationException(
 
148
                                "cannnot combine " + oldMessage.toString() + " and " + newMessage.toString());
 
149
        }
 
150
        
 
151
        public static ArrayList<String> getList(String name, Message message){
 
152
                switch (GameController.db().getRole(name).action) {
 
153
                case CHECK:
 
154
                case SAVE:
 
155
                case SLEEP:
 
156
                        return GameController.db().names;
 
157
                case SUGGEST:
 
158
                        if(message != null)
 
159
                                break;
 
160
                case KILL:
 
161
                        return createKillableList();
 
162
                }
 
163
                return null;
 
164
        }
 
165
        
 
166
        private static ArrayList<String> createKillableList(){
 
167
                ArrayList<String> killable = new ArrayList<String>(
 
168
                                GameController.db().names);
 
169
                for(String name: GameController.db().names){
 
170
                        Person person = GameController.db().getRole(name);
 
171
                        if(person.isMafia())
 
172
                                killable.remove(name);
 
173
                }
 
174
                return killable;
 
175
        }
 
176
        
 
177
}