billard3d.c

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

        ts->game[0][game].winner = -1;
    }
    ts->roster.nr = 1<<ts->round_num;

    if(init_me){
        DPRINTF("init_tournament_state: initializing player roster\n");
        init_ai_player_roster(&(ts->roster));
        init_me=0;
    }
}

void restart_game_common();

void tournament_state_setup_next_round( struct TournamentState_ * ts )
{
    int i;
    int players[100];

    printf("tournament_state_setup_next_round\n");

    (ts->round_ind)++;
    if( ts->round_ind == ts->round_num ){ /* tournament over ? */
        ts->tournament_over=1;
        ts->round_ind = ts->round_num-1;
        if(ts->game[ts->round_ind][0].winner==0){
            ts->overall_winner=ts->game[ts->round_ind][0].roster_player1;
        } else if(ts->game[ts->round_ind][0].winner==1){
            ts->overall_winner=ts->game[ts->round_ind][0].roster_player2;
        } else {
            fprintf(stderr,"error: nobody won the tournament !?\n");
            exit(1);
        }
    } else {
        for(i=0;i<(1<<(ts->round_num-ts->round_ind));i++){
            if(ts->game[ts->round_ind-1][i].winner==0){
                players[i]=ts->game[ts->round_ind-1][i].roster_player1;
            } else if(ts->game[ts->round_ind-1][i].winner==1){
                players[i]=ts->game[ts->round_ind-1][i].roster_player2;
            } else {
                fprintf(stderr,"error: sbdy didnt win one of the last matches !?\n");
                exit(1);
            }
        }
        printf("Pairings:\n");
        for(i=0;i<(1<<(ts->round_num-ts->round_ind-1));i++){
            ts->game[ts->round_ind][i].roster_player1=players[2*i];
            ts->game[ts->round_ind][i].roster_player2=players[2*i+1];
            ts->game[ts->round_ind][i].winner = -1;
            printf("%d vs. %d\n",
                   ts->game[ts->round_ind][i].roster_player1,
                   ts->game[ts->round_ind][i].roster_player2
                  );
            printf("%s vs. %s\n",
                   ts->roster.player[ts->game[ts->round_ind][i].roster_player1].name,
                   ts->roster.player[ts->game[ts->round_ind][i].roster_player2].name
                  );
        }
    }
}

void tournament_evaluate_last_match( struct TournamentState_ * ts )
{
    printf("tournament_evaluate_last_match 1\n");
    if( player[0].winner ){
        ts->game[ts->round_ind][ts->game_ind].winner=0;
    } else if( player[1].winner ){
        ts->game[ts->round_ind][ts->game_ind].winner=1;
    } else {
        ts->game[ts->round_ind][ts->game_ind].winner=-1;
    }
    printf("tournament_evaluate_last_match 2\n");
    ts->game_ind++;
    printf("tournament_evaluate_last_match 3\n");
    if( ts->game_ind >= (1<<(ts->round_num-ts->round_ind-1)) ){
        printf("tournament_evaluate_last_match 4\n");
        tournament_state_setup_next_round(ts);
        ts->game_ind=0;
/*        if(ts->round_ind>=ts->round_num){
            ts->tournament_over=1;
            if( ts->game[ts->round_num-1][0].winner == 0 ){
                ts->overall_winner = ts->game[ts->round_num-1][0].roster_player1;
            } else {
                ts->overall_winner = ts->game[ts->round_num-1][0].roster_player2;
            }
        }*/
    }
    printf("tournament_evaluate_last_match 5\n");
}

void tournament_state_setup_next_match( struct TournamentState_ * ts )
{
    printf("tournament_state_setup_next_match 1\n");
    printf("ts->game[ts->round_ind][ts->game_ind].roster_player1=%d\n",ts->game[ts->round_ind][ts->game_ind].roster_player1);
    player_copy(&(player[0]),ts->roster.player[ts->game[ts->round_ind][ts->game_ind].roster_player1]);
    printf("tournament_state_setup_next_match 2\n");
    printf("ts->game[ts->round_ind][ts->game_ind].roster_player2=%d\n",ts->game[ts->round_ind][ts->game_ind].roster_player2);
    player_copy(&(player[1]),ts->roster.player[ts->game[ts->round_ind][ts->game_ind].roster_player2]);
    printf("tournament_state_setup_next_match 3\n");
    player[0].winner=0;
    player[1].winner=0;
    printf("tournament_state_setup_next_match 4\n");
    if( player[0].is_AI && player[1].is_AI ){
        g_motion_ratio=ts->ai_fast_motion;
        printf("ts->ai_fast_motion=%f\n",g_motion_ratio);
        printf("tournament_state_setup_next_match 4-1\n");
    } else {
        g_motion_ratio=1.0;
        printf("g_motion_ratio=%f\n",g_motion_ratio);
        printf("tournament_state_setup_next_match 4-2\n");
    }
    printf("tournament_state_setup_next_match 5\n");
    restart_game_common();
    printf("tournament_state_setup_next_match 6\n");
    act_player=0;
    printf("tournament_state_setup_next_match 7\n");
    queue_view=player[act_player].queue_view;
    printf("tournament_state_setup_next_match 8\n");
}

void create_players_text()
{
    player[0].text = textObj_new(player[0].name, options_player_fontname, 28);
    player[1].text = textObj_new(player[1].name, options_player_fontname, 28);
//    player[0].text = textObj3D_new(player[0].name, options_player_fontname, 28, 1.0, 3);
//    player[1].text = textObj3D_new(player[1].name, options_player_fontname, 28, 1.0, 3);
    player[0].score_text = textObj_new("0", options_score_fontname, 20);
    player[1].score_text = textObj_new("0", options_score_fontname, 20);
}

void copy_balls( BallsType * balls1, BallsType * balls2 )
{
    int i;
    if ( balls2->nr != balls1->nr ){
        balls2->nr = balls1->nr;
        free( balls2->ball );
        balls2->ball=(BallType *)malloc(balls2->nr*sizeof(BallType));
    }
    for(i=0;i<balls1->nr;i++){
        balls2->ball[i] = balls1->ball[i];
    }
    balls2->gametype = balls1->gametype;
}


void queue_shot()
{
    VMvect dir, nx, ny, hitpoint;

    if( !balls_moving ){
        int other_player;

        /* backup actual ball setup */
        copy_balls(&balls,&bakballs);

        other_player=(act_player==1)?0:1;
        if( player[other_player].is_net ){
            socket_write(g_socket,(char *)&(Zque),sizeof(Zque));
            socket_write(g_socket,(char *)&(Xque),sizeof(Xque));
        }
//        player[act_player].place_cue_ball=0;

        dir = vec_xyz(sin(Zque*M_PI/180.0)*sin(Xque*M_PI/180.0),
                      cos(Zque*M_PI/180.0)*sin(Xque*M_PI/180.0),
                      cos(Xque*M_PI/180.0));
        nx = vec_unit(vec_cross(vec_ez(),dir));  /* parallel to table */
        ny = vec_unit(vec_cross(nx,dir));        /* orthogonal to dir and nx */
        hitpoint = vec_add(vec_scale(nx,queue_point_x),vec_scale(ny,queue_point_y));
//        fprintf(stderr,"queue_shot: Zque=%f\n",Zque);
//        Zque=-137.020020;
        balls.ball[CUE_BALL_IND].v =  vec_scale(dir,-CUEBALL_MAXSPEED*queue_strength);
#if options_jump_shots
#else
        balls.ball[CUE_BALL_IND].v.z =  0.0;
#endif
/*        balls.ball[CUE_BALL_IND].v.x =  -CUEBALL_MAXSPEED*queue_strength*sin(Xque*M_PI/180.0)*sin(Zque*M_PI/180.0);
        balls.ball[CUE_BALL_IND].v.y =  -CUEBALL_MAXSPEED*queue_strength*sin(Xque*M_PI/180.0)*cos(Zque*M_PI/180.0);*/
//        balls.ball[0].w.x = -2.0/balls.ball[0].d/2.0*balls.ball[0].v.y;
//        balls.ball[0].w.y = +2.0/balls.ball[0].d/2.0*balls.ball[0].v.x;
//        balls.ball[0].w.z = -2.0/balls.ball[0].d/2.0;
        if(vec_abssq(hitpoint)==0.0){
            balls.ball[CUE_BALL_IND].w = vec_xyz(0.0,0.0,0.0);
        } else {
            /* w = roll speed if hit 1/3of radius above center */
//            balls.ball[CUE_BALL_IND].w = vec_scale(vec_cross(dir,hitpoint),4.0*3.0*CUEBALL_MAXSPEED*queue_strength/balls.ball[CUE_BALL_IND].d/balls.ball[CUE_BALL_IND].d);
            /* hmm, this one works better */
            balls.ball[CUE_BALL_IND].w = vec_scale(vec_cross(dir,hitpoint),2.0*3.0*CUEBALL_MAXSPEED*queue_strength/balls.ball[CUE_BALL_IND].d/balls.ball[CUE_BALL_IND].d);
        }

#ifdef USE_SOUND
        PlaySound(&ball_cue_snd,options_snd_volume*queue_strength/2.0);
#endif

        /* clear recorded ballpaths */
        {int i;
            for( i=0 ; i<balls.nr ; i++ ){
                BM_clearpath( &balls.ball[i] );
            }
        }

        /* reset offset parameters */
        queue_point_x=0.0;
        queue_point_y=0.0;

    }
}



void shoot( int ani );


void do_computer_move( int doit )
{
    VMvect dir;

    DPRINTF("do_computermove: begin ai_get_strike_dir\n");

    ai_set_err(player[act_player].err);
    dir = ai_get_stroke_dir(&balls,&walls,&player[act_player]);

    DPRINTF("do_computermove: end ai_get_strike_dir\n");

    Zque = atan2(dir.x,dir.y)/M_PI*180.0;
//    Xque = atan2(sqrt(dir.x*dir.x+dir.y*dir.y),dir.z)/M_PI*180.0;
    if(doit){
        shoot( !queue_view );
/*        if(!queue_view){
            queue_anim=30.0;
        } else {
            queue_shot();
        }*/
    }
    comp_dir=dir;
}

int do_net_move( void )
{
    int nbytes;

    DPRINTF("do_net_move: start\n");

    nbytes=socket_read(g_socket,(char *)&(Zque),sizeof(Zque));
    if( nbytes==0 ) return 0;
    nbytes=socket_read(g_socket,(char *)&(Xque),sizeof(Xque));
    if( nbytes==0 ) return 0;
    DPRINTF("do_net_move: %d bytes read\n",nbytes);
    DPRINTF("Zque = %f\n",Zque);

    if(!queue_view){
        queue_anim=30.0;
    } else {
        queue_shot();
    }
    DPRINTF("do_net_move: end\n");

    return 1;
}


double queue_offs_func1( double t )
{
    return( 1.0-cos(t*2.0*M_PI) );
}


double queue_offs_func2( double t )
{
    return( sin(t*M_PI) );
}


double queue_offs_func( double t )
{
    double tx6, rval, dt1, dt2, dt3, dt4, dt5, dt6, t1,t2,t3,t4,t5,t6;
    rval=0.0;
    dt1=1.0;
    dt2=0.4;
    dt3=1.0;
    dt4=0.4;
    dt5=1.0;
    dt6=0.7;
    t1=dt1;
    t2=t1+dt2;
    t3=t2+dt3;
    t4=t3+dt4;
    t5=t4+dt5;
    t6=t5+dt6;
    tx6=t*t6;
    if       ( tx6 >= 0.0 && tx6 < t1  ){
        rval = 1.0*queue_offs_func1(tx6);
    } else if( tx6 >= t1 && tx6 < t2  ){
        rval = 0.0;
    } else if( tx6 >= t2 && tx6 < t3  ){
        rval = 1.0*queue_offs_func1((tx6-t2)/dt3);
    } else if( tx6 >= t3 && tx6 < t4  ){
        rval = 0.0;
    } else if( tx6 >= t4 && tx6 < t5  ){
        rval = 1.3*queue_offs_func1((tx6-t4)/dt5);
    } else if( tx6 >= t5 && tx6 < t6  ){
        rval = 6.0*queue_offs_func2((tx6-t5)/dt6*1.06);
    }
    return 0.5*(0.7+rval);
//    return( 1.0+t*t*sin(t*(10.0+M_PI)) );
}


int net_get_send_req()
{
    char c;
    if( socket_read(g_socket,&c,1)==1 && c=='R' ){
        return 1;
    }
    return 0;
}


int net_get_ack()
{
    char c;
    if( socket_read(g_socket,&c,1)==1 && c=='A' ){
        return 1;
    }
    return 0;
}


int net_get_data()
{
    if( socket_read(g_socket,(char *)&g_net_data,sizeof(NetData))==sizeof(NetData) ){
        Xque=g_net_data.Xrot;
        Zque=g_net_data.Zrot;
        player[act_player].cue_x=g_net_data.cue_x;
        player[act_player].cue_y=g_net_data.cue_y;
        player[act_player].strength=g_net_data.strength;
        balls.ball[CUE_BALL_IND].r.x=g_net_data.white_x;
        balls.ball[CUE_BALL_IND].r.y=g_net_data.white_y;
        return 1;
    }
    return 0;
}


void net_send_send_req()
{
    char c='R';
    socket_write(g_socket,&c,1);
}


void net_send_ack()
{
    char c='A';
    socket_write(g_socket,&c,1);
}


void net_send_data()
{
    g_net_data.Xrot=Xque;
    g_net_data.Zrot=Zque;
    g_net_data.cue_x=player[act_player].cue_x;
    g_net_data.cue_y=player[act_player].cue_y;
    g_net_data.strength=player[act_player].strength;
    g_net_data.white_x=balls.ball[CUE_BALL_IND].r.x;
    g_net_data.white_y=balls.ball[CUE_BALL_IND].r.y;
    socket_write(g_socket,(char *)&g_net_data,sizeof(NetData));
}