Changeset 47


Ignore:
Timestamp:
03/31/10 07:47:00 (12 years ago)
Author:
BegemoT
Message:
 
Location:
SnowBallBot
Files:
1 added
17 edited
1 moved

Legend:

Unmodified
Added
Removed
  • SnowBallBot

    • Property svn:ignore set to
      SnowBallBot.ipr
      SnowBallBot.iml
      SnowBallBot.iws

      config.properties
  • SnowBallBot/src/snowball/BotRunner.java

    r46 r47  
    22 
    33import java.util.*; 
    4 import java.util.concurrent.TimeUnit; 
    5 import java.util.concurrent.ScheduledExecutorService; 
    64 
    75import snowball.protocol.*; 
     
    1715 * <p/> 
    1816 * Êîëëåêòèâíîå íàïàäåíèå íà âàñþ 
    19  * 
     17 * <p/> 
    2018 * ñòðàòåãèè "ñèäåíèÿ â ñóãðîáå/áàðå" è "àêòèâíîãî íàïàäåíèÿ" 
    2119 * 
     
    2422 */ 
    2523public class BotRunner implements Runnable, IProtocolListener { 
    26     private final Log log = LogFactory.getLog( BotRunner.class ); 
     24    private static final Log LOG = LogFactory.getLog( BotRunner.class ); 
     25 
     26    private final Log log; 
     27 
    2728 
    2829    private static final long QUERY_INFO_TIMEOUT = 240000;  //4min 
     
    4445 
    4546    private final Protocol protocol; 
     47 
     48    private final IBehaviorStrategy strategy = new IBehaviorStrategy(){ 
     49 
     50    }; 
    4651 
    4752    private final PeopleRegistry peopleRegistry; 
     
    5156                      final Protocol protocol, 
    5257                      final PeopleRegistry peopleRegistry ) { 
     58        this.log = LogFactory.getLog( BotRunner.class.getName() + "[" + name + "]" ); 
    5359        this.name = name; 
    5460        this.protocol = protocol; 
     
    5864 
    5965        enemyFinder = new EnemyFinder( 
     66                name, 
    6067                peopleRegistry, 
    6168                protocol, 
     
    103110 
    104111    private int experience = 120; 
     112 
     113 
    105114 
    106115    private void updateInfo( final UnitInfo info ) { 
     
    230239                    break; 
    231240                case ENEMY_STRIKED_BACK: { 
    232                     final EnemyResponse eres = ( EnemyResponse )r.data(); 
     241                    final EnemyStrikeBack eres = ( EnemyStrikeBack )r.data(); 
    233242                    updatePlace( Place.STREET ); 
    234243                    final String enemy = eres.enemyName(); 
     
    240249                        log.info( "It seems to be dangerous on the street -> go bar" ); 
    241250                        tryToHideInBar(); 
     251                    } else if ( isVeryLowHealth() ) { 
     252                        log.info( "It seems to be cold(" + temperature + ") on the street -> go bar" ); 
     253                        tryToHideInBar(); 
    242254                    } else { 
    243255                        heatIfRequired(); 
     
    259271                } 
    260272                case ENEMY_ESCAPING: { 
    261                     final EnemyResponse eres = ( EnemyResponse )r.data(); 
     273                    final EnemyStrikeBack eres = ( EnemyStrikeBack )r.data(); 
    262274                    updatePlace( Place.STREET ); 
    263275                    //updateState( State.IN_THE_FIGHT ); 
     
    531543    } 
    532544 
     545    private boolean isVeryLowHealth() { 
     546        return temperature < ONE_SHOT_DAMAGE; 
     547    } 
     548 
    533549    private boolean isEnemyWeaker( final UnitInfo enemy ) { 
    534550        final double ep = Commons.enemyPower( enemy.experience() ); 
     
    546562    public void attack( final String name ) throws Exception { 
    547563        enemyFinder.clear(); 
    548         //actualEnemy = name; 
    549564        fights.attacked( name ); 
    550565        protocol.attack( name ); 
    551         //updateState( State.ATTACKED ); 
    552566        lastAttack = System.currentTimeMillis(); 
    553567        log.info( " -> attack(" + name + ")" ); 
     
    645659        log.info( 
    646660                String.format( 
    647                         "@%s, %s\u00B0, %s", 
    648                         place, temperature, fights 
     661                        "%s(@%s, %f\u00B0, %d) %s", 
     662                        name, 
     663                        place, temperature, experience, 
     664                        fights 
    649665                ) 
    650666        ); 
  • SnowBallBot/src/snowball/EnemyStrikeBack.java

    r46 r47  
    22 
    33/** 
     4 * @immutable 
    45 * @author ruslan 
    56 *         created 06.03.2010 at 16:12:08 
    67 */ 
    7 public class EnemyResponse { 
     8public final class EnemyStrikeBack { 
    89        private final String name; 
    910        private final double ownHealthLost; 
    1011        private final double enemyHealthLost; 
    1112 
    12         public EnemyResponse( final String name, 
     13        public EnemyStrikeBack( final String name, 
    1314                              final double ownHealthLost, 
    1415                              final double enemyHealthLost ) { 
     
    1819        } 
    1920 
    20         public String enemyName() { 
     21    public String enemyName() { 
    2122                return name; 
    2223        } 
  • SnowBallBot/src/snowball/Main.java

    r46 r47  
    1515import snowball.protocol.Protocol; 
    1616import org.jivesoftware.smack.proxy.ProxyInfo; 
    17 import org.jivesoftware.smack.XMPPException; 
    1817import org.apache.commons.logging.LogFactory; 
    1918import org.apache.commons.logging.Log; 
     
    7473 
    7574            final Protocol protocol = new Protocol( 
    76                     server, port, service, 
    77                     login, password, tag, 
     75                    tag, server, port, service, 
     76                    login, password, 
    7877                    gameServer, proxyInfo 
    7978            ); 
  • SnowBallBot/src/snowball/UnitInfo.java

    r46 r47  
    44 
    55/** 
     6 * @immutable 
    67 * @author ruslan 
    78 *         created 05.03.2010 at 21:27:40 
     
    3132    } 
    3233 
    33     //public void setName( final String name ) { 
    34     //    this.name = name; 
    35     //} 
    36  
    3734    public double temperature() { 
    3835        return temperature; 
    3936    } 
    40  
    41     //public void setTemperature( final double temperature ) { 
    42     //    this.temperature = temperature; 
    43     //} 
    4437 
    4538    public int experience() { 
     
    4740    } 
    4841 
    49     //public void setExperience( final int experience ) { 
    50     //    this.experience = experience; 
    51     //} 
    52  
    5342    public Place place() { 
    5443        return place; 
    5544    } 
    5645 
    57     //public void setPlace( final Place place ) { 
    58     //    this.place = place; 
    59     //} 
    60  
    6146    public long timestamp() { 
    6247        return timestamp; 
    6348    } 
    64  
    65     //public void updateTimestamp() { 
    66     //    timestamp = System.currentTimeMillis(); 
    67     //} 
    6849 
    6950    public boolean equals( final Object o ) { 
  • SnowBallBot/src/snowball/helpers/EnemyFinder.java

    r46 r47  
    99import org.apache.commons.logging.Log; 
    1010import snowball.UnitInfo; 
    11 import snowball.helpers.PeopleRegistry; 
    1211import snowball.Place; 
    1312import snowball.protocol.Protocol; 
    1413 
    1514/** 
    16  * Class 
     15 * todo èñêëþ÷èòü ãåíåðàöèþ îäèíàêîâûõ êàíäèäàòîâ â ðàçíûõ ýêçåìïëÿðàõ 
    1716 * User: BegemoT<br/> 
    1817 * Date: 24.03.2010<br/> 
     
    2019 */ 
    2120public class EnemyFinder { 
    22         private static final Log log = LogFactory.getLog( EnemyFinder.class ); 
     21    /** 
     22     * "looking for" state expiration period. 
     23     */ 
     24    private static final int EXPIRATION_PERIOD = 180000; 
    2325 
    24         private static final int EXPIRATION_PERIOD = 180000; 
    25         /** one-time prefetch user count. must be < MAX_QUERIES */ 
    26         private static final int PREFETCH = 6; 
    27         private static final int MIN_COUNT = 6; 
     26    /** 
     27     * one-time prefetch user count 
     28     */ 
     29    private static final int PREFETCH = 6; 
     30    private static final int MIN_COUNT = 6; 
    2831 
    29         private final List<UnitInfo> infos = new ArrayList(); 
    30         private UnitInfo mostWanted; 
     32    private final Log log; 
    3133 
    32         private boolean started; 
    33         private long queryStartedTimestamp = -1; 
     34    private final List<UnitInfo> infos = new ArrayList(); 
     35    private UnitInfo mostWanted; 
    3436 
    35         //private long lastLookedForEnemy = -1; 
    36         private final List<String> toQuery = new ArrayList(); 
    37         private final List<String> waitingFor = new ArrayList(); 
     37    private boolean started; 
     38    private long queryStartedTimestamp = -1; 
    3839 
    39         private final PeopleRegistry registry; 
    40         private final Protocol protocol; 
     40    //private long lastLookedForEnemy = -1; 
     41    private final List<String> toQuery = new ArrayList(); 
     42    private final List<String> waitingFor = new ArrayList(); 
    4143 
    42         private final IPeopleFilter okFilter; 
    43         private final Comparator<UnitInfo> opponentComparator; 
     44    private final PeopleRegistry registry; 
     45    private final Protocol protocol; 
    4446 
    45         public EnemyFinder( final PeopleRegistry registry, 
    46                             final Protocol protocol, 
    47                             final IPeopleFilter okFilter, 
    48                             final Comparator<UnitInfo> opponentComparator ) { 
    49                 this.registry = registry; 
    50                 this.protocol = protocol; 
    51                 this.okFilter = okFilter; 
    52                 this.opponentComparator = opponentComparator; 
    53         } 
     47    private final IPeopleFilter okFilter; 
     48    private final Comparator<UnitInfo> opponentComparator; 
    5449 
    55         public boolean investigate() throws Exception { 
    56                 if( started ) { 
    57                         throw new IllegalStateException( "Already looking for enemies" ); 
    58                 } 
    59                 final List<String> candidates = registry.suggestCandidates( PREFETCH ); 
    60                 if( !candidates.isEmpty() ) { 
    61                         clear(); 
     50    public EnemyFinder( final String name, 
     51                        final PeopleRegistry registry, 
     52                        final Protocol protocol, 
     53                        final IPeopleFilter okFilter, 
     54                        final Comparator<UnitInfo> opponentComparator ) { 
     55        log = LogFactory.getLog( EnemyFinder.class.getName() + "[" + name + "]" ); 
    6256 
    63                         started = true; 
    64                         toQuery.addAll( candidates ); 
    65                         queryStartedTimestamp = System.currentTimeMillis(); 
     57        this.registry = registry; 
     58        this.protocol = protocol; 
     59        this.okFilter = okFilter; 
     60        this.opponentComparator = opponentComparator; 
     61    } 
    6662 
    67                         log.info( "Querying " + toQuery.size() + " people's info:" ); 
    68                         for( final String name : toQuery ) { 
    69                                 queryInfo( protocol, name ); 
    70                         } 
    71                         return true; 
    72                 } else { 
    73                         log.info( "No candidates to kill -- waiting" ); 
    74                         return false; 
    75                 } 
    76         } 
     63    public boolean investigate() throws Exception { 
     64        if ( started ) { 
     65            throw new IllegalStateException( "Already looking for enemies" ); 
     66        } 
     67        final List<String> candidates = registry.suggestCandidates( PREFETCH ); 
     68        if ( !candidates.isEmpty() ) { 
     69            clear(); 
    7770 
    78         public boolean update( final UnitInfo people ) throws Exception { 
    79                 final String name = people.name(); 
    80                 if( waitingFor.contains( name ) ) { 
    81                         waitingFor.remove( name ); 
    82                         if( people.place() == Place.STREET 
    83                                         && okFilter.appropriate( people ) ) { 
    84                                 if( registry.isMostWanted( name ) ) { 
    85                                         mostWanted = people; 
    86                                         started = false; 
    87                                         return true; 
    88                                 } else { 
    89                                         infos.add( people ); 
    90                                 } 
    91                         } else { 
    92                                 log.info( "enemy(" + name + ") unappropriate" ); 
    93                         } 
    94                         final int total = waitingFor.size() + infos.size(); 
    95                         if( total < MIN_COUNT ) { 
    96                                 for( int i = 0; i < MIN_COUNT - total; i++ ) { 
    97                                         final String suggested = registry.suggestNext(); 
    98                                         if( suggested == null ) { 
    99                                                 break; 
    100                                         } 
    101                                         queryInfo( protocol, suggested ); 
    102                                 } 
    103                         } 
    104                 } else { 
    105                         log.warn( "Out of query info: " + people ); 
    106                 } 
    107                 if( waitingFor.isEmpty() && started ) { 
    108                         started = false; 
    109                         return true; 
    110                 } else { 
    111                         return false; 
    112                 } 
    113         } 
     71            started = true; 
     72            toQuery.addAll( candidates ); 
     73            queryStartedTimestamp = System.currentTimeMillis(); 
    11474 
    115         public String chooseOpponent() { 
    116                 if( started ) { 
    117                         throw new IllegalStateException( "Still running" ); 
    118                 } 
    119                 if( mostWanted != null ) { 
    120                         return mostWanted.name(); 
    121                 } 
    122                 Collections.sort( infos, opponentComparator ); 
    123                 final UnitInfo opponent = infos.remove( 0 ); 
    124                 return opponent.name(); 
    125         } 
     75            log.info( "Querying " + toQuery.size() + " people's info:" ); 
     76            for ( final String name : toQuery ) { 
     77                queryInfo( protocol, name ); 
     78            } 
     79            return true; 
     80        } else { 
     81            log.info( "No candidates to kill -- waiting" ); 
     82            return false; 
     83        } 
     84    } 
    12685 
    127         private void queryInfo( final Protocol p, 
    128                                 final String name ) throws Exception { 
    129                 p.queryEnemyInfo( name ); 
    130                 log.info( " -> info(" + name + ")" ); 
    131                 waitingFor.add( name ); 
    132         } 
     86    public boolean update( final UnitInfo people ) throws Exception { 
     87        final String name = people.name(); 
     88        if ( waitingFor.contains( name ) ) { 
     89            waitingFor.remove( name ); 
     90            if ( people.place() == Place.STREET 
     91                    && okFilter.appropriate( people ) ) { 
     92                if ( registry.isMostWanted( name ) ) { 
     93                    mostWanted = people; 
     94                    started = false; 
     95                    return true; 
     96                } else { 
     97                    infos.add( people ); 
     98                } 
     99            } else { 
     100                log.info( "enemy(" + name + ") unappropriate" ); 
     101            } 
     102            final int total = waitingFor.size() + infos.size(); 
     103            if ( total < MIN_COUNT ) { 
     104                for ( int i = 0; i < MIN_COUNT - total; i++ ) { 
     105                    final String suggested = registry.suggestNext(); 
     106                    if ( suggested == null ) { 
     107                        break; 
     108                    } 
     109                    queryInfo( protocol, suggested ); 
     110                } 
     111            } 
     112        } else { 
     113            log.warn( "Out of query info: " + people ); 
     114        } 
     115        if ( waitingFor.isEmpty() && started ) { 
     116            started = false; 
     117            return true; 
     118        } else { 
     119            return false; 
     120        } 
     121    } 
    133122 
    134         public boolean isLooking() { 
    135                 return started; 
    136         } 
     123    public String chooseOpponent() { 
     124        if ( started ) { 
     125            throw new IllegalStateException( "Still running" ); 
     126        } 
     127        if ( mostWanted != null ) { 
     128            return mostWanted.name(); 
     129        } 
     130        Collections.sort( infos, opponentComparator ); 
     131        final UnitInfo opponent = infos.remove( 0 ); 
     132        return opponent.name(); 
     133    } 
    137134 
    138         //public boolean isFinished() { 
    139         //    return waitingFor.isEmpty(); 
    140         //} 
     135    private void queryInfo( final Protocol p, 
     136                            final String name ) throws Exception { 
     137        p.queryEnemyInfo( name ); 
     138        log.info( " -> info(" + name + ")" ); 
     139        waitingFor.add( name ); 
     140    } 
    141141 
    142         public boolean isExpired() { 
    143                 return ( System.currentTimeMillis() - queryStartedTimestamp ) >= EXPIRATION_PERIOD; 
    144         } 
     142    public boolean isLooking() { 
     143        return started; 
     144    } 
    145145 
    146         public void reset() { 
    147                 waitingFor.clear(); 
    148         } 
     146    //public boolean isFinished() { 
     147    //    return waitingFor.isEmpty(); 
     148    //} 
    149149 
    150         public void clear() { 
    151                 started = false; 
    152                 queryStartedTimestamp = -1; 
     150    public boolean isExpired() { 
     151        return ( System.currentTimeMillis() - queryStartedTimestamp ) >= EXPIRATION_PERIOD; 
     152    } 
    153153 
    154                 waitingFor.clear(); 
    155                 toQuery.clear(); 
     154    public void reset() { 
     155        waitingFor.clear(); 
     156    } 
    156157 
    157                 mostWanted = null; 
    158         } 
     158    public void clear() { 
     159        started = false; 
     160        queryStartedTimestamp = -1; 
     161 
     162        waitingFor.clear(); 
     163        toQuery.clear(); 
     164 
     165        mostWanted = null; 
     166    } 
    159167} 
  • SnowBallBot/src/snowball/helpers/PeopleRegistry.java

    r46 r47  
    1515 */ 
    1616public class PeopleRegistry { 
    17         private static final Log log = LogFactory.getLog( PeopleRegistry.class ); 
    18  
    19         //private static final long EL_QUERY_EXPIRED = 180000;//3min 
    20         private static final int PL_EXPIRED_PERIOD = 120000; 
    21         //private static final int EL_EXPIRED = 120000; 
    22  
    23         /** íèêîãäà íå íàïàäàåì */ 
    24         private static final List<String> FRIENDS = Arrays.asList( 
    25                         "r.suhomlinov", 
    26                         "BegemoT", 
    27                         "cheremin", 
    28                         "kotobaba"/*, 
     17    private static final Log log = LogFactory.getLog( PeopleRegistry.class ); 
     18 
     19    //private static final long EL_QUERY_EXPIRED = 180000;//3min 
     20    private static final int PL_EXPIRED_PERIOD = 120000; 
     21    //private static final int EL_EXPIRED = 120000; 
     22 
     23    /** 
     24     * íèêîãäà íå íàïàäàåì 
     25     */ 
     26    private static final List<String> FRIENDS = Arrays.asList( 
     27            "r.suhomlinov", 
     28            "BegemoT", 
     29            "cheremin", 
     30            "kotobaba"/*, 
    2931            "feyaolya"*/ 
    30         ); 
    31  
    32         /** ñàìûå, ñöóêî, ïèäîðàñû */ 
    33         private static final List<String> MOST_WANTED = Arrays.asList( 
    34                         "v_vasia", 
    35                         "Orfest" 
    36         ); 
    37  
    38  
    39         /** ýòèõ ïðîñòî ïðèÿòíî ïèçäèòü */ 
    40         private static final List<String> TOP = Arrays.asList( 
    41                         "v_vasia", 
    42                         "Fog", 
    43                         "Orfest", 
    44                         "asbest884", 
    45                         "qwmpo", 
    46                         "ken_88", 
    47                         "yur4enko" 
    48         ); 
    49  
    50         /** åñëè äîñòóïíûõ âðàãîâ íåò -- èùåì ýòèõ */ 
    51         private static final List<String> FIRST_CLASS_CANDIDATES = union( 
    52                         MOST_WANTED, 
    53                         TOP, 
    54                         Arrays.asList( 
    55                                         "v_vasia", 
    56                                         "Orfest", 
    57                                         "tgmka", 
    58                                         "terminator", 
    59                                         "elenka_motyl", 
    60                                         "snegovik", 
    61                                         "DenisKo", 
    62                                         "Yason", 
    63                                         "whiteapt", 
    64                                         "bigh0use", 
    65                                         "440284239", 
    66                                         "spartak.cham", 
    67                                         "garik", 
    68                                         "qwmpo", 
    69                                         "Fog", 
    70                                         "asbest884", 
    71                                         "ken_88", 
    72                                         "mike", 
    73                                         "491504474", 
    74                                         "stah", 
    75                                         "m_o_z_i_a", 
    76                                         "MAKAPOH", 
    77                                         "kirdik", 
    78                                         "batora", 
    79                                         "macron" 
    80                         ) 
    81         ); 
    82  
    83         private static final String STATS_FILE_NAME = "stats.txt"; 
    84         private static final String PARAMS_FILE_NAME = "params"; 
    85  
    86         private final List<String> peopleOnTheStreet = new ArrayList<String>(); 
    87  
    88         private volatile long peopleListTimestamp = -1; 
    89         private final Map<String, UnitInfo> people = new HashMap(); 
    90  
    91         private final List<UnitInfo> prioritized; 
    92  
    93         public PeopleRegistry() { 
    94                 final File file = new File( PARAMS_FILE_NAME ); 
    95                 List<UnitInfo> prioritized = null; 
    96                 if( file.exists() && file.length() > 0 ) { 
    97                         try { 
    98                                 final FileInputStream fis = new FileInputStream( file ); 
    99                                 try { 
    100                                         final ObjectInputStream ois = new ObjectInputStream( fis ); 
    101                                         prioritized = ( List<UnitInfo> ) ois.readObject(); 
    102                                 } finally { 
    103                                         fis.close(); 
    104                                 } 
    105                         } catch( Exception e ) { 
    106                                 log.error( "can't load params", e ); 
    107                         } 
    108                 } 
    109                 if( prioritized == null ) { 
    110                         this.prioritized = new ArrayList(); 
    111                 } else { 
    112                         this.prioritized = prioritized; 
    113                         for( final UnitInfo info : prioritized ) { 
    114                                 people.put( info.name(), info ); 
    115                         } 
    116                 } 
    117         } 
    118  
    119         public boolean isMostWanted( final String name ) { 
    120                 return MOST_WANTED.contains( name ); 
    121         } 
    122  
    123     public Iterable<String> mostWanted(){ 
     32    ); 
     33 
     34    /** 
     35     * ñàìûå, ñöóêî, ïèäîðàñû 
     36     */ 
     37    private static final List<String> MOST_WANTED = Arrays.asList( 
     38            "v_vasia", 
     39            "Orfest" 
     40    ); 
     41 
     42 
     43    /** 
     44     * ýòèõ ïðîñòî ïðèÿòíî ïèçäèòü 
     45     */ 
     46    private static final List<String> TOP = Arrays.asList( 
     47            "v_vasia", 
     48            "Fog", 
     49            "Orfest", 
     50            "asbest884", 
     51            "qwmpo", 
     52            "ken_88", 
     53            "yur4enko" 
     54    ); 
     55 
     56    /** 
     57     * åñëè äîñòóïíûõ âðàãîâ íåò -- èùåì ýòèõ 
     58     */ 
     59    private static final List<String> FIRST_CLASS_CANDIDATES = union( 
     60            MOST_WANTED, 
     61            TOP, 
     62            Arrays.asList( 
     63                    "v_vasia", 
     64                    "Orfest", 
     65                    "tgmka", 
     66                    "terminator", 
     67                    "elenka_motyl", 
     68                    "snegovik", 
     69                    "DenisKo", 
     70                    "Yason", 
     71                    "whiteapt", 
     72                    "bigh0use", 
     73                    "440284239", 
     74                    "spartak.cham", 
     75                    "garik", 
     76                    "qwmpo", 
     77                    "Fog", 
     78                    "asbest884", 
     79                    "ken_88", 
     80                    "mike", 
     81                    "491504474", 
     82                    "stah", 
     83                    "m_o_z_i_a", 
     84                    "MAKAPOH", 
     85                    "kirdik", 
     86                    "batora", 
     87                    "macron" 
     88            ) 
     89    ); 
     90 
     91    private static final String STATS_FILE_NAME = "stats.txt"; 
     92    private static final String PARAMS_FILE_NAME = "params"; 
     93 
     94    private final List<String> peopleOnTheStreet = new ArrayList<String>(); 
     95 
     96    private volatile long peopleListTimestamp = -1; 
     97    private final Map<String, UnitInfo> people = new HashMap(); 
     98 
     99    private final List<UnitInfo> prioritized; 
     100 
     101    public PeopleRegistry() { 
     102        final File file = new File( PARAMS_FILE_NAME ); 
     103        List<UnitInfo> prioritized = load( file ); 
     104        if ( prioritized == null ) { 
     105            this.prioritized = new ArrayList(); 
     106        } else { 
     107            this.prioritized = prioritized; 
     108            for ( final UnitInfo info : prioritized ) { 
     109                people.put( info.name(), info ); 
     110            } 
     111        } 
     112    } 
     113 
     114    public boolean isMostWanted( final String name ) { 
     115        return MOST_WANTED.contains( name ); 
     116    } 
     117 
     118    public Iterable<String> mostWanted() { 
    124119        return MOST_WANTED; 
    125120    } 
    126121 
    127         public boolean isTop( final String name ) { 
    128                 return TOP.contains( name ); 
    129         } 
    130  
    131         public UnitInfo get( final String name ) { 
    132                 return people.get( name ); 
    133         } 
    134  
    135         public synchronized UnitInfo update( final String name, 
    136                                              final double temp, 
    137                                              final int exp, 
    138                                              final Place place ) { 
    139                 final UnitInfo info = new UnitInfo( name, temp, exp, place ); 
    140                 return update( info ); 
    141         } 
    142  
    143         public synchronized UnitInfo update( final UnitInfo info ) { 
    144                 people.put( info.name(), info ); 
    145                 if( info.place() != Place.STREET ) { 
    146                         peopleOnTheStreet.remove( info.name() ); 
    147                 } 
    148                 save(); 
    149                 return info; 
    150         } 
    151  
    152         public synchronized void updatePeopleList( final List<String> enemies ) { 
    153                 peopleListTimestamp = System.currentTimeMillis(); 
    154                 final List<String> newEnemies = new ArrayList( enemies ); 
    155                 newEnemies.removeAll( FRIENDS ); 
    156                 if( !newEnemies.isEmpty() ) { 
    157                         peopleOnTheStreet.clear(); 
    158                         peopleOnTheStreet.addAll( newEnemies ); 
    159                         Collections.shuffle( peopleOnTheStreet, Util.random() ); 
    160                 } else { 
    161                         //îñòàâëÿåì ñòàðûé ñïèñîê -- âäðóã ïðîêàòèò? 
    162                 } 
    163         } 
    164  
    165         public long peopleListAge() { 
    166                 return System.currentTimeMillis() - peopleListTimestamp; 
    167         } 
    168  
    169         public boolean peopleListExpired() { 
    170                 return peopleListAge() >= PL_EXPIRED_PERIOD; 
    171         } 
    172  
    173         //todo prioritized candidates based on their experience 
    174         public synchronized List<String> suggestCandidates( final int count ) { 
    175                 final List<String> res; 
    176                 if( peopleOnTheStreet.isEmpty() ) { 
    177                         log.info( "No new enemies -- look for somebody known" ); 
    178                         res = new ArrayList( FIRST_CLASS_CANDIDATES ); 
    179                 } else if( !peopleOnTheStreet.isEmpty() ) { 
    180                         res = new ArrayList(); 
    181                         final int len = peopleOnTheStreet.size(); 
    182  
    183                         //first of all use most-wanted 
    184                         final int cnt = Math.min( count, len ); 
    185                         res.addAll( MOST_WANTED ); 
    186  
    187                         //next choose from shuffled list 
    188                         for( int i = 0; i < cnt; i++ ) { 
    189                                 final String name = peopleOnTheStreet.remove( len - 1 ); 
    190                                 //and move them to the end of queue 
    191                                 peopleOnTheStreet.add( 0, name ); 
    192  
    193                                 res.add( name ); 
    194                         } 
    195                 } else { 
    196                         res = Collections.emptyList(); 
    197                 } 
    198                 return res; 
    199         } 
    200  
    201         public synchronized String suggestNext() { 
    202                 if( peopleOnTheStreet.isEmpty() ) { 
    203                         return null; 
    204                 } else { 
    205                         final int len = peopleOnTheStreet.size(); 
    206                         final String last = peopleOnTheStreet.remove( len - 1 ); 
    207                         peopleOnTheStreet.add( 0, last ); 
    208                         return last; 
    209                 } 
    210         } 
    211  
    212         public int size() { 
    213                 return peopleOnTheStreet.size(); 
    214         } 
    215  
    216         private static List<String> union( final List<String>... arrs ) { 
    217                 final Set<String> res = new HashSet<String>(); 
    218                 for( List<String> arr : arrs ) { 
    219                         for( String name : arr ) { 
    220                                 res.add( name ); 
    221                         } 
    222                 } 
    223                 return Collections.unmodifiableList( new ArrayList( res ) ); 
    224         } 
    225  
    226         private int saveCalledCount = 0; 
    227  
    228         private synchronized void save() { 
    229                 saveCalledCount++; 
    230                 if( saveCalledCount % 5 == 0 ) { 
    231                         prioritized.clear(); 
    232                         prioritized.addAll( people.values() ); 
    233                         Collections.sort( prioritized, Commons.EXPERIENCE_COMPARATOR ); 
    234                         try { 
    235                                 final FileWriter fw = new FileWriter( STATS_FILE_NAME ); 
    236                                 try { 
    237                                         for( UnitInfo unit : prioritized ) { 
    238                                                 fw.write( 
    239                                                                 String.format( 
    240                                                                                 "%s, %d, %s\n", 
    241                                                                                 unit.name(), 
    242                                                                                 unit.experience(), 
    243                                                                                 unit.place() 
    244                                                                 ) 
    245                                                 ); 
    246                                         } 
    247                                 } finally { 
    248                                         fw.close(); 
    249                                 } 
    250                                 final OutputStream fos = new FileOutputStream( PARAMS_FILE_NAME ); 
    251                                 try { 
    252                                         final ObjectOutputStream oos = new ObjectOutputStream( fos ); 
    253                                         oos.writeObject( prioritized ); 
    254                                         oos.flush(); 
    255                                 } finally { 
    256                                         fos.close(); 
    257                                 } 
    258                         } catch( IOException e ) { 
    259                                 log.error( "IO", e ); 
    260                         } 
    261                 } 
    262         } 
     122    public boolean isTop( final String name ) { 
     123        return TOP.contains( name ); 
     124    } 
     125 
     126    public UnitInfo get( final String name ) { 
     127        return people.get( name ); 
     128    } 
     129 
     130    public synchronized UnitInfo update( final String name, 
     131                                         final double temp, 
     132                                         final int exp, 
     133                                         final Place place ) { 
     134        final UnitInfo info = new UnitInfo( name, temp, exp, place ); 
     135        return update( info ); 
     136    } 
     137 
     138    public synchronized UnitInfo update( final UnitInfo info ) { 
     139        people.put( info.name(), info ); 
     140        if ( info.place() != Place.STREET ) { 
     141            peopleOnTheStreet.remove( info.name() ); 
     142        } 
     143        save(); 
     144        return info; 
     145    } 
     146 
     147    public synchronized void updatePeopleList( final List<String> enemies ) { 
     148        peopleListTimestamp = System.currentTimeMillis(); 
     149        final List<String> newEnemies = new ArrayList( enemies ); 
     150        newEnemies.removeAll( FRIENDS ); 
     151        if ( !newEnemies.isEmpty() ) { 
     152            peopleOnTheStreet.clear(); 
     153            peopleOnTheStreet.addAll( newEnemies ); 
     154            Collections.shuffle( peopleOnTheStreet, Util.random() ); 
     155        } else { 
     156            //îñòàâëÿåì ñòàðûé ñïèñîê -- âäðóã ïðîêàòèò? 
     157        } 
     158    } 
     159 
     160    public long peopleListAge() { 
     161        return System.currentTimeMillis() - peopleListTimestamp; 
     162    } 
     163 
     164    public boolean peopleListExpired() { 
     165        return peopleListAge() >= PL_EXPIRED_PERIOD; 
     166    } 
     167 
     168    //todo prioritized candidates based on their experience 
     169    public synchronized List<String> suggestCandidates( final int count ) { 
     170        final List<String> res; 
     171        if ( peopleOnTheStreet.isEmpty() ) { 
     172            log.info( "No new enemies -- look for somebody known" ); 
     173            res = new ArrayList( FIRST_CLASS_CANDIDATES ); 
     174        } else if ( !peopleOnTheStreet.isEmpty() ) { 
     175            res = new ArrayList(); 
     176            final int len = peopleOnTheStreet.size(); 
     177 
     178            //first of all use most-wanted 
     179            final int cnt = Math.min( count, len ); 
     180            res.addAll( MOST_WANTED ); 
     181 
     182            //next choose from shuffled list 
     183            for ( int i = 0; i < cnt; i++ ) { 
     184                final String name = peopleOnTheStreet.remove( len - 1 ); 
     185                //and move them to the end of queue 
     186                peopleOnTheStreet.add( 0, name ); 
     187 
     188                res.add( name ); 
     189            } 
     190        } else { 
     191            res = Collections.emptyList(); 
     192        } 
     193        return res; 
     194    } 
     195 
     196    public synchronized String suggestNext() { 
     197        if ( peopleOnTheStreet.isEmpty() ) { 
     198            return null; 
     199        } else { 
     200            final int len = peopleOnTheStreet.size(); 
     201            final String last = peopleOnTheStreet.remove( len - 1 ); 
     202            peopleOnTheStreet.add( 0, last ); 
     203            return last; 
     204        } 
     205    } 
     206 
     207    public int size() { 
     208        return peopleOnTheStreet.size(); 
     209    } 
     210 
     211    private static List<String> union( final List<String>... arrs ) { 
     212        final Set<String> res = new HashSet<String>(); 
     213        for ( List<String> arr : arrs ) { 
     214            for ( String name : arr ) { 
     215                res.add( name ); 
     216            } 
     217        } 
     218        return Collections.unmodifiableList( new ArrayList( res ) ); 
     219    } 
     220 
     221    private int saveCalledCount = 0; 
     222 
     223    private static final boolean useSerialization = true; 
     224 
     225    private static List<UnitInfo> load( final File file ) { 
     226        final List<UnitInfo> res = new ArrayList(); 
     227        if ( file.exists() && file.length() > 0 ) { 
     228            try { 
     229                final FileInputStream fis = new FileInputStream( file ); 
     230                try { 
     231                    if ( useSerialization ) { 
     232                        final ObjectInputStream ois = new ObjectInputStream( fis ); 
     233                        return ( List<UnitInfo> )ois.readObject(); 
     234                    } else { 
     235                        final BufferedReader r = new BufferedReader( new InputStreamReader( fis ) ); 
     236                        try { 
     237                            final String line = r.readLine(); 
     238                            final String[] parts = line.split( "\\s*,\\s*" ); 
     239                            final String name = parts[0]; 
     240                            final int exp = Integer.parseInt( parts[1] ); 
     241                            final double temp = Double.parseDouble( parts[2] ); 
     242                            final Place place = Place.valueOf( parts[3] ); 
     243                            res.add( new UnitInfo( name, temp, exp, place ) ); 
     244                        } finally { 
     245                            r.close(); 
     246                        } 
     247                    } 
     248                } finally { 
     249                    fis.close(); 
     250                } 
     251            } catch ( Exception e ) { 
     252                log.error( "can't load params", e ); 
     253            } 
     254        } 
     255        return res; 
     256    } 
     257 
     258    private synchronized void save() { 
     259        saveCalledCount++; 
     260        if ( saveCalledCount % 5 == 0 ) { 
     261            prioritized.clear(); 
     262            prioritized.addAll( people.values() ); 
     263            Collections.sort( prioritized, Commons.EXPERIENCE_COMPARATOR ); 
     264            try { 
     265                final FileWriter fw = new FileWriter( STATS_FILE_NAME ); 
     266                try { 
     267                    for ( UnitInfo unit : prioritized ) { 
     268                        fw.write( 
     269                                String.format( 
     270                                        "%s, %d, %f, %s\n", 
     271                                        unit.name(), 
     272                                        unit.experience(), 
     273                                        unit.temperature(), 
     274                                        unit.place() 
     275                                ) 
     276                        ); 
     277                    } 
     278                } finally { 
     279                    fw.close(); 
     280                } 
     281                final OutputStream fos = new FileOutputStream( PARAMS_FILE_NAME ); 
     282                try { 
     283                    final ObjectOutputStream oos = new ObjectOutputStream( fos ); 
     284                    oos.writeObject( prioritized ); 
     285                    oos.flush(); 
     286                } finally { 
     287                    fos.close(); 
     288                } 
     289            } catch ( IOException e ) { 
     290                log.error( "IO", e ); 
     291            } 
     292        } 
     293    } 
    263294} 
  • SnowBallBot/src/snowball/protocol/Protocol.java

    r46 r47  
    2020public class Protocol implements MessageListener, 
    2121                                 ConnectionListener { 
    22     private static final Log log = LogFactory.getLog( Protocol.class ); 
    23     private static final Log incomingLog = LogFactory.getLog( Protocol.class.getName() + ".INCOMING" ); 
     22    private final Log log; 
     23    private final Log incomingLog; 
    2424 
    2525    static { 
     
    4343    private transient String threadID; 
    4444 
    45     public Protocol( final String jabberServer, 
     45    public Protocol( final String name, 
     46                     final String jabberServer, 
    4647                     final int jabberPort, 
    4748                     final String jabberResource, 
    4849                     final String login, 
    4950                     final String password, 
    50                      final String tag, 
    5151                     final String gameAddress ) throws Exception { 
    5252        this( 
     53                name, 
    5354                jabberServer, jabberPort, jabberResource, 
    54                 login, password, tag, 
     55                login, password, 
    5556                gameAddress, 
    5657                null 
     
    5859    } 
    5960 
    60     public Protocol( final String jabberServer, 
     61    public Protocol( final String name, 
     62                     final String jabberServer, 
    6163                     final int jabberPort, 
    6264                     final String jabberResource, 
    6365                     final String login, 
    6466                     final String password, 
    65                      final String tag, 
    6667                     final String gameAddress, 
    6768                     final ProxyInfo proxyInfo ) throws Exception { 
     69        this.name = name; 
     70 
     71        final String className = Protocol.class.getName(); 
     72        log = LogFactory.getLog( className + "[" + name + "]" ); 
     73        incomingLog = LogFactory.getLog( className + "[" + name + "].INCOMING" ); 
     74 
    6875        this.gameAddress = gameAddress; 
     76 
    6977        this.login = login; 
    7078        this.password = password; 
    71         this.name = tag; 
    7279 
    7380        if ( proxyInfo != null ) { 
  • SnowBallBot/src/snowball/protocol/parse/EnemyAttackedParser.java

    r46 r47  
    11package snowball.protocol.parse; 
    22 
    3 import java.util.regex.Matcher; 
    4 import java.util.regex.Pattern; 
    5  
    6 import snowball.protocol.Response; 
    73import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
    94 
    105/** 
  • SnowBallBot/src/snowball/protocol/parse/EnemyEscapedParser.java

    r46 r47  
    11package snowball.protocol.parse; 
    22 
    3 import java.util.regex.Matcher; 
    4 import java.util.regex.Pattern; 
    5  
    6 import snowball.protocol.Response; 
    73import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
    94 
    105/** 
  • SnowBallBot/src/snowball/protocol/parse/EnemyEscapingParser.java

    r46 r47  
    66import snowball.protocol.Response; 
    77import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
     8import snowball.EnemyStrikeBack; 
    99 
    1010/** 
     
    1212 *         created 06.03.2010 at 2:14:01 
    1313 */ 
    14 public class EnemyEscapingParser extends MatchPatternParser<EnemyResponse> { 
     14public class EnemyEscapingParser extends MatchPatternParser<EnemyStrikeBack> { 
    1515 
    1616        public EnemyEscapingParser() { 
     
    2424        } 
    2525 
    26         protected Response<EnemyResponse> create( final String msg, 
     26        protected Response<EnemyStrikeBack> create( final String msg, 
    2727                                                  final Matcher m ) { 
    2828                final String enemy = m.group( 1 ); 
    2929                final double enemyHealthLost = Double.parseDouble( m.group( 2 ) ); 
    3030 
    31                 return new Response<EnemyResponse>( 
     31                return new Response<EnemyStrikeBack>( 
    3232                                ResponseKind.ENEMY_ESCAPING, 
    3333                                msg, 
    34                                 new EnemyResponse( 
     34                                new EnemyStrikeBack( 
    3535                                                enemy, 
    3636                                                0, 
  • SnowBallBot/src/snowball/protocol/parse/EnemyRespondedParser.java

    r46 r47  
    66import snowball.protocol.Response; 
    77import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
     8import snowball.EnemyStrikeBack; 
    99 
    1010/** 
     
    1212 *         created 06.03.2010 at 2:14:01 
    1313 */ 
    14 public class EnemyRespondedParser extends MatchPatternParser<EnemyResponse> { 
     14public class EnemyRespondedParser extends MatchPatternParser<EnemyStrikeBack> { 
    1515 
    1616        public EnemyRespondedParser() { 
     
    2525        } 
    2626 
    27         protected Response<EnemyResponse> create( final String msg, 
     27        protected Response<EnemyStrikeBack> create( final String msg, 
    2828                                                  final Matcher m ) { 
    2929                final String enemy = m.group( 1 ); 
     
    3131                final double enemyHealthLost = Double.parseDouble( m.group( 3 ) ); 
    3232 
    33                 return new Response<EnemyResponse>( 
     33                return new Response<EnemyStrikeBack>( 
    3434                                ResponseKind.ENEMY_STRIKED_BACK, 
    3535                                msg, 
    36                                 new EnemyResponse( 
     36                                new EnemyStrikeBack( 
    3737                                                enemy, 
    3838                                                ownHealthLost, 
  • SnowBallBot/src/snowball/protocol/parse/IWasKilledInBackParser.java

    r46 r47  
    11package snowball.protocol.parse; 
    22 
    3 import java.util.regex.Matcher; 
    4 import java.util.regex.Pattern; 
    5  
    6 import snowball.protocol.Response; 
    73import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
    94 
    105/** 
  • SnowBallBot/src/snowball/protocol/parse/IWasKilledParser.java

    r46 r47  
    11package snowball.protocol.parse; 
    22 
    3 import java.util.regex.Matcher; 
    4 import java.util.regex.Pattern; 
    5  
    6 import snowball.protocol.Response; 
    73import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
    94 
    105/** 
  • SnowBallBot/src/snowball/protocol/parse/IWasKilledParser2.java

    r46 r47  
    11package snowball.protocol.parse; 
    22 
    3 import java.util.regex.Matcher; 
    4 import java.util.regex.Pattern; 
    5  
    6 import snowball.protocol.Response; 
    73import snowball.protocol.ResponseKind; 
    8 import snowball.EnemyResponse; 
    94 
    105/** 
  • SnowBallBot/tests/units/snowball/protocol/parse/EnemyEscapedParserTest.java

    r46 r47  
    44import snowball.protocol.Response; 
    55import snowball.protocol.ResponseKind; 
    6 import snowball.EnemyResponse; 
    76 
    87/** 
  • SnowBallBot/tests/units/snowball/protocol/parse/EnemyEscapingParserTest.java

    r46 r47  
    44import snowball.protocol.Response; 
    55import snowball.protocol.ResponseKind; 
    6 import snowball.EnemyResponse; 
     6import snowball.EnemyStrikeBack; 
    77 
    88/** 
     
    2020                                "S — îãëÿäåòüñÿ î.Î"; 
    2121 
    22                 final Response<EnemyResponse> res = parser.parse( msg ); 
     22                final Response<EnemyStrikeBack> res = parser.parse( msg ); 
    2323                assertNotNull( res ); 
    2424                assertEquals( ResponseKind.ENEMY_ESCAPING, res.kind() ); 
     
    3232                                "S — îãëÿäåòüñÿ î.Î"; 
    3333 
    34                 final Response<EnemyResponse> res = parser.parse( msg ); 
    35                 final EnemyResponse eres = res.data(); 
     34                final Response<EnemyStrikeBack> res = parser.parse( msg ); 
     35                final EnemyStrikeBack eres = res.data(); 
    3636 
    3737                assertEquals( "define_true_", eres.enemyName() ); 
  • SnowBallBot/tests/units/snowball/protocol/parse/EnemyRespondedParserTest.java

    r46 r47  
    44import snowball.protocol.Response; 
    55import snowball.protocol.ResponseKind; 
    6 import snowball.EnemyResponse; 
     6import snowball.EnemyStrikeBack; 
    77 
    88/** 
     
    2121                                "S — ïîäûñêàòü äðóãîãî îòìîðîçêà."; 
    2222 
    23                 final Response<EnemyResponse> res = parser.parse( msg ); 
     23                final Response<EnemyStrikeBack> res = parser.parse( msg ); 
    2424                assertNotNull( res ); 
    2525                assertEquals( ResponseKind.ENEMY_STRIKED_BACK, res.kind() ); 
     
    3434                                "S — ïîäûñêàòü äðóãîãî îòìîðîçêà."; 
    3535 
    36                 final Response<EnemyResponse> res = parser.parse( msg ); 
    37                 final EnemyResponse eres = res.data(); 
     36                final Response<EnemyStrikeBack> res = parser.parse( msg ); 
     37                final EnemyStrikeBack eres = res.data(); 
    3838 
    3939                assertEquals( "chonduhvan", eres.enemyName() ); 
     
    5050                                "S — ïîäûñêàòü äðóãîãî îòìîðîçêà."; 
    5151 
    52                 final Response<EnemyResponse> res = parser.parse( msg ); 
    53                 final EnemyResponse eres = res.data(); 
     52                final Response<EnemyStrikeBack> res = parser.parse( msg ); 
     53                final EnemyStrikeBack eres = res.data(); 
    5454 
    5555                assertEquals( "lk29", eres.enemyName() ); 
Note: See TracChangeset for help on using the changeset viewer.