Final Project : Penalty Kicks

Introduction

In the game of soccer, when both scores are tied there is a penalty kick off. This project will consist of a player kicking penalty kicks. The design is to have a player kicking the ball into the goal and a goalkeeper trying to catch the ball. Every time the ball goes into the goal, we update the score by 1 point on the kicker's team. If the kicker misses, we update the scoreboard with a zero for the kicker's team and a one for the goalkeeper's team. After five kicks, we will check the scoreboard to see which team won the game. Ex. If the kicker only makes 2 out of 5 kicks into the goal, the goalkeeper's team will have 3 points and the kicker's team will have 2 points. The score will show the goalkeeper's team won the game.

Implementation

Interrupts will be used for real-time calculations. The time interrupt will be used to allow position update so that the ball can move. Keyboard interrupts
by the arrow keys will be used for the goalkeeper's movements.
Our program will use both text and video modes.

Outline of the soccer field: 320 X 200 image

1: Kicker initial position
2: Ball initial position
3,4,5: Various goal keeper positions

Problem Description

One of the major hurdles we foresee is that of incorporating mode 13h since we have not formally covered the topic in detail in class.
Another bigger hurdle is that of putting all the project members procedures into complete code that will work.
A challenge we also see is that of having the ball move and at the same time have control of the goal keeper to move as well.

Equations and Calculations

From a given ball start position (position 1 on the diagram), a calculation has to be made to move the ball in a straight line to either the
left (position 4) the center  (position 3) or the right hand side (position 5). To calculate the position of the ball at each instant of time the
ball moved, the equation below would be use

            y = mx + c

where y is the horizontal position, m is the slope, x the vertical position, and c the y-axis intercept, which is just a constant. So depending
on the direction the ball is being kicked, y would be updated by the values of the variables calculated making a triangle.

• Random ( by Jian Gao )

• Purpose: Returns a random number between 0 and 3 in AX.

 
• Description: When this procedure is called, we get the current seconds from the system time, and then we mod the seconds by 3. In our

implementation of other methods, we need a random number to determine which direction the ball is going to be kicked.
 
• Notes: Modifies the AX register with the return value

Does not take in any input

 
• MoveKeeper ( by Bill Ntwali )

• Purpose: Change the position of the keeper goalie) to either left, right or keep him still.

 
• Description: This routine should move the keeper at the position selected by the arrow keys. It should change the position of the

keeper once the ball is kicked. The initial position of the goal keper is inbetween the goals, on position 3 of the diagram above.
 
• Notes: The keeper should be standing in the middle of the goal before the ball is kicked.

Right after the ball is kicked, the keeper is allowed to move either left or right regarding to the key pressed

• MoveBall ( by Chilumba Mubashi )

• Purpose: Moves the ball towards the goal

 
• Description: This routine will move the ball into the goal randomly. Either the nets (score) or the goalkeeper (saved) will stop the ball.

The procedure input will include the constant velocity, and the balls x and y positions. The initial position of the ball in the middle of the field (in the middle of the screen)
 
• Notes: Calls Random to determine direction

The procedure will update score and save variables accordingly
The ball will be moving vertically at speed of  –X m/s.
 
• MoveKicker ( by Bill Ntwali )

 
• Purpose: Move the kicker.


Description: In order for the ball to move, it has to be kicked by the kicker. This routine should  make the kicker move forward
and kick the ball once the “ Enter” key is pressed. The initial position of the kicker is the bottom center of the screen, marked position 1 on
given diagram above.

The procedure will also require an initial ball position input.

• ScoreBoard ( by Jian Gao )

• Purpose: Display current results. Reads the score_gk(player) and score_kk(cpu) scores

 
• Description: This procedure will keep a tally of the scores. It will read various variables to determine what to display

Lives - to determine how many more entries to take in
Score - to determine whether to adjust the players score
Save - to determine whether to adjust the opponent score

• InstKeeperKey ( by Chilumba Mubashi )

 
• Purpose: Procedure to define a new keyboard interrupt

 
• Description: Defines the new interrupt and keeps a pointer to the old interrupt for easy reinstall

 
• StartKeyInt ( by Chilumba Mubashi )

• Purpose: Wait for keyboard press to start the game

 
• Description: In order for the ball not the penalty shoot out not to automatically start, we have to have a control which asks for a

key press. This routine will take over the keyboard interrupt and allow only the "Enter" key to be pressed whilst all others ignored.
It will actually be a procedure which rewrites the keyboard interrupt routine
 
• Notes: Remember to call the DeStartKeyInt which should restore the old keyboard

• DeStartKeyInt ( by Chilumba Mubashi )

• Purpose: Restore keyboard interrupt

 
• Description: Returns the original keyboard interrupt which was taken up by the StartKeyInt

• KeeperKeyInt ( by Chilumba Mubashi )

• Purpose: Wait for arrow keys keyboard presses to move the keeper (goalie)

 
• Description: When the ball is kicked towards the goal, the goal keeper will be controlled using the arrow keys. This ISR will remove

all keyboard functionality and allow only the arrow keys to move the goalie. The procedure will rewrite IRQ 8 (Hardware Keyboard
Interrupt).
 
• Notes: To give the keyboard functionality back, DeKeeperKeyInt needs to be called

• DeKeeperKeyInt ( by Chilumba Mubashi )

• Purpose: Restore keyboard interrupt

 
• Description: Returns the original keyboard interrupt which was taken up by the StartKeyInt

• DrawBackground ( by T.J. Peterson )

• Purpose: To give a graphical backdrop to the scene

 
• Description: Will draw a field with a goal at the top.  There will also be a penalty box

• DisplayStartScreen ( by T.J. Peterson )

 
• Purpose: Display the introductory start screen

 
• Description: This is a procedure that displays the game information right at the start. The start screen will display

an image showing the Team names and people behind the project.
• GoalScreen ( by Jian Gao )

• Purpose: Display a screen which shows whether a goal has been scored or not

 
• Description: Depending on how the goal keeper interacted with the ball, a score will then de determined. This

procedure will read the saved and scored variables when determining which message to display. The different score
variables to be updated are Score_gk (you) and Score_kk (the cpu team).
• DisplayFinalScreen ( by T.J. Peterson )

• Purpose: To display the final score, and which team has won.

 
• Description: Will draw a final screen showing the final score.  The winning team and fans will be shown cheering.

• CalPos ( by Jian Gio)

Helper procedure for ScoreBoard which calculates a text mode position on the screen
input dl =row, dh=col, equation=(80*row+col)*2
output dx=value of the position
 
 
• Draw ( by Jian Gio)

 

 

Inputs: cl=char to display, dl=row,dh=col, ah=color

Text mode helper procedure which right a char with the given input attributes displayed to the screen.
 
 

• DrawBox (By Jian Gio)


Procedure to draw the outline of the score board.
The outline is a character width boarder around a 80 x 25 text mode screen
 
 
 

• OpenAllFile, CloseAllFile (By T.J. Peterson)

 
• OpenAllFile - Opens a file

Inputs: dx = offset address of  filename
Outputs: filehandle
 
• CloseAllFile - Closes a file

Inputs: filehandle
 
 
 
• ReadAllFile (By T.J. Peterson)

 
• ReadAllFile - Reads a file into a buffer
• Inputs
          cx: File size
          bl: filehandle
         ds: SEG Picturebuffer
         dx: offset Picturebuffer
 

• SetPalette ( By T.J. Peterson )


 

• Sets the palette for image display



• No inputs nor outputs

 
 
 

• DrawMovPic (By T.J. Peterson)

Draws the non-background pictures(e.g. goalie, ball, numbers, etc)
Before calling the procedure,
        move to di the position on the screen where the keeper needs to be
        move to bx the offset (Buffer holding image bytes)
        add to bx the (file size - image width)
        move to cx, (Image width * image height)
        move to currentWidth, the image's width
 
 

• ImageData ( By T.J. Peterson, arranged by Chilumba Mubashi)

Loads the images into memmory
All the registers are preserved
 
 

• Main ( by Chilumba Mubashi )

• Purpose: This will be the procedure that will call the different procedures to make the penalty shoot out game work

---


External Routines

        We will have the 'lib306.lib' library available at hand.
        There has not been a need for other library yet.

---

Files For Group Members

• PROJ.ASM: Program framework where our code goes (found in download project link)
• LIB306.LIB: Library functions we could use throughout the semester
• Makefile : For assembly, linking (all behind the scenes)
• Download the code proj.zip

---