evaluate_move.c

这是一个相当棒的Linux下的台球游戏

    }

    /* wenn foul - weisse platzieren */
    if( foul ){
//        double x,y;
        /* this is done now for all balls in billard3d.c after evaluate_last_move  */
        /*white_free_place(0, -TABLE_L/4.0, &x, &y, pballs);*/
        pballs->ball[0].v=vec_xyz(0.0,0.0,0.0);
        pballs->ball[0].w=vec_xyz(0.0,0.0,0.0);
        pballs->ball[0].r=vec_xyz(0,-TABLE_L/4.0,0.0);
    }

    fprintf(stderr,"foul:%d, nextplayer:%d, BM_get_ball_out(9):%d\n",foul,nextplayer,BM_get_ball_out(9));
    if( !foul && !nextplayer && BM_get_ball_out(9) ){
        player[act_player].winner=1;
    }

    if( foul && BM_get_ball_out(9) ){
        player[(act_player==1)?0:1].winner=1;
    }

    BM_reset_move_info();

    if( player[act_player].place_cue_ball ) player[act_player].place_cue_ball=0;

    if(nextplayer){
//        Xque=player[act_player].Xque;
//        player[act_player].Zque=Zque;
        player[act_player].queue_view=*pqueue_view;
        act_player = (act_player==1) ? 0 : 1 ;
        if( foul ) player[act_player].place_cue_ball=1;
//        Xque=player[act_player].Xque;
        *pXque=player[act_player].Xque;
        *pqueue_view=player[act_player].queue_view;
    }
#undef act_player
}


void evaluate_last_move_carambol( struct Player * player, int * pact_player,
                               BallsType * pballs, int * pqueue_view, float * pXque )
{
#define act_player (*pact_player)
#define CUE_BALL_IND (player[act_player].cue_ball)
    int nextplayer=1;
    int bhit1, bhit2, i;
    int other_player;

    other_player=(act_player==1)?0:1;

    nextplayer=1;

    bhit1=BM_get_nth_ball_hit_by_ind(CUE_BALL_IND,1);
    for( i=2 ; (bhit2=BM_get_nth_ball_hit_by_ind(CUE_BALL_IND,i))!=-1 && bhit2==bhit1 ; i++ );

    fprintf(stderr,"cueball=%d,%d\n",CUE_BALL_IND, pballs->ball[CUE_BALL_IND].nr);
    fprintf(stderr,"bhit1=%d\n",bhit1);
    fprintf(stderr,"bhit2=%d\n",bhit2);

    if( bhit2!=-1 && bhit1!=-1 && bhit2!=bhit1 ){
        nextplayer=0;
        player[act_player].score++;
    }

    BM_reset_move_info();

    if(nextplayer){
//        Xque=player[act_player].Xque;
//        player[act_player].Zque=Zque;
        player[act_player].queue_view=*pqueue_view;
        fprintf(stderr, "score of %s: %d\n", player[act_player].name,   player[act_player].score   );
        fprintf(stderr, "score of %s: %d\n", player[other_player].name, player[other_player].score );
        act_player = (act_player==1) ? 0 : 1 ;
//        if( foul ) player[act_player].place_cue_ball=1;
//        Xque=player[act_player].Xque;
        *pXque=player[act_player].Xque;
        *pqueue_view=player[act_player].queue_view;
    }

#undef CUE_BALL_IND
#undef act_player
}

void evaluate_last_move_snooker( struct Player * player, int * pact_player,
                               BallsType * pballs, int * pqueue_view, float * pXque )
{
#define act_player (*pact_player)
#define IS_RED(x) ( x==1 || x>=8 )
    int red_balls_are_in_game=0;
    static SnookerState st={SN_PLAY_RED};
    int color_to_pot;
    int i;
    int act_score=0;
    int act_penalty=0;
    int foul=0;
    int ball_out;
    int other_player=(act_player==1)?0:1;
    int b1hit = BM_get_1st_ball_hit();  if (b1hit>=8) b1hit=1;

    if( player[act_player].place_cue_ball ) player[act_player].place_cue_ball=0;
    printf("EVAL start\n");
    printf("EVAL to_play=%d\n",st.to_play);
    printf("EVAL b1hit=%d\n",b1hit);
    for(i=0;i<pballs->nr;i++){
        if( IS_RED(pballs->ball[i].nr) && pballs->ball[i].in_game ){
            red_balls_are_in_game=1; 
            break;
        }
    }

    /* wenn weisse rein */
    if( BM_get_white_out() ){
        foul=1;
        printf("EVAL foul 7\n");
        act_penalty =MAX(act_penalty,(BM_get_1st_ball_hit()<=7?BM_get_1st_ball_hit():4));
        spot_snooker_ball(pballs,0);
        player[other_player].place_cue_ball=1;
    }

    switch(st.to_play)
    {
    case SN_PLAY_RED:
        color_to_pot=1;
        if(b1hit!=1)
        {
            foul=1;
            act_penalty=MAX(act_penalty,b1hit);
            printf("EVAL foul 1\n");
        }
        i=1;
        while((ball_out=BM_get_nth_ball_out(i++))>=0)
        {
            printf("EVAL ball out:%d\n",ball_out);
            if(IS_RED(ball_out))
            {
                act_score+=1;
            }
            else
            {
                act_penalty=MAX(act_penalty,ball_out);
                foul=1;
                printf("EVAL foul 2\n");
            }
        }
        for(i=2;i<8;i++)
        {
            if( BM_get_ball_out(i))
                spot_snooker_ball(pballs,i);
        }
        st.to_play=SN_PLAY_ANY_COLOR;
        break;
    case SN_PLAY_ANY_COLOR:
        if(b1hit==1)
        {
            foul=1;
            printf("EVAL foul 3\n");
            act_penalty=MAX(act_penalty,7);
        }
        color_to_pot=b1hit;
        i=1;
        while((ball_out=BM_get_nth_ball_out(i++))>=0)
        {
            printf("EVAL ball out:%d\n",ball_out);
            if(ball_out==color_to_pot)
            {
                act_score+=ball_out;
            }
            else
            {
                foul=1;
                printf("EVAL foul 4\n");
                act_penalty=MAX(act_penalty,ball_out==1?7:ball_out);
            }
        }
        if(red_balls_are_in_game)
            st.to_play=SN_PLAY_RED;
        else
            st.to_play=SN_PLAY_YELLOW;

        for(i=2;i<8;i++)
        {
            if( BM_get_ball_out(i))
                spot_snooker_ball(pballs,i);
        }
        break;
    case SN_PLAY_YELLOW:
    case SN_PLAY_GREEN:
    case SN_PLAY_BROWN:
    case SN_PLAY_BLUE:
    case SN_PLAY_PINK:
    case SN_PLAY_BLACK:
        color_to_pot=st.to_play;
        if(b1hit!=color_to_pot)
        {
            foul=1;
            printf("EVAL foul 5\n");
            act_penalty=MAX(act_penalty,b1hit);
            act_penalty=MAX(act_penalty,color_to_pot);
        }
        i=1;
        while((ball_out=BM_get_nth_ball_out(i++))>=0)
        {
            printf("EVAL ball out:%d\n",ball_out);
            if(ball_out==color_to_pot)
            {
                act_score+=ball_out;
            }
            else
            {
                foul=1;
                printf("EVAL foul 6\n");
                act_penalty=MAX(act_penalty,b1hit);
                act_penalty=MAX(act_penalty,color_to_pot);
            }
        }
        if(!foul && act_score>0) st.to_play++;

        for(i=st.to_play;i<8;i++)
        {
            if( BM_get_ball_out(i))
                spot_snooker_ball(pballs,i);
        }
        break;
    }


    if(foul)
    {
        act_penalty =MAX(act_penalty,4);
        player[other_player].score += act_penalty ;
        printf("EVAL foul\n");
    }
    else
    {
        player[act_player].score += act_score ;
        printf("EVAL no foul\n");
    }
    if(act_score==0 || foul)
    {
        printf("EVAL next player\n");
        if(red_balls_are_in_game)
        {
            st.to_play=SN_PLAY_RED;
        }
        else
        {
            if(st.to_play<=SN_PLAY_ANY_COLOR)
            {
                st.to_play=SN_PLAY_YELLOW;
            }
        }
        player[act_player].queue_view=*pqueue_view;
        act_player = other_player;
        *pXque=player[act_player].Xque;
        *pqueue_view=player[act_player].queue_view;
    }

    player[act_player].snooker_on_red=st.to_play==SN_PLAY_RED;
    player[act_player].snooker_next_color=st.to_play;
    printf("EVAL to_play=%d\n",st.to_play);

    if(st.to_play==SN_DONE)
    {
        int other_player;

        other_player = (act_player+1)%2;

        if(player[act_player].score>player[other_player].score){
            player[act_player].winner=1;
            player[other_player].winner=0;
        }
        if(player[act_player].score<player[other_player].score) {
            player[act_player].winner=0;
            player[other_player].winner=1;
        }
    }

    printf("EVAL done\n");

    BM_reset_move_info();
    fflush(stdout);
}

void setfunc_evaluate_last_move(void (* eval_func)( struct Player * player, int * actual_player,
                                                    BallsType * pballs, int * pqueue_view, float * pXque ) )
{
    evaluate_last_move=eval_func;
}