partida.java

J2ME 技术开发的扑克牌类游戏 是开源代码

     * @param jugador indice del juador (empieza en 0) para el cual se desea 
     * conocer los puntos
     * @param ronda ronda en la que se desea conoecer los puntos (la ronda 0?
     * siempre tiene 0 puntos)
     * @throws java.lang.IndexOutOfBoundsException si el jugador o la ronda no 
     * se encuentran. tenga en cuenta solo se crear? la ronda si exist?a la inmediatame anterior.  
     * @return puntos totales para el jugador, en la ronda especificados.
     */
    public int getAcumulado(int jugador, int ronda)throws IndexOutOfBoundsException
    {
        if(ronda>getRondas() || ronda<0)
            throw new IndexOutOfBoundsException();
        else if(ronda==0)
            return 0;
        else 
            return ((Ronda)(puntos.elementAt(ronda-1))).getPuntos(jugador);
    }

   /**
     * obtiene un valor acumulado 
     * @param jugador indice del juador (empieza en 0) para el cual se desea 
     * conocer los puntos
     * @throws java.lang.IndexOutOfBoundsException si el jugador o la ronda no 
     * se encuentran. tenga en cuenta solo se crear? la ronda si exist?a la inmediatame anterior.  
     * @return puntos totales para el jugador especificado en la ?ltima ronda jugada 
     */
    public int getAcumulado(int jugador)throws IndexOutOfBoundsException
    {
        return getAcumulado(jugador, getRondas(jugador));
    }
    
    /**
     * establece un valor de puntos acumulados
     * @param jugador jugador a la que se le asignan los puntos
     * @param ronda ronda en que se le asigna los puntos
     * @param valor puntos conseguidos por en la ronda
     * @throws java.lang.IndexOutOfBoundsException si el jugador o la ronda no 
     * se encuentran. tenga en cuenta solo se crear? la ronda si exist?a la inmediatame anterior.
     */
    public void setParcial(int jugador, int ronda, int valor)throws IndexOutOfBoundsException
    {
        if(ronda<=0 || ronda>getRondas()+1)
            throw new IndexOutOfBoundsException();
        setAcumulado(jugador,ronda,getAcumulado(jugador, ronda-1)+valor);
    }

    /**
     * obtiene un valor de puntos de onda
     * @param jugador indice del juador (empieza en 0) para el cual se desea 
     * conocer los puntos
     * @param ronda ronda para la cual se quiere conocer los puntos
     * @throws java.lang.IndexOutOfBoundsException si el jugador o la ronda no 
     * se encuentran. tenga en cuenta solo se crear? la ronda si exist?a la inmediatame anterior.  
     * @return puntos obtenidos para el jugador especificado en la rond especificada 
     */
    public int getParcial( int jugador, int ronda)throws IndexOutOfBoundsException
    {
        if(ronda==0)
            return 0;
        else if(ronda==1)
            return getAcumulado(jugador, ronda);
        else if(ronda<0||ronda>getRondas())
            throw new IndexOutOfBoundsException();
        else 
            return getAcumulado(jugador, ronda)- getAcumulado(jugador, ronda-1);
    }
    
    /**
     * obtiene cuantas cartas se dan en la ronda seg?n las reglas
     * @param ronda ronda ara la cual se quiere sabe cuantas cartas se dan
     */
    public int getCartas(int ronda)throws IndexOutOfBoundsException
    {
        return ((Ronda)(puntos.elementAt(ronda-1))).getCartas();
    }
    
    /**
     * obtiene un valor de puntos de ronda
     * @param jugador indice del juador (empieza en 0) para el cual se desea 
     * conocer los puntos
     * @throws java.lang.IndexOutOfBoundsException si el jugador o la ronda no 
     * se encuentran. tenga en cuenta solo se crear? la ronda si exist?a la inmediatame anterior.  
     * @return puntos obtenidos para el jugador especificado su ?ltima ronda
     */
    public int getParcial(int jugador)throws IndexOutOfBoundsException
    {
        return getParcial(jugador,getRondas());
    }
    
    /** 
     * calcula el n?mero de rondas de la partida
     * @return n?ero de rondas de la ptida
     */
    public int getRondas()
    {
        return puntos.size();
    }
    
    /** 
     * calcula el n?mero de rondas para un jugador
     * @return numero de rondas jugadas por el jugador
     * @param jugador n?mero del jugador
     * @throws java.lang.IndexOutOfBoundsException si el jugador no existe 
     */
    public int getRondas(int jugador)throws IndexOutOfBoundsException
    {
        int result=0;
        for(int i=getRondas();i>0;--i)
        {
            try
            {
                getAcumulado(jugador,i);
                result=i;
                i=0;//condjci?n de parada
            }
            catch(IndexOutOfBoundsException ioobe)
            {
                //no tiene puntos en esta ronda bajamos
            }
        }
        return result;
    }
    
    /**
     * aplica el incremento marcado por las reglas a lo puntos parciales
     * @param jugador jugador al que se le aplica el incremento
     * @ronda en la que se aplicar? el incremento
     */
    public void inc(int jugador,int ronda)
    {
        int parcial;
        int result;
        try
        {
            parcial=getParcial(jugador,ronda);
            result=reglas.incParcial(parcial);
        }
        catch(Exception e)
        {
            result=reglas.incParcial();
        }
        setParcial(jugador, ronda, result);
    }
    
    /**
     * aplica el decremento marcado por las reglas a lo puntos parciales
     * @param jugador jugador al que se le aplica el incremento
     * @ronda en la que se aplicar? el decremento
     */
    public void dec(int jugador,int ronda)
    {
        int parcial;
        int result;
        try
        {
            parcial=getParcial(jugador,ronda);
            result=reglas.decParcial(parcial);
        }      
        catch(Exception e)
        {
            result=reglas.decParcial();
        }
        setParcial(jugador,ronda,result);
    }
    
    /**
     * obtiene la lista de rayas que se hacen en la tabla de apuntar seg?n las
     * reglas de partida
     * @return lista de rayas de apunte
     */
    public int[] getLineas()
    {
        return reglas.getLines();
    }
    
    /**
     * @return nombre del ganador
     */
    public String getGanadorNombre()
    {
        String result="";
        int maximo=getAcumulado(1);
        for (int i=0;i<this.getNJugadores();i++)
        {
            int acumulado=getAcumulado(i+1);
            if(acumulado>=maximo)
            {
                maximo=acumulado;
                result=getNombres()[i];
            }
               
        }
        return result;
    }
    
    /** @return nombre del perdedor */
    public String getPerdedorNombre()
    {
        String result="";
        int maximo=getAcumulado(1);
        for (int i=0;i<this.getNJugadores();i++)
        {
            int acumulado=getAcumulado(i+1);
            if(acumulado<=maximo)
            {
                maximo=acumulado;
                result=getNombres()[i];
            }
               
        }
        return result;
        
    }
    
    /** @return puntos del perdedor*/
    public int getPerdedorPuntos()
    {
        int result=0;
        int maximo=getAcumulado(1);
        for (int i=0;i<this.getNJugadores();i++)
        {
            int acumulado=getAcumulado(i+1);
            if(acumulado<=maximo)
            {
                maximo=acumulado;
                result=acumulado;
            }
               
        }
        return result;
    }
    
    /**
     * nota. no usar como funci?n m?ximo 
     * @return puntos del ganador.*/
    public int getGanadorPuntos()
    {
        int result=0;
        int maximo=getAcumulado(1);
        for (int i=0;i<this.getNJugadores();i++)
        {
            int acumulado=getAcumulado(i+1);
            if(acumulado>=maximo)
            {
                maximo=acumulado;
                result=acumulado;
            }
               
        }
        return result;        
    }
    
    /**
     * reinicia los puntos de la paritida
     */
    public void reiniciar()
    {
        puntos=new java.util.Vector();
        System.gc();
    }
    
    /**
     * Serializa los datos de la partida en formato xml
     * @param destino buffer donde escribe el resultado.
     */
    public void toXml(StringBuffer destino)
    {
        destino.append(" <partida>  \n");
        //nombres
        int i;
        int maxI=nombres.length;
        for(i=0;i<maxI;i++)
        {
            destino.append("<jugador>");
            destino.append(nombres[i]);
            destino.append("</jugador> ");
        }
        //reglas
        destino.append("\n  <reglas>");
        destino.append(idNormas);
        destino.append("</reglas>");
        //puntos
        for(i=0;i<getRondas();i++)
        {
            destino.append("\n  <puntos> ");
            for(int j=0;j<maxI;j++)
            {
               destino.append("<punto>");
               try
               {
                    destino.append(getParcial(j+1, i+1));
               }
               catch (IndexOutOfBoundsException iooe){}
               //destino.append(getAcumulado(j+1, i+1));
               destino.append("</punto> ");
            }
            destino.append("</puntos>");
        }
        destino.append("\n </partida>");
    }
}