Changeset 50


Ignore:
Timestamp:
04/11/10 18:05:43 (12 years ago)
Author:
BegemoT
Message:
 
Location:
SnowBallBot
Files:
4 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed
  • SnowBallBot/src/snowball/BotRunner.java

    r49 r50  
    44 
    55import snowball.protocol.*; 
    6 import static snowball.protocol.ResponseKind.ENEMY_KILLED; 
     6import static snowball.protocol.ResponseKind.*; 
    77import snowball.helpers.*; 
    88import org.jivesoftware.smack.XMPPException; 
     
    308308                                } 
    309309                                case ENEMY_KILLED: 
     310                                case ENEMY_IN_BAR: 
    310311                                case ENEMY_NOT_AVAILABLE: { 
    311312                                        final String enemy = ( String ) r.data(); 
     
    323324                                                } else { 
    324325                                                        fights.opponentNotAvailable( enemy ); 
    325                                                         log.info( "\t <- not found(" + enemy + ")" ); 
     326                                                        if(r.kind() == ENEMY_IN_BAR){ 
     327                                                                log.info( "\t <- in bar(" + enemy + ")" ); 
     328                                                        }else{ 
     329                                                                log.info( "\t <- not available(" + enemy + ")" ); 
     330                                                        } 
    326331                                                } 
    327332                                        } 
  • SnowBallBot/src/snowball/helpers/FightsList.java

    r48 r50  
    1212 */ 
    1313public class FightsList implements Iterable<Fight> { 
    14     private final PeopleRegistry registry; 
    15     private final Map<String, Fight> fightByName = new HashMap(); 
    16     private final Queue<Fight> fights = new ArrayDeque(); 
    17  
    18     public FightsList( final PeopleRegistry registry ) { 
    19         this.registry = registry; 
    20     } 
    21  
    22     public Iterable<Fight> fights() { 
    23         return Collections.unmodifiableCollection( fights ); 
    24     } 
    25  
    26     public Iterator<Fight> iterator() { 
    27         return Collections.unmodifiableCollection( fights ).iterator(); 
    28     } 
    29  
    30     /** 
    31      * i was attacked by specified opponent 
    32      */ 
    33     public Fight wasAttackedBy( final String opponent ) { 
    34         final Fight fight = getOrCreate( opponent, true ); 
    35         fight.wasAttackedByOpponent(); 
    36         return fight; 
    37     } 
    38  
    39     /** 
    40      * opponent was attacked by myself 
    41      */ 
    42     public Fight attacked( final String opponent ) { 
    43         final Fight fight = getOrCreate( opponent, false ); 
    44         fight.opponentAttackedByMe(); 
    45         return fight; 
    46     } 
    47  
    48     /** 
    49      * opponent was attacked by myself 
    50      */ 
    51     public Fight attackedConfirmed( final String opponent ) { 
    52         final Fight fight = getOrCreate( opponent, false ); 
    53         if ( fight.state() != Fight.State.OPPONENT_ATTACKED_BY_ME ) { 
    54             fight.opponentAttackedByMe(); 
    55         } 
    56         return fight; 
    57     } 
    58  
    59     /** 
    60      * opponent strike back to me 
    61      */ 
    62     public Fight opponentStrikedBack( final String opponent ) { 
    63         final Fight fight = getOrCreate( opponent, false ); 
    64         fight.opponentStrikedBack(); 
    65         return fight; 
    66     } 
    67  
    68     public Fight opponentKilled( final String opponent ) { 
    69         final Fight fight = getOrCreate( opponent ); 
    70         remove( fight ); 
    71         fight.opponentKilled(); 
    72         return fight; 
    73     } 
    74  
    75     public Fight opponentNotAvailable( final String opponent ) { 
    76         final Fight fight = fightByName.get( opponent ); 
    77         if ( fight != null ) { 
    78             return remove( fight ); 
    79         } else { 
    80             return null; 
    81         } 
    82     } 
    83  
    84     public Fight opponentNotAvailable() { 
    85         for ( final Fight fight : fights ) { 
    86             if ( fight.state() == OPPONENT_ATTACKED_BY_ME ) { 
    87                 remove( fight ); 
    88                 return fight; 
    89             } 
    90         } 
    91         return null; 
    92     } 
    93  
    94     public Fight iWasKilled( final String opponent ) { 
    95         final Fight fight = getOrCreate( opponent ); 
    96         fight.iKilled(); 
    97         clear(); 
    98         return fight; 
    99     } 
    100  
    101     public Fight opponentEscaped( final String opponent ) { 
    102         final Fight fight = getOrCreate( opponent ); 
    103         fight.opponentEscaped(); 
    104         return fight; 
    105     } 
    106  
    107     public Fight iEscaped( final String opponent ) { 
    108         final Fight fight = getOrCreate( opponent ); 
    109         fight.iEscaped(); 
    110         return fight; 
    111     } 
    112  
    113     public void clear() { 
    114         fightByName.clear(); 
    115     } 
    116  
    117     public void outOfFight() { 
    118         for ( final Fight fight : fights ) { 
    119             if ( fight.state() != FREE ) { 
    120                 fight.updateState( FREE ); 
    121             } 
    122         } 
    123     } 
    124  
    125     public void dropOutOld( final long timeout ) { 
    126         final List<Fight> toDrop = new ArrayList(); 
    127         for ( final Fight fight : fights ) { 
    128             if ( fight.state().isFree() ) { 
    129                 if ( fight.age() >= timeout ) { 
    130                     toDrop.add( fight ); 
    131                 } 
    132             } 
    133         } 
    134         for ( final Fight fight : toDrop ) { 
    135             remove( fight ); 
    136         } 
    137     } 
    138  
    139     public int activeFights() { 
    140         int cnt = 0; 
    141         for ( final Fight fight : fights ) { 
    142             if ( fight.state() != FREE ) { 
    143                 cnt++; 
    144             } 
    145         } 
    146         return cnt; 
    147     } 
    148  
    149     public boolean isDangerous() { 
    150         for ( final Fight fight : fights ) { 
    151             if ( !fight.isOpponentZomby() ) { 
    152                 return size() > 1; 
    153             } 
    154         } 
    155         return false; 
    156     } 
    157  
    158     public boolean hasNonZombyOpponents() { 
    159         for ( final Fight fight : fights ) { 
    160             if ( !fight.isOpponentZomby() ) { 
    161                 return true; 
    162             } 
    163         } 
    164         return false; 
    165     } 
    166  
    167     public int size() { 
    168         return fights.size(); 
    169     } 
    170  
    171     /** 
    172      * @return íàèáîëåå àêòóàëüíûé òåêóùèé ïðîòèâíèê. 
    173      *         Â ïåðâóþ î÷åðåäü áåðóòñÿ îïïîíåíòû, íàïàâøèå ñàìè. Âî âòîðóþ -- 
    174      *         ïðîÿâèâøèå èíèöèàòèâó (íå-çîìáè). Äàëåå -- òå, ñ êåì ìû åùå íå 
    175      *         "â ðàñ÷åòå" (state != FREE). Äàëåå êòî ïîïàëî 
    176      */ 
    177     public Fight actualEnemy() { 
    178         if ( empty() ) { 
    179             return null; 
    180         } 
    181         for ( final Fight fight : fights ) { 
    182             if ( fight.isOpponentStarted() ) { 
    183                 return fight; 
    184             } 
    185         } 
    186         for ( final Fight fight : fights ) { 
    187             if ( fight.isOpponentActive() ) { 
    188                 return fight; 
    189             } 
    190         } 
    191  
    192         Fight f = null; 
    193         for ( final Fight fight : fights ) { 
    194             f = fight; 
    195             if ( fight.state() != FREE ) { 
    196                 return fight; 
    197             } 
    198         } 
    199         return f; 
    200     } 
    201  
    202     public boolean canUseHeater() { 
    203         for ( final Fight fight : fights ) { 
    204             if ( !fight.state().canHeal() ) { 
    205                 return false; 
    206             } 
    207         } 
    208         return true; 
    209     } 
    210  
    211     public boolean canEscape() { 
    212         for ( final Fight fight : fights ) { 
    213             if ( !fight.state().canEscape() ) { 
    214                 return false; 
    215             } 
    216         } 
    217         return true; 
    218     } 
    219  
    220     public boolean isFree() { 
    221         for ( final Fight fight : fights ) { 
    222             if ( !fight.state().isFree() ) { 
    223                 return false; 
    224             } 
    225         } 
    226         return true; 
    227     } 
    228  
    229     public boolean isWaitingForOpponent() { 
    230         for ( final Fight fight : fights ) { 
    231             if ( fight.state() == Fight.State.OPPONENT_ATTACKED_BY_ME ) { 
    232                 return true; 
    233             } 
    234         } 
    235         return false; 
    236     } 
    237  
    238     public boolean canMove() { 
    239         return isFree(); 
    240     } 
    241  
    242     public boolean empty() { 
    243         return size() == 0; 
    244     } 
    245  
    246     @Override 
    247     public String toString() { 
    248         final StringBuilder sb = new StringBuilder(); 
    249         for ( final Fight fight : fights ) { 
    250             sb.append( fight ); 
    251         } 
    252         return sb.toString(); 
    253     } 
    254  
    255     private Fight getOrCreate( final String enemy, 
    256                                final Fight.State state ) { 
    257         Fight fight = fightByName.get( enemy ); 
    258         if ( fight == null ) { 
    259             fight = new Fight( registry, enemy, state ); 
    260             add( fight ); 
    261         } else { 
    262             fight.updateState( state ); 
    263         } 
    264         return fight; 
    265     } 
    266  
    267     private Fight getOrCreate( final String enemy, 
    268                                final boolean opponentFirstStrike ) { 
    269         Fight fight = fightByName.get( enemy ); 
    270         if ( fight == null ) { 
    271             fight = new Fight( registry, enemy, opponentFirstStrike, Fight.State.FREE ); 
    272             add( fight ); 
    273         } 
    274         return fight; 
    275     } 
    276  
    277     private Fight getOrCreate( final String enemy ) { 
    278         Fight fight = fightByName.get( enemy ); 
    279         if ( fight == null ) { 
    280             fight = new Fight( registry, enemy ); 
    281             add( fight ); 
    282         } 
    283         return fight; 
    284     } 
    285  
    286     private Fight add( final Fight fight ) { 
    287         fightByName.put( fight.opponentName(), fight ); 
    288         fights.add( fight ); 
    289         return fight; 
    290     } 
    291  
    292     private Fight remove( final Fight f ) { 
    293         fightByName.remove( f.opponentName() ); 
    294         fights.remove( f ); 
    295         return f; 
    296     } 
     14        private final PeopleRegistry registry; 
     15 
     16        private final Map<String, Fight> fightByName = new HashMap(); 
     17 
     18        private final List<Fight> fights = new ArrayList(); 
     19 
     20        public FightsList( final PeopleRegistry registry ) { 
     21                this.registry = registry; 
     22        } 
     23 
     24        public synchronized Iterable<Fight> fights() { 
     25                return Collections.unmodifiableCollection( fights ); 
     26        } 
     27 
     28        public synchronized Iterator<Fight> iterator() { 
     29                return Collections.unmodifiableCollection( fights ).iterator(); 
     30        } 
     31 
     32        /** i was attacked by specified opponent */ 
     33        public synchronized Fight wasAttackedBy( final String opponent ) { 
     34                final Fight fight = getOrCreate( opponent, true ); 
     35                fight.wasAttackedByOpponent(); 
     36                return fight; 
     37        } 
     38 
     39        /** opponent was attacked by myself */ 
     40        public synchronized Fight attacked( final String opponent ) { 
     41                final Fight fight = getOrCreate( opponent, false ); 
     42                fight.opponentAttackedByMe(); 
     43                return fight; 
     44        } 
     45 
     46        /** opponent was attacked by myself */ 
     47        public synchronized Fight attackedConfirmed( final String opponent ) { 
     48                final Fight fight = getOrCreate( opponent, false ); 
     49                if( fight.state() != Fight.State.OPPONENT_ATTACKED_BY_ME ) { 
     50                        fight.opponentAttackedByMe(); 
     51                } 
     52                return fight; 
     53        } 
     54 
     55        /** opponent strike back to me */ 
     56        public synchronized Fight opponentStrikedBack( final String opponent ) { 
     57                final Fight fight = getOrCreate( opponent, false ); 
     58                fight.opponentStrikedBack(); 
     59                return fight; 
     60        } 
     61 
     62        public synchronized Fight opponentKilled( final String opponent ) { 
     63                final Fight fight = getOrCreate( opponent ); 
     64                remove( fight ); 
     65                fight.opponentKilled(); 
     66                return fight; 
     67        } 
     68 
     69        public synchronized Fight opponentNotAvailable( final String opponent ) { 
     70                final Fight fight = fightByName.get( opponent ); 
     71                if( fight != null ) { 
     72                        return remove( fight ); 
     73                } else { 
     74                        return null; 
     75                } 
     76        } 
     77 
     78        public synchronized Fight opponentNotAvailable() { 
     79                for( final Fight fight : fights ) { 
     80                        if( fight.state() == OPPONENT_ATTACKED_BY_ME ) { 
     81                                remove( fight ); 
     82                                return fight; 
     83                        } 
     84                } 
     85                return null; 
     86        } 
     87 
     88        public synchronized Fight iWasKilled( final String opponent ) { 
     89                final Fight fight = getOrCreate( opponent ); 
     90                fight.iKilled(); 
     91                clear(); 
     92                return fight; 
     93        } 
     94 
     95        public synchronized Fight opponentEscaped( final String opponent ) { 
     96                final Fight fight = getOrCreate( opponent ); 
     97                fight.opponentEscaped(); 
     98                return fight; 
     99        } 
     100 
     101        public synchronized Fight iEscaped( final String opponent ) { 
     102                final Fight fight = getOrCreate( opponent ); 
     103                fight.iEscaped(); 
     104                return fight; 
     105        } 
     106 
     107        public synchronized void clear() { 
     108                fightByName.clear(); 
     109        } 
     110 
     111        public synchronized void outOfFight() { 
     112                for( final Fight fight : fights ) { 
     113                        if( fight.state() != FREE ) { 
     114                                fight.updateState( FREE ); 
     115                        } 
     116                } 
     117        } 
     118 
     119        public synchronized void dropOutOld( final long timeout ) { 
     120                final List<Fight> toDrop = new ArrayList(); 
     121                for( final Fight fight : fights ) { 
     122                        if( fight.state().isFree() ) { 
     123                                if( fight.age() >= timeout ) { 
     124                                        toDrop.add( fight ); 
     125                                } 
     126                        } 
     127                } 
     128                for( final Fight fight : toDrop ) { 
     129                        remove( fight ); 
     130                } 
     131        } 
     132 
     133        public synchronized int activeFights() { 
     134                int cnt = 0; 
     135                for( final Fight fight : fights ) { 
     136                        if( fight.state() != FREE ) { 
     137                                cnt++; 
     138                        } 
     139                } 
     140                return cnt; 
     141        } 
     142 
     143        public synchronized boolean isDangerous() { 
     144                for( final Fight fight : fights ) { 
     145                        if( !fight.isOpponentZomby() ) { 
     146                                return size() > 1; 
     147                        } 
     148                } 
     149                return false; 
     150        } 
     151 
     152        public synchronized boolean hasNonZombyOpponents() { 
     153                for( final Fight fight : fights ) { 
     154                        if( !fight.isOpponentZomby() ) { 
     155                                return true; 
     156                        } 
     157                } 
     158                return false; 
     159        } 
     160 
     161        public synchronized int size() { 
     162                return fights.size(); 
     163        } 
     164 
     165        /** 
     166         * @return íàèáîëåå àêòóàëüíûé òåêóùèé ïðîòèâíèê. 
     167         *         Â ïåðâóþ î÷åðåäü áåðóòñÿ îïïîíåíòû, íàïàâøèå ñàìè. Âî âòîðóþ -- 
     168         *         ïðîÿâèâøèå èíèöèàòèâó (íå-çîìáè). Äàëåå -- òå, ñ êåì ìû åùå íå 
     169         *         "â ðàñ÷åòå" (state != FREE). Äàëåå êòî ïîïàëî 
     170         */ 
     171        public synchronized Fight actualEnemy() { 
     172                if( empty() ) { 
     173                        return null; 
     174                } 
     175                for( final Fight fight : fights ) { 
     176                        if( fight.isOpponentStarted() ) { 
     177                                return fight; 
     178                        } 
     179                } 
     180                for( final Fight fight : fights ) { 
     181                        if( fight.isOpponentActive() ) { 
     182                                return fight; 
     183                        } 
     184                } 
     185 
     186                Fight f = null; 
     187                for( final Fight fight : fights ) { 
     188                        f = fight; 
     189                        if( fight.state() != FREE ) { 
     190                                return fight; 
     191                        } 
     192                } 
     193                return f; 
     194        } 
     195 
     196        public synchronized boolean canUseHeater() { 
     197                for( final Fight fight : fights ) { 
     198                        if( !fight.state().canHeal() ) { 
     199                                return false; 
     200                        } 
     201                } 
     202                return true; 
     203        } 
     204 
     205        public synchronized boolean canEscape() { 
     206                for( final Fight fight : fights ) { 
     207                        if( !fight.state().canEscape() ) { 
     208                                return false; 
     209                        } 
     210                } 
     211                return true; 
     212        } 
     213 
     214        public synchronized boolean isFree() { 
     215                for( final Fight fight : fights ) { 
     216                        if( !fight.state().isFree() ) { 
     217                                return false; 
     218                        } 
     219                } 
     220                return true; 
     221        } 
     222 
     223        public synchronized boolean isWaitingForOpponent() { 
     224                for( final Fight fight : fights ) { 
     225                        if( fight.state() == Fight.State.OPPONENT_ATTACKED_BY_ME ) { 
     226                                return true; 
     227                        } 
     228                } 
     229                return false; 
     230        } 
     231 
     232        public synchronized boolean canMove() { 
     233                return isFree(); 
     234        } 
     235 
     236        public synchronized boolean empty() { 
     237                return size() == 0; 
     238        } 
     239 
     240        @Override 
     241        public synchronized String toString() { 
     242                final StringBuilder sb = new StringBuilder(); 
     243                for( final Fight fight : fights ) { 
     244                        sb.append( fight ); 
     245                } 
     246                return sb.toString(); 
     247        } 
     248 
     249//      private Fight getOrCreate( final String enemy, 
     250//                                 final Fight.State state ) { 
     251//              Fight fight = fightByName.get( enemy ); 
     252//              if( fight == null ) { 
     253//                      fight = new Fight( registry, enemy, state ); 
     254//                      add( fight ); 
     255//              } else { 
     256//                      fight.updateState( state ); 
     257//              } 
     258//              return fight; 
     259//      } 
     260 
     261        private Fight getOrCreate( final String enemy, 
     262                                   final boolean opponentFirstStrike ) { 
     263                Fight fight = fightByName.get( enemy ); 
     264                if( fight == null ) { 
     265                        fight = new Fight( registry, enemy, opponentFirstStrike, Fight.State.FREE ); 
     266                        add( fight ); 
     267                } 
     268                return fight; 
     269        } 
     270 
     271        private Fight getOrCreate( final String enemy ) { 
     272                Fight fight = fightByName.get( enemy ); 
     273                if( fight == null ) { 
     274                        fight = new Fight( registry, enemy ); 
     275                        add( fight ); 
     276                } 
     277                return fight; 
     278        } 
     279 
     280        private Fight add( final Fight fight ) { 
     281                final String name = fight.opponentName(); 
     282                assert ( !fightByName.containsKey( name ) ); 
     283                fightByName.put( name, fight ); 
     284                fights.add( fight ); 
     285                return fight; 
     286        } 
     287 
     288        private Fight remove( final Fight f ) { 
     289                fightByName.remove( f.opponentName() ); 
     290                fights.remove( f ); 
     291                return f; 
     292        } 
    297293} 
  • SnowBallBot/src/snowball/protocol/ResponseKind.java

    r46 r50  
    1313        ENEMY_ATTACKED_CONFIRMED, 
    1414        ENEMY_NOT_AVAILABLE, 
     15        ENEMY_IN_BAR, 
    1516        ENEMY_ALREADY_ATTACKED, 
    1617 
  • SnowBallBot/src/snowball/protocol/parse/EnemyInBarParser.java

    r46 r50  
    1616                super( 
    1717                                ENEMY_NAME_PATTERN + " ñåé÷àñ íàäèðàåòñÿ â áàðå", 
    18                                 ResponseKind.ENEMY_NOT_AVAILABLE 
     18                                ResponseKind.ENEMY_IN_BAR 
    1919                ); 
    2020        } 
  • SnowBallBot/tests/units/snowball/protocol/parse/EnemyInBarParserTest.java

    r47 r50  
    99 *         created 06.03.2010 at 15:21:07 
    1010 */ 
    11 public class EnemyNotAvailableParserTest extends TestCase { 
     11public class EnemyInBarParserTest extends TestCase { 
    1212        private final EnemyInBarParser parser = new EnemyInBarParser(); 
    1313 
     
    2323                assertNotNull( res ); 
    2424 
    25                 assertEquals( ResponseKind.ENEMY_NOT_AVAILABLE, res.kind() ); 
     25                assertEquals( ResponseKind.ENEMY_IN_BAR, res.kind() ); 
    2626        } 
    2727 
  • SnowBallBot/tests/units/snowball/protocol/parse/EnemyNotAvailableParserTest.java

    r47 r50  
    99 *         created 06.03.2010 at 15:21:07 
    1010 */ 
    11 public class EnemyNotAvailableParser2Test extends TestCase { 
     11public class EnemyNotAvailableParserTest extends TestCase { 
    1212        private final EnemyNotAvailableParser parser = new EnemyNotAvailableParser(); 
    1313 
Note: See TracChangeset for help on using the changeset viewer.