
iQc           @   s  d  d l  Td  d l Z d  d l Z d  d l Z d  d l Z d d d     YZ d d d     YZ d d d     YZ d	 d d
     YZ d d d     YZ	 d   Z
 d d d     YZ d d d     YZ y d  d l Z e Z Wn e Z n Xd d d     YZ d S(   i(   t   *Nt   Agentc           B   s#   e  Z d  Z d d  Z d   Z RS(   s   
    An agent must define a getAction method, but may also define the
    following methods which will be called if they exist:

    def registerInitialState(self, state): # inspects the starting state
    i    c         C   s   | |  _  d  S(   N(   t   index(   t   selfR   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   __init__#   s    c         C   s   t    d S(   s   
        The Agent will receive a GameState (from either {pacman, capture, sonar}.py) and
        must return an action from Directions.{North, South, East, West, Stop}
        N(   t   raiseNotDefined(   R   t   state(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt	   getAction&   s    (   t   __name__t
   __module__t   __doc__R   R   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR      s   t
   Directionsc           B   s   e  Z d  Z d Z d Z d Z d Z i e e 6e e 6e e 6e e 6e e 6Z e g  e j	   D] \ Z
 Z e e
 f ^ q]  Z i e e 6e e 6e e 6e e 6e e 6Z RS(   t   Northt   Southt   Eastt   Westt   Stop(   R   R	   t   NORTHt   SOUTHt   EASTt   WESTt   STOPt   LEFTt   dictt   itemst   xt   yt   RIGHTt   REVERSE(    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR   -   s    

1
t   Configurationc           B   sV   e  Z d  Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z	 d   Z
 RS(	   s<  
    A Configuration holds the (x,y) coordinate of a character, along with its
    traveling direction.

    The convention for positions, like a graph, is that (0,0) is the lower left corner, x increases
    horizontally and y increases vertically.  Therefore, north is the direction of increasing y, or (0,1).
    c         C   s   | |  _  | |  _ d  S(   N(   t   post	   direction(   R   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR   K   s    	c         C   s   |  j  S(   N(   R   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   getPositionO   s    c         C   s   |  j  S(   N(   R   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   getDirectionR   s    c         C   s1   |  j  \ } } | t |  k o0 | t |  k S(   N(   R   t   int(   R   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt	   isIntegerU   s    c         C   s2   | d  k r t S|  j | j k o1 |  j | j k S(   N(   t   Nonet   FalseR   R   (   R   t   other(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   __eq__Y   s     c         C   s0   t  |  j  } t  |  j  } t  | d |  S(   Ni   (   t   hashR   R   (   R   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   __hash__]   s    c         C   s"   d t  |  j  d t  |  j  S(   Ns   (x,y)=s   , (   t   strR   R   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   __str__b   s    c         C   s`   |  j  \ } } | \ } } t j |  } | t j k rE |  j } n  t | | | | f |  S(   s  
        Generates a new configuration reached by translating the current
        configuration by the action vector.  This is a low-level call and does
        not attempt to respect the legality of the movement.

        Actions are movement vectors.
        (   R   t   Actionst   vectorToDirectionR   R   R   R   (   R   t   vectorR   R   t   dxt   dyR   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   generateSuccessore   s    (   R   R	   R
   R   R    R!   R#   R'   R)   R+   R1   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR   B   s   							t
   AgentStatec           B   sM   e  Z d  Z d   Z d   Z d   Z d   Z d   Z d   Z d   Z	 RS(   sU   
    AgentStates hold the state of an agent (configuration, speed, scared, etc).
    c         C   s1   | |  _  | |  _ | |  _ d |  _ d |  _ d  S(   Ni    (   t   startt   configurationt   isPacmant   scaredTimert   numCarrying(   R   t   startConfigurationR5   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR   y   s
    				c         C   s/   |  j  r d t |  j  Sd t |  j  Sd  S(   Ns   Pacman: s   Ghost: (   R5   R*   R4   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR+      s    	c         C   s2   | d  k r t S|  j | j k o1 |  j | j k S(   N(   R$   R%   R4   R6   (   R   R&   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR'      s    c         C   s$   t  t  |  j  d t  |  j   S(   Ni   (   R(   R4   R6   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR)      s    c         C   s=   t  |  j |  j  } |  j | _ |  j | _ |  j | _ | S(   N(   R2   R3   R5   R4   R6   R7   (   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   copy   s
    c         C   s    |  j  d  k r d  S|  j  j   S(   N(   R4   R$   R    (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR       s     c         C   s   |  j  j   S(   N(   R4   R!   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR!      s    (
   R   R	   R
   R   R+   R'   R)   R9   R    R!   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR2   t   s   						t   Gridc           B   s   e  Z d  Z e d d  Z d   Z d   Z d   Z d   Z	 d   Z
 d   Z d   Z d	   Z e d
  Z e d  Z d   Z d   Z d   Z d   Z RS(   s9  
    A 2-dimensional array of objects backed by a list of lists.  Data is accessed
    via grid[x][y] where (x,y) are positions on a Pacman map with x horizontal,
    y vertical and the origin (0,0) in the bottom left corner.

    The __str__ method constructs an output that is oriented like a pacman board.
    c         C   s   | t  t g k r! t d   n  d |  _ | |  _ | |  _ g  t |  D]% } g  t |  D] } | ^ q\ ^ qI |  _ | r |  j |  n  d  S(   Ns   Grids can only contain booleansi   (	   R%   t   Truet	   Exceptiont   CELLS_PER_INTt   widtht   heightt   ranget   datat   _unpackBits(   R   R>   R?   t   initialValuet   bitRepresentationR   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR      s     			;c         C   s   |  j  | S(   N(   RA   (   R   t   i(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   __getitem__   s    c         C   s   | |  j  | <d  S(   N(   RA   (   R   t   keyt   item(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   __setitem__   s    c         C   s   g  t  |  j  D]= } g  t  |  j  D]! } t |  j | |  d ^ q& ^ q } | j   d j g  | D] } d j |  ^ qj  S(   Ni    s   
t    (   R@   R?   R>   R*   RA   t   reverset   join(   R   R   R   t   out(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR+      s    S
c         C   s    | d  k r t S|  j | j k S(   N(   R$   R%   RA   (   R   R&   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR'      s     c         C   sX   d } d } x? |  j  D]4 } x+ | D]# } | r< | | 7} n  | d 9} q# Wq Wt |  S(   Ni   i    i   (   RA   R(   (   R   t   baset   ht   lRE   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR)      s    c         C   s9   t  |  j |  j  } g  |  j D] } | ^ q | _ | S(   N(   R:   R>   R?   RA   (   R   t   gR   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR9      s     c         C   s
   |  j    S(   N(   R9   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   deepCopy   s    c         C   s%   t  |  j |  j  } |  j | _ | S(   N(   R:   R>   R?   RA   (   R   RQ   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   shallowCopy   s    c         C   s)   t  g  |  j D] } | j |  ^ q  S(   N(   t   sumRA   t   count(   R   RH   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyRU      s    c         C   sh   g  } x[ t  |  j  D]J } xA t  |  j  D]0 } |  | | | k r, | j | | f  q, q, Wq W| S(   N(   R@   R>   R?   t   append(   R   RG   t   listR   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   asList   s     c         C   s   |  j  |  j g } d } x t |  j |  j   D] } |  j | |  j d } |  j |  \ } } |  | | r | d | 7} n  | d |  j d k r/ | j |  d } q/ q/ W| j |  t |  S(   si   
        Returns an efficient int list representation

        (width, height, bitPackedInts...)
        i    i   i   (   R>   R?   R@   R=   t   _cellIndexToPositionRV   t   tuple(   R   t   bitst
   currentIntRE   t   bitR   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   packBits   s    c         C   s$   | |  j  } | |  j  } | | f S(   N(   R?   (   R   R   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyRY      s    c         C   s   d } xu | D]m } xd |  j  | |  j  D]M } | |  j |  j k rI Pn  |  j |  \ } } | |  | | <| d 7} q) Wq Wd S(   s?   
        Fills in data from a bit-level representation
        i    i   N(   t
   _unpackIntR=   R>   R?   RY   (   R   R[   t   cellt   packedR]   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyRB      s     c         C   s   g  } | d k  r t  d  n  x\ t |  D]N } d |  j | d } | | k rl | j t  | | 8} q+ | j t  q+ W| S(   Ni    s   must be a positive integeri   i   (   t
   ValueErrorR@   R=   RV   R;   R%   (   R   Ra   t   sizet   boolsRE   t   n(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR_     s     N(   R   R	   R
   R%   R$   R   RF   RI   R+   R'   R)   R9   RR   RS   R;   RU   RX   R^   RY   RB   R_   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR:      s    
											c         C   sC   t  |   t  d  k	 r |  S|  d  \ } } t | | d |  d S(   Ni   i   RD   (   i   i   (   t   typeR:   (   t   bitRepR>   R?   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   reconstituteGrid  s    R,   c           B   s   e  Z d  Z i d e j 6d e j 6d e j 6d e j 6d e j 6Z	 e	 j
   Z d Z d   Z e e  Z d   Z e e  Z d d  Z e e  Z d	   Z e e  Z d
   Z e e  Z d   Z e e  Z RS(   sG   
    A collection of static methods for manipulating move actions.
    i    i   igMbP?c         C   s\   |  t  j k r t  j S|  t  j k r, t  j S|  t  j k rB t  j S|  t  j k rX t  j S|  S(   N(   R   R   R   R   R   (   t   action(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   reverseDirection(  s    c         C   s_   |  \ } } | d k r t  j S| d k  r2 t  j S| d k  rE t  j S| d k rX t  j St  j S(   Ni    (   R   R   R   R   R   R   (   R.   R/   R0   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR-   4  s    g      ?c         C   s%   t  j |  \ } } | | | | f S(   N(   R,   t   _directions(   R   t   speedR/   R0   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   directionToVectorA  s    c         C   s   g  } |  j  \ } } t | d  t | d  } } t | |  t | |  t j k rj |  j   g SxU t j D]J \ } } | \ }	 }
 | |
 } | |	 } | | | st | j |  qt qt W| S(   Ng      ?(   R   R"   t   absR,   t	   TOLERANCER!   t   _directionsAsListRV   (   t   configt   wallst   possibleR   R   t   x_intt   y_intt   dirt   vecR/   R0   t   next_yt   next_x(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   getPossibleActionsF  s    !'

 c         C   s   |  \ } } t  | d  t  | d  } } g  } x t j D] \ } } | \ }	 }
 | |	 } | d k  s= | | j k r q= n  | |
 } | d k  s= | | j k r q= n  | | | s= | j | | f  q= q= W| S(   Ng      ?i    (   R"   R,   Rp   R>   R?   RV   (   t   positionRr   R   R   Rt   Ru   t	   neighborsRv   Rw   R/   R0   Ry   Rx   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   getLegalNeighborsY  s    !
 
  c         C   s3   t  j |  \ } } |  \ } } | | | | f S(   N(   R,   Rm   (   R{   Ri   R/   R0   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   getSuccessorg  s    (   i    i   (   i    i(   i   i    (   ii    (   i    i    (   R   R	   R
   R   R   R   R   R   R   Rk   R   Rp   Ro   Rj   t   staticmethodR-   Rm   Rz   R}   R~   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR,     s(   


	
				t   GameStateDatac           B   sk   e  Z d  Z d d  Z d   Z d   Z d   Z d   Z d   Z	 d   Z
 d   Z d	   Z d
   Z RS(   s   

    c         C   s   | d k rg | j j   |  _ | j |  _ |  j | j  |  _ | j |  _ | j |  _ | j |  _ n  d |  _	 d |  _
 d |  _ d |  _ t |  _ t |  _ d |  _ d S(   sZ   
        Generates a new data packet by copying information from its predecessor.
        i    N(   R$   t   foodRS   t   capsulest   copyAgentStatest   agentStatest   layoutt   _eatent   scoret
   _foodEatent
   _foodAddedt   _capsuleEatent   _agentMovedR%   t   _loset   _wint   scoreChange(   R   t	   prevState(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR   q  s    						c         C   sd   t  |   } |  j j   | _ |  j j   | _ |  j | _ |  j | _ |  j | _ |  j | _ | S(   N(   R   R   RR   R   R   R   R   R   (   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyRR     s    c         C   s.   g  } x! | D] } | j  | j    q W| S(   N(   RV   R9   (   R   R   t   copiedStatest
   agentState(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s    c         C   sl   | d k r t S|  j | j k s& t S|  j | j k s< t S|  j | j k sR t S|  j | j k sh t St S(   s3   
        Allows two states to be compared.
        N(   R$   R%   R   R   R   R   R;   (   R   R&   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR'     s         c         C   s   xL t  |  j  D]; \ } } y t t |   Wq t k
 rJ } | GHq Xq Wt t t |  j   d t |  j  d t t |  j   d t |  j  d  S(   s;   
        Allows states to be keys of dictionaries.
        i   iq   i   i (	   t	   enumerateR   R"   R(   t	   TypeErrorRZ   R   R   R   (   R   RE   R   t   e(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR)     s    c         C   s  |  j  j |  j  j } } t | |  } t |  j  t d  k rX t |  j  |  _ n  xk t |  D]] } xT t |  D]F } |  j |  j  j } } |  j	 | | | | | |  | | | <qx Wqe Wx |  j
 D] } | d  k r q n  | j d  k r q n  g  t | j j  D] }	 t |	  ^ q\ } } | j j }
 | j r]|  j |
  | | | <q |  j |
  | | | <q Wx% |  j D] \ } } d | | | <qWt |  d |  j S(   Ni   i   t   os   
Score: %d
(   i   i   (   R   R>   R?   R:   Rf   R   Rh   R@   Rr   t   _foodWallStrR   R$   R4   t   nearestPointR   R"   R   R5   t   _pacStrt	   _ghostStrR   R*   R   (   R   R>   R?   t   mapR   R   R   Rr   R   RE   t	   agent_dir(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR+     s*    2  1	c         C   s   | r
 d S| r d Sd Sd  S(   Nt   .t   %t    (    (   R   t   hasFoodt   hasWall(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s
    c         C   s=   | t  j k r d S| t  j k r& d S| t  j k r9 d Sd S(   Nt   vt   ^t   >t   <(   R   R   R   R   (   R   Rv   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s    c         C   sA   d S| t  j k r d S| t  j k r* d S| t  j k r= d Sd S(   Nt   Gt   Mt   Wt   3t   E(   R   R   R   R   (   R   Rv   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s    c         C   s   | j  j   |  _  | j |  _ | |  _ d |  _ d |  _ g  |  _ d } xa | j D]V \ } } | s | | k rw qS q | d 7} n  |  j j t	 t
 | t j  |   qS Wg  |  j D] } t ^ q |  _ d S(   sT   
        Creates an initial game state from a layout array (see layout.py).
        i    i   N(   R   R9   R   R   R   R   R   t   agentPositionsRV   R2   R   R   R   R%   R   (   R   R   t   numGhostAgentst	   numGhostsR5   R   t   a(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt
   initialize  s    				 )N(   R   R	   R
   R$   R   RR   R   R'   R)   R+   R   R   R   R   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR   m  s   	
								
t   Gamec           B   s\   e  Z d  Z d e e d  Z d   Z e d  Z d Z d Z	 d   Z
 d   Z d   Z RS(	   sL   
    The Game manages the control flow, soliciting actions from agents.
    i    c   	      C   s   t  |  _ | |  _ | |  _ | |  _ | |  _ t  |  _ | |  _ | |  _ g  |  _	 g  | D] } d ^ qX |  _
 g  | D] } d ^ qt |  _ t  |  _ d d  l } g  | D] } | j   ^ q |  _ d  S(   Ni    i(   R%   t   agentCrashedt   agentst   displayt   rulest   startingIndext   gameOvert
   muteAgentst   catchExceptionst   moveHistoryt   totalAgentTimest   totalAgentTimeWarningst   agentTimeoutt	   cStringIOt   StringIOt   agentOutput(	   R   R   R   R   R   R   R   t   agentR   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s    										c         C   s!   |  j  r d S|  j j |   Sd  S(   Ng      ?(   R   R   t   getProgress(   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s    	c         C   s<   | s t  j   n  t |  _ t |  _ |  j j |  |  d S(   s(   Helper method for handling agent crashesN(   t	   tracebackt	   print_excR;   R   R   R   t
   agentCrash(   R   t
   agentIndext   quiet(    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   _agentCrash  s
     		c         C   sO   |  j  s d  Sd d  l } t j a t j a |  j | t _ |  j | t _ d  S(   Ni(   R   R   t   syst   stdoutt
   OLD_STDOUTt   stderrt
   OLD_STDERRR   (   R   R   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   mute  s    	 		c         C   s#   |  j  s d  St t _ t t _ d  S(   N(   R   R   R   R   R   R   (   R   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   unmute(  s    	 	c         C   s:  |  j  j |  j j  d |  _ xt t |  j   D]} |  j | } | s |  j |  t	 j
 d | IJ|  j   |  j | d t d Sd t |  k r5 |  j |  |  j ry t | j t |  j j |    } yF t j   } | |  j j    t j   | } |  j | c | 7<WnI t k
 rmt	 j
 d | IJ|  j   t |  _ |  j | d t d SXWqt k
 r} |  j | d t |  j   d SXn | j |  j j    |  j   q5 q5 W|  j } t |  j  } x|  j s|  j | } d }	 t }
 d t |  k r|  j |  |  j ry t | j t |  j j |    } y% t j   } | |  j j    } Wn t k
 rt }
 n X|	 t j   | 7}	 |  j   Wqt k
 r} |  j | d t |  j   d SXn | j |  j j    } |  j   n |  j j   } d } |  j |  |  j rfyt | j! t |  j j |   t |	   } y. t j   } |
 rt    n  | |  } WnI t k
 rt	 j
 d | IJt |  _ |  j | d t |  j   d SX|	 t j   | 7}	 |	 |  j j" |  k r|  j# | c d	 7<t	 j
 d
 | |  j# | f IJ|  j# | |  j j$ |  k rt	 j
 d | |  j# | f IJt |  _ |  j | d t |  j   d Sn  |  j | c |	 7<|  j | |  j j% |  k r*t	 j
 d | |  j | f IJt |  _ |  j | d t |  j   d S|  j   Wqut k
 rb} |  j |  |  j   d SXn | j! |  } |  j   |  j& j' | | f  |  j ry |  j j( | |  |  _ Wqt k
 r} |  j |  |  j |  |  j   d SXn |  j j( | |  |  _ |  j  j) |  j j  |  j j* |  j |   | | d	 k r^|  j d	 7_ n  | d	 | } t+ rt, j- |  j.    qqWx t/ |  j  D] \ } } d t |  k ry+ |  j |  | j0 |  j  |  j   Wq%t k
 r!} |  j s  n  |  j |  |  j   d SXqqW|  j  j1   d S(   s2   
        Main control loop for game play.
        i    s   Agent %d failed to loadR   Nt   registerInitialStates$   Agent %d ran out of time on startup!t   observationFunctions$   Agent %d timed out on a single move!i   s9   Agent %d took too long to make a move! This is warning %ds4   Agent %d exceeded the maximum number of warnings: %ds'   Agent %d ran out of time! (time: %1.2f)t   final(2   R   R   R   RA   t   numMovesR@   t   lenR   R   R   R   R   R   R;   Rv   R   t   TimeoutFunctionR   R"   R   t   getMaxStartupTimet   timeRR   R   t   TimeoutFunctionExceptionR   R<   R%   R   R   R   t   getMoveTimeoutR$   R   t   getMoveWarningTimeR   t   getMaxTimeWarningst   getMaxTotalTimeR   RV   R1   t   updatet   processt   _BOINC_ENABLEDt   boinct   set_fraction_doneR   R   R   t   finish(   R   RE   R   t
   timed_funct
   start_timet
   time_takenRA   R   t	   numAgentst	   move_timet   skip_actiont   observationRi   (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   run0  s    	
	$
		
		$

	.	
	
	


	
 	 
N(   R   R	   R
   R%   R   R   R   R$   R   R   R   R   R   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyR     s   				(    (    (    (    (    (    (    (    (   t   utilR   t   osR   R   R   R   R   R2   R:   Rh   R,   R   R   R;   R   R%   R   (    (    (    sK   C:\MyDocuments\Studies\Berkeley CS188X\05 Projects\03 Reinforcement\game.pyt   <module>   s"   
2(s	
T

