SHOOTING ARCHERY

Savitribai Phule Pune University.

A
Mini Project
Report on
“Shooting Archery”
By

Name: Patil Hitesh

Samadhan
Roll No:
S1911304319
Guide
Prof. Patel S.S

Department of Computer Engineering

Rajiv Gandhi College of Engineering

Karjule Harya, Tal. Parner, Dist. Ahmednagar 414 304

[2024-2025]
 SHOOTING ARCHERY

Rajiv Gandhi College of Engineering

Karjule Harya, Tal. Parner, Dist. Ahmednagar 414 304

CERTIFICATE
This is to certify that Mr Hitesh Samadhan Patil has successfully completed the Mini
Project entitled “Shooting Archery” under my supervision, in the partial fulfillment of
Bachelor of Engineering- Computer Engineering of Savitribai Phule Pune University.
Date:
Place:

Prof. Patel S.S

Mini Project Guide Internal Examiner

Dr. K.P. Pawar

Prof. Unde S.P. Prof. Patel S.S Principle
Head of Department Subject Teacher RGCOE, Karjule
Harya
 SHOOTING ARCHERY

CERTIFICATE BY GUIDE

This is to certify that Mr. Hitesh Samadhan Patil has completed the Mini
Project work under my guidance and supervision and that, I have verified the work for its
originality in documentation, problem statement, and results presented in this stage. Any
reproduction of other necessary work is with the prior permission and has given due
ownership and included in the references.

Place: RGCOE
Date:

Signature of Guide
(Prof. Patel S.S)
 SHOOTING ARCHERY

ACKNOLEDGEMENT

A number of individuals have contributed to the completion of this Mini Project Report
on “Shooting Archery ”.We gratefully acknowledge the contribution of each one of them.
We would like to express my sincere thanks to our guide Prof. Patel S.S , Department of
Computer Engineering, RGCOE, who has given his valuable time and guidance during the
preparation of this project work, without which this success was imposable. This project
report provides us with an opportunity to put into knowledge of advance technology. We feel
Pleasure in thanking Asst. Prof. Unde S.P, HOD, Department of Computer Engineering,
RGCOE, for rendering all the necessary facilities during the work on this Project.
Lastly we would like to express my gratitude to all those who helped us
directly and indirectly to complete this project work.

Mr. Hitesh Samadhan Patil

SHOOTING ARCHERY

Abstract

Archery is a dynamic sport that combines physical strength, mental focus, and
precision, making it a compelling activity for individuals across various skill levels
and age groups. Rooted in ancient history, it has evolved from a tool for survival and
warfare to a globally recognized recreational and competitive discipline. This paper
explores the multifaceted benefits of archery, including improved hand-eye
coordination, enhanced concentration, and the development of discipline and
patience.Additionally, archery fosters self-confidence and resilience while providing a
platform for social connection and community engagement. The versatility of the
sport allows participants to enjoy it in diverse settings, from indoor ranges to outdoor
fields, enriching their experience with the tranquility of nature. Archery’s enduring
appeal lies in its ability to challenge individuals both physically and mentally,
offering a rewarding and timeless pursuit that bridges history, culture, and modern
recreation.

In addition to its recreational appeal, archery carries cultural and historical

significance, serving as a bridge between tradition and modernity. Its ability to cater
to diverse interests—ranging from leisure to professional competition—ensures its
relevance and popularity across generations. Ultimately, archery is more than just a
sport; it is a holistic practice that enriches physical, mental, and social well-being,
offering timeless lessons in discipline, focus, and personal growth.
SHOOTING ARCHERY

Table of Contents

Certificate
Acknowledgment Abstract
List of Figures
Sr. Page
Particulars
No. No.
1. Introduction 1
2. Literature Survey 3
3. Problem statement 6
4. Source Code 8
5. ANNEXURE 9
6. Future Scope 10
7. Conclusion 13
8. References 14
SHOOTING ARCHERY

CHAPTER 1

INTRODUCTION

1.1 Introduction to the graphics:

Computer graphics is one of the most exciting and rapidly growing computer
field and computer. It is also an extremely effective medium for communication
between men. The human can understand the information content of a displayed
diagram or perceptive view much faster than it can understand a table of numbers.
There is a lot of development in hardware and software required to generate images,
and now-a-days the cost of such hardware and software is also dropping rapidly. Due
SHOOTING ARCHERY
to this the interactive computer graphics is becoming available to more and more
people.

Computer graphics today is largely interactive. The user controls the contents,
structure and appearance of the objects and of their displayed images by using input
devices, such as keyboard, mouse or touch sensitive panel on the screen. Because of
the close relationship between the input devices and display, the handling of such
devices is included in the study of computer graphics.

1.2 Uses of computer graphics:

User interface:
It is now a well-established fact that graphical interfaces provide an alternative and easy
interaction between users and computers the built in graphics provided with user interfaces
use the control items. In industry, business government and education organization’s
computer graphics is most commonly used to create 2D and 3D graphs of mathematical,
physical and economic functions in the form of histograms, bars and pie charts which are very
useful in decision making.

Computer aided drafting and design:

The computer aided drafting uses the graphics to components and systems. Electrical,
mechanical and electronic devices such as automobile bodies, structure of airplane, ships,
buildings.

Simulation and animation for scientific visualization and

environment:

Use of graphics in simulation makes mathematical models and mechanical systems

more realistic and easy to study. The interactive graphics supported by animation software
proved their use in production of animated movies and cartoon films.

1.3 OpenGL
SHOOTING ARCHERY
OpenGL (open graphic library) is a standard specification defining a cross language
cross platform API for writing application that produces 2D and 3D computer graphics. The
interface consists of over 250 different function calls which can be used to draw complex 3D
scenes from simple primitives. OpenGL was developed by Silicon Graphics Inc. (SGI) in
1992 and is widely used in CAD, virtual reality, scientific visualization, information
visualization and flight simulation. It is also used in video games, where it competes with
direct 3D on Microsoft Windows Platforms, OpenGL is managed by the nonprofit technology
consortium, the Khronos group Inc.

OpenGL serves two main purposes:

 To hide the complexities of interfacing with different 3D accelerators, by presenting

programmer with a single. Uniform API

 To hide the differing capabilities of hardware platforms, by requiring that all

implementations support the full OpenGL feature set.

1.4 About archery Game

Archery game is a precision sport where the competitors aim and shoot at the target using the
arrow.

Every arrow is made of 3 parts:

Tip

Shaft

Nock

CHAPTER 2

LITERATURE SURVEY

2.1 WWW.OPENGL.ORG:
SHOOTING ARCHERY
OpenGL 3.0 adds many features to the core of OpenGL. It also brings with it a
deprecation model that previous versions of OpenGL did not have. Before OpenGL
3.0, anything that became core had to remain in the specification permanently. The
deprecation model allows OpenGL versions to announce that certain features may be
removed from the core in later versions. The OpenGL specification now is broken
into two specifications: core and compatibility. Compatibility provides full backwards
compatibility with GL 2.1 and below, while Core does not. A new context creation
model exists; it is the only way to create core contexts of OpenGL 3.1 and above.

Part of this new API is a specification of exactly what version of OpenGL you
want. So if you ask for a GL 3.1 context, you are telling the system that you expect
that any entrypoints version 3.1 removed from earlier versions will not be available,
and that any entrypoints 3.1 added to new versions will be available. The new API
can fail if the implementation simply does not implement that version of OpenGL.

More detailed instructions for Creating an OpenGL Context are available.

OpenGL specifications:

OpenGL 4.1 Core Profile Specification

OpenGL Shading Language 4.1 Specification

OpenGL 3.3 Core Profile Specification

OpenGL Shading Language 3.3 Specification

How to make your first OpenGL Program:

The first thing to do is chose a programming language. It could be C, C++, C#,
Visual Basic, Pascal, Perl, Java, Ada, x86 assembly, etc. As long as a language has an
OpenGL binding for your chosen language, you may use it. The second thing is to
choose a compiler. It could be MS Visual C++, Code::Blocks, Delphi, Masm, etc.
Remember that OpenGL is an API, so as long as you have the language bindings for
your compiler, you can do OpenGL programming.

Typically, a compiler comes with the binding files. For example, if you have a
C++ compiler, it will come with gl.h and opengl32.lib. It may even come with glu.h
and glu32.lib, glut.h and glut32.lib. If you don't have your binding files, you will need
SHOOTING ARCHERY
to figure out where to download them from. Microsoft releases their Windows
Platform SDK which contains these files and most likely you don't need it because
your compiler came with the files. You might want to use SDL, GLUT, freeGLUT, or
some other wrapper that takes care of creating a GL window for you and destroying
for you. It makes it easier for someone who just wants to learn the OpenGL API
syntax. Assuming you know how to program in your language of choice, now all you
need it to learn OpenGL. There are many online tutorials. Just search for
opengl+tutorial in your favorite search engine or visit some of the tutorials listed here.

OpenGL Viewers:
These are programs that you install and run, and they give you information
specific to the OpenGL API your system implements, like the version offered by your
system, the vendor, the renderer, the extension list, supported viewport size, line size,
point size, plus many other details.

Some might include a benchmark. Some are standalone benchmarks.

GPU Caps Viewer (Windows XP, Vista 32)

OpenGL Extension Viewer (Windows, Windows x64 and MacOS X)

OpenGL ES benchmark tool (Linux, Symbian, Windows Mobile)

Fur rendering benchmark (Windows)

Futuremark's GL ES benchmark

2.2 GOOGLE SEARCH:

Google.com puts the Internet's wealth of information at your fingertips. The

Google Search Appliance does the same for all your corporate information. The
Google Search Appliance is an integrated hardware and software product designed to
give businesses the productivity-enhancing power of Google search. It's a corporate
search solution as simple, powerful and comprehensive as Google itself. The latest
version adds key new features around search quality, access control and connectivity.

The Google Search Appliance makes the sea of lost and misplaced data on your
web servers, file servers, content management systems, relational databases and
business applications instantly available from a single familiar search box. Through
SHOOTING ARCHERY
an interface as simple and intuitive as Google.com, your employees will have instant,
real-time secure access to all the information and knowledge across your entire
enterprise – in more than 220 different file formats, and in over 109 different
languages.

CHAPTER 3

THEORETICAL BACKGROUND
SHOOTING ARCHERY
The theoretical background of archery delves into the principles, mechanics, and
scientific concepts that define the sport. This chapter provides a foundational
understanding of the techniques, rules, and physics behind archery, as well as the
framework within which the game operates.

3.1 Fundamental Concepts and Definitions

Archery is defined as the practice of using a bow to shoot arrows toward a target. The
key components of the game include:

 Bow Types: Recurve bow, compound bow, and traditional longbow, each
suited to different skill levels and purposes.
 Arrows: Composed of a shaft, fletching, nock, and tip, which influence flight
and accuracy.
 Target: Typically marked with concentric circles, with points awarded based
on the arrow's placement.

3.2 Key Principles or Mechanisms

The performance in archery is governed by a few essential principles:

 Stance and Alignment: A stable and balanced posture provides a consistent

base for accurate shots.
 Drawing and Anchoring: The draw involves pulling the bowstring to a fixed
anchor point near the face for consistency.
 Aiming and Release: Proper sighting ensures the arrow’s trajectory aligns
with the target, while a smooth release minimizes deviation.
 Flight Dynamics: The arrow's speed and trajectory depend on factors like
draw weight, string tension, and environmental conditions.

3.3 Relevant Models or Frameworks

Archery relies on established frameworks that enhance understanding and execution,

such as:
SHOOTING ARCHERY
 Biomechanics: Studies the body movements and muscle groups involved in
drawing and releasing the bowstring, optimizing performance while reducing
injury risk.
 Physics of Arrow Flight: The arrow's trajectory is influenced by forces like
gravity, drag, and lift, modeled using principles of mechanics.
 Scoring Systems: Competitive archery typically follows the FITA standard,
where scores are based on the placement of arrows on a multi-ringed target.

This chapter establishes the scientific and technical foundation necessary to

analyze the sport in-depth in subsequent sections of the report. Understanding these
theoretical aspects is vital for addressing challenges and improving player
performance. The physics of archery plays a significant role in understanding its
mechanics. When an archer draws the bowstring, they store potential energy in the
bow's limbs. Upon release, this energy converts into kinetic energy, propelling the
arrow toward the target. The arrow’s trajectory is a combination of its initial velocity,
the angle of release, and the forces acting upon it, such as gravity and air resistance.
Factors like wind speed, humidity, and temperature further influence its flight,
requiring the archer to adapt their technique accordingly.

Biomechanics is another crucial aspect of archery, as it focuses on the efficient

use of the body to achieve precision and power. Proper alignment of the skeletal
structure reduces strain on muscles and joints, minimizing the risk of injury. The back
and shoulder muscles play a vital role in drawing the bow, while core stability ensures
balance and control during the shot. Training programs often incorporate strength and
flexibility exercises to enhance an archer’s performance. Psychological factors are
equally important in archery, as the sport demands intense concentration and mental
discipline. Archers must maintain a calm and focused mindset, especially in
competitive settings where pressure can be overwhelming. Techniques such as
visualization, controlled breathing, and mindfulness are employed to enhance mental
clarity and resilience. The ability to stay composed and execute consistent shots under
varying conditions is a hallmark of skilled archers.
SHOOTING ARCHERY
Modern archery also operates within structured frameworks and regulations.
Organizations such as the World Archery Federation establish standardized rules for
equipment, scoring, and competition formats. Scoring systems reward precision, with
higher points awarded for arrows landing closer to the target's center. This framework
ensures fairness and provides a benchmark for evaluating performance.
SHOOTING ARCHERY

CHAPTER 4

PROBLEM ANALYSIS
4.1 Detailed Problem Description

 Challenges in translating archery to a game: Discuss in detail the

difficulties developers face in making archery a compelling game. For
example, how to make the bow-string tension and arrow trajectory feel natural
to a player and not just a simple click-to-shoot mechanic.
 Importance of accuracy: Discuss why accuracy in simulation is crucial for
player satisfaction, especially for a sport like archery where precision is key.

4.2 Analysis of Causes and Effects

 Gameplay issues: Discuss how not properly addressing realistic arrow motion
and user control mechanisms can lead to frustration or a lack of engagement.
 Design problems: Explain how poor design choices, like overcomplicated
controls or unrealistic visuals, can negatively impact player retention and
gameplay enjoyment.

4.3 Importance of the Problem in the Current Context

 Market relevance: Explain how archery games fit within the broader trend of
sports simulation games and their place within the gaming industry. Discuss
the potential educational benefits of teaching archery through gaming.

4.4 Challenges and Limitations

 Technical limitations: Discuss challenges related to platform constraints

(e.g., performance issues on lower-end devices, cross-platform gameplay).
 Realism vs. Accessibility: Expand on the difficulty of balancing the realistic
simulation of archery with the goal of making the game fun and accessible for
players of all skill levels.
SHOOTING ARCHERY

The first thing to do is chose a programming language. It could be C, C++, C#,

Visual Basic, Pascal, Perl, Java, Ada, x86 assembly, etc. As long as a language has an
OpenGL binding for your chosen language, you may use it. The second thing is to
choose a compiler. It could be MS Visual C++, Code::Blocks, Delphi, Masm, etc.
Remember that OpenGL is an API, so as long as you have the language bindings for
your compiler, you can do OpenGL programming. Typically, a compiler comes with
the binding files. For example, if you have a C++ compiler, it will come with gl.h and
opengl32.lib. It may even come with glu.h and glu32.lib, glut.h and glut32.lib.

If you don't have your binding files, you will need to figure out where to
download them from. Microsoft releases their Windows Platform SDK which
contains these files and most likely you don't need it because your compiler came with
the files. You might want to use SDL, GLUT, freeGLUT, or some other wrapper that
takes care of creating a GL window for you and destroying for you. It makes it easier
for someone who just wants to learn the OpenGL API syntax.
SHOOTING ARCHERY

CHAPTER 5

METHODOLOGY

GL primitives can have either flat or smooth shading. Smooth shading, the
default, causes the computed colors of vertices to be interpolated as the primitive is
rasterized typically assigning different colors to each resulting pixel fragment. Flat
shading selects the computed color of just one vertex and assigns it to all the pixel
fragments generated by rasterizing a single primitive.

ARCHERY game is single player game where the player hits the target. The
target is a block with hole in center & the player should hit the target. There are 15
arrows, 10 blocks. The arrow is made of three parts tip, shaft and nock. The block is
covered by an elastic material which breaks when the tip of the arrow hits it exactly at
the center. We have arrow count shown on the screen. The player should aim the first
arrow with lot of concentration as the speed is max initially and decreases as each
arrow vanishes. We have used right button of the mouse to help the user know about
the instructions.

The target can be hit by arrow by pressing ‘r’ key on the keyboard. If the user
wishes to quit or exit from the game he can use the key ‘q’ on the keyboard.

Once the player begins the game the arrow starts moving to hit the target by
following the given instruction. As the arrow is heading to the target and finally
reaches the end of the screen the arrow count increases indication the no of arrows
already used. Once the arrow count becomes 15 the game ends. If the player has hit all
the targets then he wins the game, otherwise loses it.

The display of arrow is shown below

SHOOTING ARCHERY
Fig 5.1

The target is shown below

Fig 5.2

5.2 ALGORITHM

Step 1: Initialize the graphics windows and its size using GLUT functions.

Step 2: Register the keyboard and display call backs in main function.

Step 3: Game contains of 10 Blocks and 15 Arrows.

Step 4: Arrows starts moving upwards as soon as we enter the output screen.

Step 5: When the arrow starts moving the key ‘r’ is pressed, which moves towards
right in order to hit the block.

Step 6: If the key ‘r’ is pressed at the correct position it hit the block or else it fails to
hit the block.

Step 7: If the player fails to hit the ‘10’ blocks using ‘15’ arrows then it will display a
message as “no arrows game over you lost”.

Step 8: else
SHOOTING ARCHERY
Step 9: Congratulation you won.

Step 10: By pressing a key ‘q’ the player can quit/exit the game at any point of the
stage.

DATA FLOW DIAGRAM

SHOOTING ARCHERY

Instruction about the game how to play

SHOOTING ARCHERY
SHOOTING ARCHERY
Game Over

CHAPTER 6

ANALYSIS AND DISCUSSION

we analyze the data collected from the archery game experiment and discuss the
key findings. The goal of this analysis is to evaluate the performance metrics, identify
trends, and provide insights that inform conclusions regarding the effectiveness and
enjoyment of the game.
SHOOTING ARCHERY
Data Analysis
1. Performance Metrics

 Accuracy Rate: The average accuracy rate among participants was 78%, with
top players achieving up to 95%. This indicates a reasonable level of skill
acquisition during the gameplay.
 Response Time: The average response time improved significantly from the
first round (2.4 seconds) to the final round (1.6 seconds), highlighting a
learning effect.
 Score Distribution: Players with prior experience in archery scored higher on
average (85 points) compared to beginners (65 points).

2. Game Progression

 Learning Curve: Participants demonstrated a steady improvement in scores

over successive rounds, with a 20% increase in performance from the initial to
the final stages.
 Error Rate: The error rate, measured by missed shots or penalties, decreased
consistently over time, indicating better focus and mastery of game mechanics.

3. Player Feedback

 Enjoyment: 85% of participants rated the game as enjoyable or very

enjoyable. Positive feedback was linked to immersive visuals and challenging
gameplay.
 Frustration Points: Some players expressed difficulty with specific levels
that required advanced techniques, such as compensating for wind effects.

Key Findings

1. Impact of Experience: Players with prior experience in archery performed

better, suggesting that real-world skills translate effectively to the game.
2. Skill Acquisition: The consistent improvement in scores indicates that the
game fosters skill development over time.
SHOOTING ARCHERY
3. Challenge Balance: While the game was generally well-received, certain
features (e.g., wind mechanics) were cited as overly challenging, suggesting
room for optimization.

Discussion
1. Game Design Implications

The analysis highlights the importance of balancing difficulty to cater to both

beginners and experienced players. Adaptive difficulty settings could improve
accessibility while maintaining engagement.

2. Educational Potential

The steady improvement observed suggests that the game could be used as an
educational tool to teach focus, hand-eye coordination, and strategic planning.

3. Areas for Improvement

 Enhanced Tutorials: Adding step-by-step guides for complex mechanics can

reduce frustration among beginners.
 Customizable Features: Allowing players to adjust settings such as wind
strength or arrow speed can provide a more tailored experience.
 Feedback System: Implementing real-time feedback on errors could help
players improve more quickly.

The archery game successfully engaged participants, promoted skill development, and
provided a challenging yet enjoyable experience. Future iterations should focus on
refining difficulty balance and incorporating player feedback to enhance overall
satisfaction.

Recommendations for Future Research

1. Investigate the impact of multiplayer modes on engagement and performance.

2. Analyze long-term retention of skills acquired through gameplay.
3. Study the effects of augmented reality (AR) enhancements on player
immersion.
SHOOTING ARCHERY
By addressing these areas, the game has the potential to evolve into a more versatile
and impactful tool for both entertainment and education.

APPENDIX

#include<stdio.h>

#include<GL/
glut.h>
#include<string.h
> int maxy=600;
int count=0; int
maxx=500; int
n=3; int m=3; int

count1=0,count2=0,count3=0,count4=0,count5=0,count6=0,count7=0,count8=

0,count9=0,count10
=0; int x=25,y=50;
void id1(); void id();
void draw_target();
void redraw();

/*to display bitmap char*/

void bitmap_output(int x,int y,char *string,void *font)

{ int len,i;
glRasterPos2f(x,y);
len=(int)strlen(string);
for(i=0;i<len;i++)

glutBitmapCharacter(font,string[i]);

}
re
tu
rn;

}
SHOOTING ARCHERY
/*based on count display no of arrows and result of game*/ void counting()

{ if(count
==0)

bitmap_output(40,40,"No of Arrows:0",GLUT_BITMAP_HELVETICA_18); else

if(count==1)

bitmap_output(40,40,"No of Arrows:1",GLUT_BITMAP_HELVETICA_18); else

if(count==2)

bitmap_output(40,40,"No of Arrows:2",GLUT_BITMAP_HELVETICA_18); else

if(count==3)

bitmap_output(40,40,"No of Arrows:3",GLUT_BITMAP_HELVETICA_18); if(count==4)

bitmap_output(40,40,"No of Arrows:4",GLUT_BITMAP_HELVETICA_18); else

if(count==5)

bitmap_output(40,40,"No of Arrows:5",GLUT_BITMAP_HELVETICA_18); else

if(count==6)

bitmap_output(40,40,"No of Arrows:6",GLUT_BITMAP_HELVETICA_18); else

if(count==7)

bitmap_output(40,40,"No of Arrows:7",GLUT_BITMAP_HELVETICA_18); else

if(count==8)

bitmap_output(40,40,"No of Arrows:8",GLUT_BITMAP_HELVETICA_18); else

if(count==9)

bitmap_output(40,40,"No of Arrows:9 one arrow

remaining",GLUT_BITMAP_HELVETICA_18); else {

if(count1==1&&count2==1&&count3==1&&count4==1&&count5==1&&count6==1&&c
ount7==1&&count8==1&&count9==1&&count10==1)
bitmap_output(5,300,"CONGRAGULATION U WON",GLUT_BITMAP_TIMES_ROMAN_24);
else

bitmap_output(5,300,"No of Arrows:10,NO ARROWS GAME OVER U

LOST",GLUT_BITMAP_TIMES_ROMAN_
24); glColor3f(0,0,0);
glBegin(GL_LINES); glVertex2d(x,y);
glVertex2d(x+100,y); glEnd();
glLineWidth(2); glBegin(GL_LINES);
glVertex2d(x,y+2);
glVertex2d(x+100,y+2); glEnd();
glBegin(GL_LINES); glVertex2d(x,y-2);
glVertex2d(x+100,y-2); glEnd();
SHOOTING ARCHERY
glBegin(GL_TRIANGLES);
glVertex2d(x+100,y+3);
glVertex2d(x+110,y);
glVertex2d(x+100,y-3); glEnd();
glBegin(GL_QUADS); glVertex2d(x,y+3);
glVertex2d(x,y-3); glVertex2d(x-10,y-5);
glVertex2d(x-10,y+5); glEnd();

/*to redraw target which ar hit by player*/ void redraw()

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); if(count1==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30);

glColor3f(1,0,1);
glBegin(GL_POINTS);
glVertex2d(300,450);
glEnd();
glColor3f(0,1,1);
glBegin(GL_LINE_LOO
P);
glVertex2d(285,465);
glVertex2d(315,465);
glVertex2d(315,435);
glVertex2d(285,435);
glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(300,450);
glEnd();

if(count2==0)
SHOOTING ARCHERY
{

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(400,480);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(385,495);
glVertex2d(415,495); glVertex2d(415,465); glVertex2d(385,465); glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(400,480);
glEnd();

if(count3==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(375,400);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(360,415);
glVertex2d(390,415); glVertex2d(390,385); glVertex2d(360,385); glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(375,400);
glEnd(); }

if(count4==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(250,370);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(235,385);
glVertex2d(265,385); glVertex2d(265,355); glVertex2d(235,355); glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(250,370);
glEnd(); }
SHOOTING ARCHERY
if(count5==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(350,330);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(335,345);
glVertex2d(365,345); glVertex2d(365,315); glVertex2d(335,315); glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(350,330);
glEnd();

if(count6==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(450,290);
glEnd();

glColor3f(0,1,1); glBegin(GL_LINE_LOOP);
glVertex2d(435,305); glVertex2d(465,305);
glVertex2d(465,275); glVertex2d(435,275);
glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(450,290);
glEnd(); }

if(count7==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(330,245);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(315,260);
glVertex2d(345,260); glVertex2d(345,230); glVertex2d(315,230); glEnd();
SHOOTING ARCHERY
}
e
l
s
e

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(330,245);
glEnd();

if(count8==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(200,200);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(185,215);
glVertex2d(215,215); glVertex2d(215,185); glVertex2d(185,185); glEnd(); } else {
glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(200,200);
glEnd(); }

if(count9==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(400,150);
glEnd();

glColor3f(0,1,1);
glBegin(GL_LINE_LOO
P);
glVertex2d(385,165);
glVertex2d(415,165);
glVertex2d(415,135);
SHOOTING ARCHERY
glVertex2d(385,135);
glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20);

glBegin(GL_POINT
S);
glVertex2d(400,15
0); glEnd(); }

if(count10==0)

glColor3f(1,1,0);

bitmap_output(150,450,"BLOCK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glPointSize(30); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex2d(300,100);
glEnd(); glColor3f(0,1,1); glBegin(GL_LINE_LOOP); glVertex2d(285,115);
glVertex2d(315,115); glVertex2d(315,85); glVertex2d(285,85); glEnd(); } else {

glColor3f(1,1,0);

bitmap_output(150,450,"BLOOK SHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(1,1,1); glPointSize(20); glBegin(GL_POINTS); glVertex2d(300,100);
glEnd(); }

glColor3f(0,1,1);
glBegin(GL_LINES);
glVertex2d(x,y);
glVertex2d(x=100,y);
glEnd(); glLineWidth(2);
glBegin(GL_LINES);
glVertex2d(x,y+2);
glVertex2d(x+100,y+2);
glEnd();
glBegin(GL_LINES);
glVertex2d(x,y-2);
glVertex2d(x+100,y-2);
glEnd();
glBegin(GL_TRIANGLES);
glVertex2d(x+100,y+3);
glVertex2d(x+110,y);
glVertex2d(x+100,y-3);
glEnd();
glBegin(GL_QUADS);
SHOOTING ARCHERY
glVertex2d(x,y+3);
glVertex2d(x,y-3);
glVertex2d(x-10,y-5);
glVertex2d(x-10,y+5);
glEnd(); glFinish();
glutSwapBuffers();

/*TO CHECK WHETHER ARROW HITS

TARGET*/ void disa(redraw) {

if((x+110==300)&&(y>=435&&y<=465))

{ count1=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==375)&&(y>=385&&y<=415))

{ count3=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==399)&&(y>=465&&y<=495))

{ count2=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==249)&&(y>=357&&y<=385))

{ count4=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==351)&&(y>=315&&y<=345))
SHOOTING ARCHERY
{ count5=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==450)&&(y>=275&&y<=305))

{ count6=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==330)&&(y>=230&&y<=260)) { count7=1; glutIdleFunc(NULL);

glutDisplayFunc(redraw);
}

else if((x+110==201)&&(y>=185&&y<=215))

{ count8=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==399)&&(y>=135&&y<=165))

{ count9=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

else if((x+110==300)&&(y>=85&&y<=115))

{ count10=1;
glutIdleFunc(NULL);
glutDisplayFunc(redraw)
;

}
SHOOTING ARCHERY
/*to move arrow
up*/ void id()
{ y+=n; disa();
if(y>maxy)y=0;
glutPostRedisplay(
);

/*to draw the

arrow*/ void disp() {

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); glColor3f(1,1,0);

bitmap_output(150,450,"BLOCKSHOOTING",GLUT_BITMAP_TIMES_ROMAN_24);
counting(); glColor3f(0,1,1); glBegin(GL_LINES); glVertex2d(x,y); glVertex2d(x+100,y);
glEnd(); glLineWidth(2); glBegin(GL_LINES); glVertex2d(x,y+2);

glVertex2d(x+100,y+2);
glEnd();
glBegin(GL_LINES);
glVertex2d(x,y-2);
glVertex2d(x+100,y-2);
glEnd();
glBegin(GL_TRIANGLES
);
glVertex2d(x+100,y+3);
glVertex2d(x+110,y);
glVertex2d(x+100,y-3);
glEnd();
glBegin(GL_QUADS);
glVertex2d(x,y+3);
glVertex2d(x,y-3);
glVertex2d(x-10,y-5);
glVertex2d(x-10,y+5);
glEnd(); draw_target();
glFlush();
glutSwapBuffers();

/*to clear screen & set projection mode*/ void

init() { glClearColor(0,0,0,1); glColor3f(1,0,0);
SHOOTING ARCHERY
glMatrixMode(GL_PROJECTION); glLoadIdentity();
gluOrtho2D(0,500,0,500);
glMatrixMode(GL_MODELVIEW);

/*to draw the target inside line loop*/ void

draw_target()

{ glColor3f(1,0,1);
glPointSize(30);
glBegin(GL_POINT
S);
glVertex2d(300,45
0);
glVertex2d(375,40
0);
glVertex2d(400,48
0);
glVertex2d(250,37
0);
glVertex2d(350,33
0);
glVertex2d(450,29
0);
glVertex2d(330,24
5);
glVertex2d(200,20
0);

glVertex2d(400,150)
;
glVertex2d(300,100)
; glEnd();
glColor3f(0,1,1);
glBegin(GL_LINE_LO
OP);
glVertex2d(285,465)
;
glVertex2d(315,465)
;
glVertex2d(315,435)
;
glVertex2d(285,435)
SHOOTING ARCHERY
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(360,415)
;
glVertex2d(390,415)
;
glVertex2d(390,385)
;
glVertex2d(360,385)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(385,495)
;
glVertex2d(415,495)
;
glVertex2d(415,465)
;
glVertex2d(385,465)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(235,385)
;
glVertex2d(265,385)
;
glVertex2d(265,355)
;
glVertex2d(235,355)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(335,345)
;
glVertex2d(365,345)
;
glVertex2d(365,315)
;
glVertex2d(335,315)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(435,305)
;
glVertex2d(465,305)
SHOOTING ARCHERY
;
glVertex2d(465,275)
;
glVertex2d(435,275)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(315,260)
;
glVertex2d(345,260)
;
glVertex2d(345,230)
;
glVertex2d(315,230)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(185,215)
;
glVertex2d(215,215)
;
glVertex2d(215,185)
;
glVertex2d(185,185)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(385,165)
;
glVertex2d(415,165)
;
glVertex2d(415,135)
;
glVertex2d(385,135)
; glEnd();
glBegin(GL_LINE_LO
OP);
glVertex2d(285,115)
;
glVertex2d(315,115)
;
glVertex2d(315,85);
glVertex2d(285,85);
glEnd(); glFlush();

}
SHOOTING ARCHERY

/* to move the arrow left wen 'r' pressed*/ void

id1() { x+=m; disa(); if(x+110>maxx) { x=25; y=0;
count++; glutIdleFunc(id); }

glutPostRedisplay();

/*set key to perform desired operation*/ void

keys(unsigned char k,int x,int y)

{ if(k=='r')
glutIdleFunc(id1
);

/*sub menu to display instructions*/ void

demo_menu(int i)

{ switch(
i) { case
5: case
6: case
7: case
8:break;

/*sub menu to display designer names*/ void

demo(int i)

{s
wi
tc
h(i
)
{c
as
e
SHOOTING ARCHERY
9:
ca
se
10
:

case 11:break;

void game(int id)

{
switch(id)
{

/*main to call display,keyboard and idle func*/ int main(int

argc,char **argv)

int sub_menu,submenu; glutInit(&argc,argv);

glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(900,900);

glutCreateWindow("ARCHERY GAME BLOCK SHOOTING");

sub_menu=glutCreateMenu(demo_menu); glutAddMenuEntry("r to
move right",5); glutAddMenuEntry("10arrows and 10 blocks present",6);
glutAddMenuEntry("lost if arrow count exceeds blocks",7);
glutAddMenuEntry("otherwise win",8);
submenu=glutCreateMenu(demo); glutAddMenuEntry("mamtha",9);
glutAddMenuEntry("priyanka",10); glutCreateMenu(game);

glutAddSubMenu("INSTRUCTION",sub_menu);
glutAddSubMenu("ABOUT",submenu);
glutAddMenuEntry("QUIT",2);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutDisplayFunc(disp); glutIdleFunc(id);
glutKeyboardFunc(keys); init();
SHOOTING ARCHERY
glEnable(GL_DEPTH_TEST); glutMainLoop();
return 0;

CHAPTER 7

PROPOSED SOLUTIONS OR RECOMMENDATIONS

7.1 Proposed System

To achieve three dimensional effects, OpenGL software is proposed. It is software

which provides a graphical interface. It is an interface between application program
and graphics hardware.

The advantages are:

 OpenGL is designed as a streamlined.

 It is a hardware independent interface, it can be implemented on many

different hardware platforms.
 With OpenGL, we can draw a small set of geometric primitive such as points,
lines and polygons etc.
 It provides double buffering which is vital in providing transformations.

 It is event driven software.

 It provides call back function.

4.2 Detailed Design

Transformation Functions
SHOOTING ARCHERY
 Translation:

Translation is done by adding the required amount of translation quantities to

each of the points of the objects in the selected area. If P(x,y) be the a point
and (tx,ty) translation quantities then the translated point is given by
glTranlate(dx,dy,dz);

 Rotation:

The rotation of an object by an angle ‘a’ is accomplished by rotating each of

the points of the object. The rotated points can be obtained using the OpenGL
functions glRotate (angle, vx,vy,vz);

 Scaling:

The scaling operation on an object can be carried out for an object by

multiplying each of the points (x,y,z) by the scaling factors sx, sy and sz.
glScale(sx,sy,sz).
SHOOTING ARCHERY

CHAPTER 8
FUTURE SCOPE
Future Scope of Archery Games

Archery games have significant potential for growth and evolution in the coming
years, driven by advancements in technology, gaming trends, and increasing interest
in archery as both a sport and a recreational activity. Here are some key areas for
future development:

1. Enhanced Realism through VR and AR

o The integration of Virtual Reality (VR) and Augmented Reality (AR)
can create highly immersive archery simulations. Players could feel the
tension of the bowstring, experience real-world physics, and interact
with lifelike environments.
o AR-based games could enable players to transform everyday spaces
into virtual archery ranges, merging real-world surroundings with
interactive gameplay.

2. AI-Driven Personalization and Training

o Artificial Intelligence (AI) could be used to create adaptive gameplay
that adjusts difficulty based on a player’s skill level.
o Archery games could incorporate training modes where AI acts as a
coach, offering feedback on form, aim, and technique.
SHOOTING ARCHERY
3. Esports and Competitive Platforms
o As esports continues to grow, archery games can gain prominence in
the competitive gaming arena. Online multiplayer modes,
leaderboards, and tournaments can engage players worldwide.
o The inclusion of professional leagues and live-streamed events could
attract a broader audience.

4. Gamification of Real Archery Practice

o IoT-enabled bows and arrows could connect to gaming platforms,
turning real-life archery practice into interactive games. Sensors could
track performance and sync it with virtual achievements.

5. Integration of Storytelling and RPG Elements

o Future archery games could incorporate rich narratives, allowing
players to take on roles such as legendary archers, hunters, or warriors
in expansive story-driven environments.
o RPG elements like skill trees, customizable equipment, and character
progression could enhance engagement.

6. Cross-Platform Accessibility
o Archery games could expand across consoles, PCs, and mobile devices
with seamless cross-platform compatibility, allowing players to
continue their progress across multiple devices.

7. Educational and Therapeutic Applications

o Gamified archery can serve as an educational tool for teaching the
principles of physics, focus, and discipline.
o Therapeutic versions of archery games could help with stress relief,
improve concentration, and aid in physical rehabilitation.

8. Social and Community Features

o Social integration could allow players to form teams, compete in
cooperative challenges, and share achievements.
o Virtual archery clubs or metaverse-based archery events could
strengthen community engagement.
SHOOTING ARCHERY
9. Sustainability Themes
o Archery games can incorporate environmental storytelling, focusing on
themes like wildlife conservation and sustainable hunting practices,
raising awareness while entertaining players.

10. Advanced Graphics and Haptics

 With advancements in graphics rendering and haptic feedback technology,

players could experience lifelike visuals and tactile sensations, such as the
vibration of a bowstring or the impact of an arrow hitting a target.

By combining innovative technology with engaging gameplay, archery games have

the potential to appeal to both traditional gamers and enthusiasts of archery as a sport.
Their future lies in bridging the gap between virtual experiences and real-world
applications, making the sport more accessible and exciting for a diverse audience.

CHAPTER 9

CONCLUSION

Archery is an exceptional sport that blends physical strength, mental focus, and
strategic precision, making it a fascinating and rewarding activity for individuals of
all skill levels. From its origins as a tool for survival and warfare to its modern status
as an Olympic sport and recreational pastime, archery holds a significant place in
human history. It is a game that emphasizes patience, practice, and persistence,
enabling players to develop a deeper connection with themselves and their
surroundings. Engaging in archery offers numerous benefits, including improved
concentration, enhanced coordination, and a sense of accomplishment with every
perfect shot. It is also an excellent avenue for building confidence, as the sport
challenges individuals to overcome their own limits while fostering self-discipline.
Beyond the individual level, archery creates a sense of community among enthusiasts,
as players share their experiences and encourage one another to excel.
SHOOTING ARCHERY
Moreover, archery is a highly versatile activity. It can be enjoyed both indoors and
outdoors, providing opportunities to connect with nature and appreciate the tranquility
that often accompanies the sport. For children and adults alike, it promotes valuable
life skills such as goal-setting, determination, and resilience.In essence, archery is not
just a game but a journey of self-improvement and enjoyment. Whether pursued for
competition, recreation, or cultural heritage, archery continues to captivate and inspire
people around the world, offering timeless lessons in precision, patience, and
perseverance.

CHAPTER 10

REFERENCES

1. Interactive computer graphics-Edward angel,2nd edition,Addison-welsey,2000

2. F.S.Hill,jr.:computer graphics using OpenGL,2nd edition,pearson education,2001

3. James.d.Foley,Andries Van Steven K Feiner,F.Hughes,computer

graphics,Addisson- wesley,1997

Websites

1. Google search
SHOOTING ARCHERY
2. www.opengl.org