Subversion Repositories shark

//////////////////////////////////////////////////////////////////

// Pong

// Written for CS 324, UIUC

// Spencer Hoke

// James Kim

// Tao Luo

//

// Last Modified: April 29, 2004

#include "pong.h"

///////////////////////////////////////

// sets initial values of global variables

void setglobals() {

    P_MASS = 100;

    kp = 30;

    kd = 20;                 // > sqrt(4*(XMAX - XMIN)* kp)

    AI_VIEWING_RANGE = 250;  // window = YMAX - this

    balllist = NULL;

    num_balls = 0;           // number of balls currently in system

    min_balls = 0;           // minimum number of balls in the system

    locked = 0;              // 1 if #balls kept constant

    ball_spd = 5;            // ballspeed (default = 5)

    p_speed = 10;            // # pixels to move each keypress

    p1_length = 150;         // size of the paddles

    p2_length = 75;          // size of the paddles

    p1_pos = (XMAX + XMIN - p1_length)/2;  // initialize starting paddle positions

    p2_pos = (XMAX + XMIN - p2_length)/2;

    p2_target_pos = p2_pos;  // initially no movement

    points1 = 0;             // scores for each side

    points2 = 0;

}

///////////////////////////////////////

// center at (x,y) with radius RAD and color c

void draw_ball(int x, int y, int c) {

    mutex_lock(&draw_mutex);

    grx_disc(x, y, RAD, c);

    mutex_unlock(&draw_mutex);

}

///////////////////////////////////////

// top left corner is (x,y), length is l,

// thickness is P_THICKNESS, and color is c

void draw_paddle(int x, int y, int l, int c) {

    mutex_lock(&draw_mutex);

    grx_box(x, y, x + l, y + P_THICKNESS, c);

    mutex_unlock(&draw_mutex);

}

///////////////////////////////////////

// draws a line where the computer's viewing window starts

void draw_viewwin(int col) {

    mutex_lock(&draw_mutex);

    grx_line(XMIN-RAD, AI_VIEWING_RANGE+YMIN, XMAX+RAD, AI_VIEWING_RANGE+YMIN, col);

    mutex_unlock(&draw_mutex);

}

///////////////////////////////////////

void print_scores() {

    char st1[15], st2[15];

    sprintf(st1, "Player 1:%6d", points1);

    sprintf(st2, "Player 2:%6d", points2);

    mutex_lock(&draw_mutex);

    grx_text(st1, XMIN-RAD-1, 20, blue, black);

    grx_text(st2, XMIN-RAD-1, 30, red, black);

    mutex_unlock(&draw_mutex);

}

///////////////////////////////////////

void print_numballs() {

    char st[15];

    sprintf(st, "Num balls:%3d", num_balls);

    mutex_lock(&draw_mutex);

    grx_text(st, XMAX-100, 20, magenta, black);

    mutex_unlock(&draw_mutex);

}

///////////////////////////////////////

void print_constants() {

    char st[15];

    sprintf(st, "kp:%3d, kd:%3d, mass:%4d", kp, kd, P_MASS);

    mutex_lock(&draw_mutex);

    grx_text(st, XMIN-RAD-1, YMAX+20, magenta, black);

    mutex_unlock(&draw_mutex);

}

///////////////////////////////////////

TASK ball(void *arg) {

    int     x, y;             // current position

    int     oldx, oldy;       // last position

    int     dx, dy;           // delta x, y

    int     theta, col;

    double  r;                // theta in radians

    int     p1len, p2len, p1pos, p2pos;   // temp storage of length and position

    int     outx;

    int     hitp1, hitp2;        // 1 if ball has hit paddle

    int     in1, in2;            // 1 if ball is currently inside paddle (error)

    struct  ballinfo myinfo;     // shared x/y/theta

    myinfo.x = x = oldx = XMIN;             // start in middle of the left

    myinfo.y = y = oldy = (YMIN+YMAX)/2;

    col = rand()%14 + 2;         // color ball

    // insert myinfo into global list

    mutex_lock(&list_mutex);

    if(balllist != NULL)   // update old first entry in list

        balllist->prev = &myinfo;

    myinfo.next = balllist;

    myinfo.prev = NULL;

    balllist = &myinfo;

    mutex_unlock(&list_mutex);

    //  starting angle = [ANGMIN,ANGMAX]

    theta = rand()%(ANGMAX - ANGMIN) + ANGMIN;

    if (rand()%2 == 1) // random starting direction

        theta *= -1;

    if (theta > 360) theta -= 360;

    if (theta < 0) theta += 360;

    myinfo.theta = theta;

    r = (double)theta * PI / 180.;

    while (1) {

        dx = (float)(ball_spd * cos(r));

        dy = (float)(ball_spd * sin(r));

        x += dx;

        y += dy;

        // check boundary conditions

        if (y >= YMAX) {  // end task and score point for player 2

            points1++;

            break;

        }

        if (y <= YMIN) {  // end task and score point for player 1

            points2++;

            break;

        }

        p1len = p1_length;  // copy globals

        p1pos = p1_pos;

        p2len = p2_length;

        p2pos = p2_pos;

        outx = (x >= XMAX) || (x <= XMIN);

        hitp1 = (y <= (YMIN + 2*RAD + P_THICKNESS)) // y is within range of paddle

                && (x >= (p1pos - RAD)) && (x <= (p1pos + p1len + RAD)); // x is within range of paddle

        hitp2 = (y >= (YMAX - 2*RAD - P_THICKNESS)) // y is within range of paddle

                && (x >= (p2pos - RAD)) && (x <= (p2pos + p2len + RAD)); // x is within range of paddle

        // need these in case ball goes in the side of the paddle

        in1 = (oldy <= (YMIN + 2*RAD + P_THICKNESS)) // oldy is within range of paddle

                && (oldx >= (p1pos - RAD)) && (oldx <= (p1pos + p1len + RAD)); // oldx is within range of paddle

        in2 = (oldy >= (YMAX - 2*RAD - P_THICKNESS)) // oldy is within range of paddle

                && (oldx >= (p2pos - RAD)) && (oldx <= (p2pos + p2len + RAD)); // oldx is within range of paddle

        if (outx || ((hitp1 || hitp2) && !in1 && !in2)) { // ball needs to bounce

            x -= dx;

            y -= dy;

            if (outx) theta = 180 - theta;                        // bounce off wall

            if ((hitp1 || hitp2) && !in1 && !in2) theta = -theta; // bounce off paddle

            if (theta > 360) theta -= 360;

            else if (theta < 0) theta += 360;

            r = (double)theta * PI / 180.;

            x += (float)(ball_spd * cos(r));

            y += (float)(ball_spd * sin(r));

        }

        draw_ball(oldx, oldy, black);       // clear old position

        draw_ball(x, y, col);               // draw new ball

        oldx = x; oldy = y;

        mutex_lock(&list_mutex);      // updates values in list

        myinfo.x = x;

        myinfo.y = y;

        myinfo.theta = theta;

        mutex_unlock(&list_mutex);

        task_endcycle();

    }

    // remove myinfo from list

    mutex_lock(&list_mutex);

    if(myinfo.next != NULL)

        (myinfo.next)->prev = myinfo.prev;

    if(myinfo.prev != NULL)

        (myinfo.prev)->next = myinfo.next;

    else

        balllist = myinfo.next;

    mutex_unlock(&list_mutex);

    draw_ball(oldx, oldy, 0); // clear ball

    print_scores();           // update score

    num_balls--;              // remove ball from system

    if(!locked)

        print_numballs();     // update count of balls

    return NULL;

}

///////////////////////////////////////

void addball() {

    HARD_TASK_MODEL m;

    PID pid;

    hard_task_default_model(m);

    hard_task_def_ctrl_jet (m);

    hard_task_def_wcet     (m, BALL_WCET);

    hard_task_def_mit      (m, BALL_PER);

    hard_task_def_group    (m, BALLGROUP);

    hard_task_def_usemath  (m);

    pid = task_create("ball", ball, &m, NULL);

    if (pid == NIL) {

        grx_close();

        sys_shutdown_message("Could not create task <ball> errno=%d", errno);

        sys_abort(errno);

    }

    task_activate(pid);

    num_balls++;

    print_numballs();

}

///////////////////////////////////////

// paddle 1 controller

TASK paddle1(void *arg) {

    int oldpos, newpos;

    int move, oldlength, length;

    oldpos = newpos = p1_pos;

    oldlength = -1;            // force draw initially

    while (1) {

        length = p1_length;    // need to copy in case they change

        move = p1_move;

        p1_move -= move;       // update global variable

        // get new position of ball

        newpos += move * p_speed;

        if(newpos < XMIN) // tried to move too far right

            newpos = XMIN;

        else if(newpos > (XMAX - length)) // tried to move too far left

            newpos = XMAX - length;

        if ((newpos != oldpos) || (length != oldlength)) { // need to redraw the paddle

            p1_pos = newpos;  // update global position

            draw_paddle(oldpos, YMIN + RAD, oldlength, black);  // clear old paddle

            draw_paddle(newpos, YMIN + RAD, length, blue);  // draw new one

            oldpos = newpos;

            oldlength = length;

        }

        else

            draw_paddle(newpos, YMIN + RAD, length, blue);  // refresh paddle

        task_endcycle();

    }

}

///////////////////////////////////////

// determines target position of paddle 2

TASK p2ai(void *arg) {

    int     proj;    // projected length to y-value of paddle

    int     closestBallY_Location = 0;

    int     closestBallX_Location = 0;

    int         closestBallY_Angle = 0;

    int     closestToPaddle;

    int         projectedX_Location = 0;

    int     foundBall;

    double  r;                  // angle in radians

    struct ballinfo *cur;

    char st[20];

     while(1) {

        if (num_balls != 0) { // if there are balls

            //finds the closest ball and its position and angle

            closestBallY_Location = AI_VIEWING_RANGE + YMIN;

            closestToPaddle = 1000000;       // large default number

            foundBall = 0;

            mutex_lock(&list_mutex);

            for (cur = balllist; cur != NULL; cur = cur->next) {

                if (cur->y > closestBallY_Location         // within window

                    && cur->y < (YMAX - RAD - P_THICKNESS) // not past paddle already

                    && cur->theta < 180)                   // going toward paddle

                {

                    r = (double)(cur->theta) * PI / 180.;

                    proj = (float)( (YMAX - RAD - P_THICKNESS - cur->y) / sin(r) );  // geometry

                    if(proj < closestToPaddle) { // this is the closest one

                        foundBall = 1;

                        closestBallY_Location = cur->y;

                        closestBallX_Location = cur->x;

                        closestBallY_Angle = cur->theta;

                        closestToPaddle = proj;

                    }

                }

            }

            mutex_unlock(&list_mutex);

            //finds where it needs to move to

            if (foundBall == 1) {

                r = (double)closestBallY_Angle * PI / 180.;

                projectedX_Location = (float)( (YMAX - RAD - P_THICKNESS - closestBallY_Location) / tan(r) );  // geometry

                projectedX_Location += closestBallX_Location;

                while(projectedX_Location < XMIN || projectedX_Location > XMAX) { // adjust for ball bounces

                    if(projectedX_Location < XMIN)

                        projectedX_Location = 2*XMIN - projectedX_Location;  // bounce off left side

                    if(projectedX_Location > XMAX)

                        projectedX_Location = 2*XMAX - projectedX_Location;  // bounce off right side

                }

                sprintf(st, "Proj X: %3d", projectedX_Location);

                mutex_lock(&draw_mutex);

                grx_text(st, XMAX-85, YMAX+20, magenta, black);

                mutex_unlock(&draw_mutex);

                p2_target_pos = projectedX_Location - p2_length/2;   // copy into target for p2

            }

        }

        task_endcycle();

    }

}

///////////////////////////////////////

// paddle 2 controller - applies forces and draws paddle

TASK paddle2(void *arg) {

    int     oldpos, newpos;

    int     positionErrorX, oldlength, length;

    int     force = 0, acceleration = 0, velocity = 0;    // paddle movement

    oldpos = newpos = p2_pos;

    oldlength = -1;            // force draw initially

    while (1) {

        length = p2_length;    // need to copy in case they change

        positionErrorX = p2_target_pos - oldpos;

        //Applying force

        force = kp * positionErrorX - kd * velocity;

        acceleration = force / P_MASS;

        velocity += acceleration;      // new velocity

        newpos = oldpos + velocity;    // using new velocity, so incorporates acceleration

        if(newpos < XMIN) // tried to move too far right

            newpos = XMIN;

        else if(newpos > (XMAX - length)) // tried to move too far left

            newpos = XMAX - length;

        if ((newpos != oldpos) || (length != oldlength)) { // need to redraw the paddle

            p2_pos = newpos;  // update global position

            draw_paddle(oldpos, YMAX - P_THICKNESS - RAD, oldlength, black);  // clear old paddle

            draw_paddle(newpos, YMAX - P_THICKNESS - RAD, length, red);  // draw new one

            oldpos = newpos;

            oldlength = length;

        }

        else

            draw_paddle(newpos, YMAX - P_THICKNESS - RAD, length, red);  // refresh paddle

        task_endcycle();

    }

}

///////////////////////////////////////

TASK countmon(void *arg) {

    while(1) {

        while(num_balls < min_balls)

            addball();

        task_endcycle();

    }

}

///////////////////////////////////////

// called when the system exits

void byebye(void *arg) {

    grx_close();

    cprintf("Thanks for playing!\n");

}

///////////////////////////////////////

int main(int argc, char **argv) {

    HARD_TASK_MODEL m;

    PID pid;

    char c;

    TIME seme;          // used to init the random seed

    PI_mutexattr_t a;   // for PI mutex init

    // Set the closing function

    sys_atrunlevel(byebye, NULL, RUNLEVEL_BEFORE_EXIT);

    // initialize global variables

    setglobals();

    // initialize PI mutexes

    PI_mutexattr_default(a);

    mutex_init(&draw_mutex, &a);

    mutex_init(&list_mutex, &a);

    // graphic card Initialization

    if (grx_init() < 1) {

        sys_abort(errno);

    }

    if (grx_open(640, 480, 8) < 0) {

        cprintf("GRX Error\n");

        sys_abort(errno);

    }

    // Draw initial screen layout and menu

    grx_rect(XMIN-RAD-1, YMIN-RAD-1, XMAX+RAD+1, YMAX+RAD+1, yellow);

    grx_text("Scores:",             XMIN-RAD-1, 10, magenta, black);

    grx_text("PONG",                       XMENU, YMENU, magenta, black);

    grx_text("Create a ball:       SPACE", XMENU, YMENU+15, redorange, black);

    grx_text("Quit program:        ESC",   XMENU, YMENU+25, redorange, black);

    grx_text("Move top paddle:     z x",   XMENU, YMENU+35, redorange, black);

    grx_text("Change top size:     a s",   XMENU, YMENU+45, redorange, black);

    grx_text("Change bottom size:  q w",   XMENU, YMENU+55, redorange, black);

    grx_text("Keep # Balls Const:  l",     XMENU, YMENU+65, redorange, black);

    grx_text("Change ball speed:   1 2",   XMENU, YMENU+75, redorange, black);

    grx_text("Change kp:           3 4",   XMENU, YMENU+85, redorange, black);

    grx_text("Change kd:           5 6",   XMENU, YMENU+95, redorange, black);

    grx_text("Change mass:         7 8",   XMENU, YMENU+105, redorange, black);

    grx_text("Change AI window:    9 0",   XMENU, YMENU+115, redorange, black);

    print_scores();

    print_numballs();

    print_constants();

    draw_viewwin(gray);

    // randomize for ball starting angle

    seme = sys_gettime(NULL);

    srand(seme);

    // set up the paddle tasks

    hard_task_default_model(m);

    hard_task_def_ctrl_jet (m);

    hard_task_def_wcet     (m, P_WCET);

    hard_task_def_mit      (m, P_PER);

    hard_task_def_group    (m, PGROUP);

    hard_task_def_usemath  (m);

    pid = task_create("paddle1", paddle1, &m, NULL);

    if (pid == NIL) {

        grx_close();

        sys_shutdown_message("Could not create task <paddle1> errno=%d", errno);

        sys_abort(errno);

    }

    hard_task_default_model(m);

    hard_task_def_ctrl_jet (m);

    hard_task_def_wcet     (m, P_WCET);

    hard_task_def_mit      (m, P_PER);

    hard_task_def_group    (m, PGROUP);

    hard_task_def_usemath  (m);

    pid = task_create("p2ai", p2ai, &m, NULL);

    if (pid == NIL) {

        grx_close();

        sys_shutdown_message("Could not create task <p2ai> errno=%d", errno);

        sys_abort(errno);

    }

    hard_task_default_model(m);

    hard_task_def_ctrl_jet (m);

    hard_task_def_wcet     (m, P_WCET);

    hard_task_def_mit      (m, P_PER);

    hard_task_def_group    (m, PGROUP);

    hard_task_def_usemath  (m);

    pid = task_create("paddle2", paddle2, &m, NULL);

    if (pid == NIL) {

        grx_close();

        sys_shutdown_message("Could not create task <paddle2> errno=%d", errno);

        sys_abort(errno);

    }

    group_activate(PGROUP);

    #ifdef JET_ON

        scenario_jetcontrol();

        init_jetcontrol();

        group_activate(JET_GROUP);

    #endif

    hard_task_default_model(m);

    hard_task_def_ctrl_jet (m);

    hard_task_def_wcet     (m, BALL_WCET);

    hard_task_def_mit      (m, BALL_PER);

    hard_task_def_group    (m, BALLGROUP);

    hard_task_def_usemath  (m);

    pid = task_create("countmon", countmon, &m, NULL);

    if (pid == NIL) {

        grx_close();

        sys_shutdown_message("Could not create task <countmonitor> errno=%d", errno);

        sys_abort(errno);

    }

    task_activate(pid);

    while(1) { // read in commands ( exit handled in handle_key() )

        c = keyb_getch(BLOCK);

        switch (c) {

            case ESC: // quit program

                sys_abort(0);

                break;

            case ' ': // create a new ball

                addball();

                if(locked == 1)    // update min # balls if locked

                    min_balls++;

                break;

            case 'z': // move paddle1 left

                p1_move--;

                break;

            case 'x': // move paddle1 right

                p1_move++;

                break;

            case 's': // increase paddle1 length

                if (p1_length < (XMAX - XMIN - P_DLENGTH))

                    p1_length += P_DLENGTH;

                break;

            case 'a': // decrease paddle1 length

                if (p1_length > (1 + P_DLENGTH))

                     p1_length -= P_DLENGTH;

                break;

            case 'w': // increase paddle2 length

                if (p2_length < (XMAX - XMIN - P_DLENGTH))

                    p2_length += P_DLENGTH;

                break;

            case 'q': // decrease paddle2 length

                if (p2_length > (1 + P_DLENGTH))

                    p2_length -= P_DLENGTH;

                break;

            case 'l': // lock number of balls

                if((locked = !locked)) {

                    min_balls = num_balls;

                    mutex_lock(&draw_mutex);

                    grx_text("   Locked", XMAX-100, 30, redorange, black);

                    mutex_unlock(&draw_mutex);

                }

                else {

                    min_balls = 0;

                    mutex_lock(&draw_mutex);

                    grx_text("         ", XMAX-100, 30, redorange, black);

                    mutex_unlock(&draw_mutex);

                }

                break;

            case '1': // decrease ball speed

                ball_spd--;

                break;

            case '2': // increase ball speed

                ball_spd++;

                break;

            case '3': // decrease kp

                if(kp > 0)

                    kp--;

                print_constants();

                break;

            case '4': // increase kp

                kp++;

                print_constants();

                break;

            case '5': // decrease kd

                if(kd > 0)

                    kd--;

                print_constants();

                break;

            case '6': // increase kd

                kd++;

                print_constants();

                break;

            case '7': // decrease mass

                if(P_MASS > 5)

                    P_MASS -= 5;

                print_constants();

                break;

            case '8': // increase mass

                P_MASS += 5;

                print_constants();

                break;

            case '9': // decrease AI window

                draw_viewwin(black);    // clear old line

                AI_VIEWING_RANGE += 5;

                draw_viewwin(gray);     // draw new one

                break;

            case '0': // increase AI window

                draw_viewwin(black);    // clear old line

                AI_VIEWING_RANGE -= 5;

                draw_viewwin(gray);     // draw new one

                break;

            default:

                break;

        }

    }

    return 0;

}