Category: Desktop software development

USE ONLY NETBEANS 8.2 IDE, NO OTHER IDE’s ALLOWED!

Write a Java program which uses the LWJGL library to draw a window of 640×480 (with a black background).

THIS PROGRAM WILL NOT USE ANY OTHER GRAPHICS LIBRARIES BESIDES LWJGL!

To download and setup LWJGL with Netbeans 8.2 go here:
http://wiki.lwjgl.org/wiki/Setting_Up_LWJGL_with_NetBeans.html

The coordinate system should be centered in this window. Your program will read a file titled ‘coordinates.txt’ and draw the corresponding filled polygon in this window using the scanline polygon fill algorithm.

Each specified polygon should be filled in the color specified in the text file and then undergo the transformations specified in the input file before being drawn on the screen.

Hence you will need to calculate the composition ofthe transformation matrices and then calculate the position of the polygon vertices and then apply the scan line
fill algorithm.

Use the glVertex2f() command to plot the pixel and glColor3f() to specify the color. Finally, your program should also use the input.Keyboard class to have the escape key quit your application.

The given coordinates.txt file will be in the following format:
P 0.5 0.6 0.3
30 300
80 150
160 400
200 150
250 300
T
r 45 0 0
s 0.5 1.5 0 0
t 200 150
r 90 0 0
P 0.2 0.4 0.7
-350 350
-350 350
350 350
350 350
T
r 90 0 0
t 100 100
s 0.5 0.5 0 0

The file coordinates.txt will contain an ordered set of vertices for the polygon. The polygon can be drawn by joining the first vertex to the second, the second to the third and so on, until the final vertex is joined to the first to close the polygon.

It denotes the polygon vertices by using the symbol P and the transformations for that
polygon by using the symbol T. The symbol P is followed by three-float numbers that signify the R, G and B values specifying the fill color of the polygon.

The symbols r, s and t stand for rotation, scaling and translation
respectively. The symbol r is followed by the rotation angle, and the coordinate for the pivot point. Similarly the symbol s is followed by the scaling factors in the x and y direction and the pivot point coordinates.

The symbol t is followed by the translation coordinates in the x and y direction. The sample file shows two polygons and the transformations for each polygon.

When your program is evaluated, a different coordinates.txt file will be used to grade, so be sure your algorithm tests all cases, such as polygons with interior and exterior regions as well as self intersections.

There will be more than two polygons in the test file, so read till end of the file and not just two polygons.

Note: Please do not turn in anything that does not use Java with the LWJGL library.

I have attached a sample coordinates file and a picture with an example of what it should look like. When you are finished, the program should look like the example.png picture.

Write a program that prints the current world population on screen. Then give them a choice of at least three locations to put the population in (one of which has to be Texas. The other two can be your choice). It then prints the amount of space per person in sq. ft., sq. mi., and acres for that location.Also, I want you to do the area conversions inside of Python. Start with one of the values (Square Feet, for example) and then get the other values by converting the Square Feet into Square Miles and Acres.

Given the following relation schemes:

Teacher = [CourseN, Quarter,TeacherName]
Course = [CourseN,CourseName, Nunit)
Student = [studentName, CourseN, Quarter]
LocationNTime = [CourseN, Quarter , DayTime,  RoomN]

//Examples of DayTime: M2:00AM, W4:50PM, and T8:00PM. Note that DayTime is represented as a string.

Express the following queries by SQL statements and test them using any appropriate data. Take screenshots of the result, please let me know what program you use and please show all answers in complete form.

1. List the name of every teacher (distinct names) who teaches in RoomN 34 in Winter2011.

2. List CourseN, CourseName,  and TeacherName of every course meets on Monday PM.

3. List the name of every teacher who taught at least one course in RroomN 723.

4. List the CourseN, Quarter, RoomN and DayTime of every course taught by Karen Reed in the Spring 2005.

5. List the CourseN and TeacherName of every course taken by the student Ron Smith or by the student David Weidman.

6. List the CourseN and Quarter of every course taught by Karen Reed and met or meets in RoomN 713.

7. List the name of every teacher who has taught the same course at least two times.

8. List the name of every teacher( distinct names) who has taught at least two different courses in the same or different quarters.

9. List the CourseN, CourseName, and Quarter which meets or met at least two times a week.

10. List the CourseN and CourseName of every course with number of units > 4.

11. List every course number and students name who has taken the course at least twice.

12. Use * to list the CourseN, CourseName, Nunit, Quarter, TeacherName of every
course sorted by CourseN ascending, CourseName descending. 

13. List the CourseN and Quarter of every course taught by two different instructors in the same quarter ordered by the CourseN in descending order.

Design an object card
Design an object Deck
Design a driver program

Use these class diagrams to create your objects.

————————————-
                    Card
————————————-
-int _value
-String _suit
-String _Color
-String _Face
————————————-
+Card(int value, String suit)
+String toString()
+String getColor()
+String getFace()
+int getValue()
+String getSuit()
————————————

————————————
                    Deck
————————————
-List <Card> _cards
————————————
+Deck()
-void loadCards()
+Card drawCard()
+int getDeckSize()
+void shuffle()
————————————

Write a driver program that produces the output below.
Your program must match the provided class diagrams.
The program must draw a card randomly from a standard deck of 52 cards.
Your program must not print the same card twice until the deck runs out.
Your program must shuffle the deck when it runs out of cards.
Your program should produce different output every time it runs (Based on randomly selecting cards)
Each object and the driver program should be in separate files.

SAMPLE RUN #1: java Driver

Printing 79 random cards

Jack of Spades
5 of Diamonds
10 of Spades
3 of Clubs
Ace of Diamonds
King of Clubs
King of Hearts
7 of Clubs
2 of Diamonds
8 of Spades
9 of Clubs
2 of Spades
Ace of Spades
2 of Clubs
10 of Hearts
3 of Spades
2 of Hearts
4 of Spades
7 of Spades
Queen of Spades
10 of Diamonds
3 of Diamonds
Queen of Hearts
6 of Diamonds
9 of Hearts
King of Diamonds
4 of Diamonds
8 of Hearts
Jack of Hearts
Queen of Clubs
Ace of Hearts
7 of Diamonds
10 of Clubs
9 of Diamonds
Jack of Diamonds
Queen of Diamonds
4 of Clubs
6 of Hearts
8 of Diamonds
6 of Spades
7 of Hearts
3 of Hearts
8 of Clubs
5 of Spades
9 of Spades
5 of Hearts
King of Spades
4 of Hearts
6 of Clubs
Ace of Clubs
5 of Clubs
Deck is empty, shuffling!
Queen of Hearts
6 of Diamonds
4 of Spades
7 of Diamonds
Queen of Clubs
4 of Diamonds
8 of Hearts
King of Diamonds
5 of Spades
Jack of Clubs
7 of Hearts
7 of Clubs
2 of Diamonds
6 of Hearts
6 of Clubs
Jack of Diamonds
Queen of Diamonds
4 of Hearts
3 of Clubs
10 of Diamonds
Ace of Spades
Ace of Hearts
3 of Hearts
5 of Clubs
8 of Spades
3 of Diamonds
King of Clubs
King of Spades
Deck Remaining 24
Poker Hand !
10 of Spades
2 of Hearts
Ace of Diamonds
Jack of Spades
King of Hearts
Deck Remaining 19

For this assignment, you will be writing classes that model different kinds of 2
dimensional shapes, and each shape will be able to calculate its perimeter and area.
Well define a superclass call Shape, that consists of a set of points in 2 dimensional
space (Point2D), which represent the vertices and are ordered such that any given
Point2D and the next Point2D represent an edge (a side) of the shape, in a clockwise
manner. The last point and the first point are also assumed to define an edge. The
Point2D objects should be fed into the constructor for each shape IN THAT ORDER.

1)Write a method delete() that takes an int argument k and deletes the kth element in a
linked list, if it exists.
(i want to be able to choose what my input k will be, i do want hard coded and do not use  )

2)Write a method max() that takes a reference to the first node in a linked list as argument and returns the value of the maximum key in the list. Assume that all keys are positive integers,and return 0 if the list is empty

I need to have 100 story points out of an available 300 from the backlog which is in the documents uploaded. I have a starting code with GUI with some basic functions available which can be downloaded from this link.(BusinessLogic3 and UserInterface3)

You have clean and build the BL file first then the GUI file before running the application.

I can provide more details if this is something you’re confident in doing and have experience.  i expect this to take roughly 20 hours fo work so works out at $25 per hour.

Thank You

You have been hired by Magic Gaming company to create a program to play the game Riders of Fortune, which will be a text-based fantasy style board game. The game plays as follows:
You play Yarra, a young horseman in search of the of the illustrious Chalice of Knowledge, an artifact that will bring you everlasting wisdom.  The Chalice can only be found in dragon dungeon after defeating the dragon.
Yarra will have will have Experience Points (XP) that start at 0. He starts up with a knife, but can upgrade his weapon. He can also attack monsters and if he beats them, they will provide XP.
The Game Board : The game board will always be displayed on the screen as an array of characters.

Onscreen Map To Be Displayed:
P * * * * * * * * * * * * * * * * * * * * * * * * * * * * D

Mapping of spaces:
P 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 D
P: Corresponds to where the player is currently located (The player starts on space 1)
D: Corresponds to the last space, where the Dragon is
There are 28 positions on the board and the player starts in space 1. The player can only travel forward (higher numbers). The dungeon dragon is on space 28 marked with a D. The player obtains the Chalice if he can slay the dragon. You must keep track of the players current position and mark it on the onscreen map with P.
Player Movement:
You will provide the player with the following menu:
1)    Travel to another space on the board
2)    Dismount and explore the current space
If the player chooses option 1, a six-sided die will be rolled, and the player must move to that space.
If the player dismounts and explores the space the space the following can happen:
1)    The player encounters a monster and must battle
2)    The player finds a new weapon
3)    The area is empty, no change.
Outcome 1: Fights a monster
During initialization, randomly choose 14 spaces that will have a monster. The monsters will have an HP of 3 to 7 (You can decide when defining the monsters).
The attack amount will be calculated by rolling a six-sided die plus the extra damage of the weapon being carried. If Yarra fails to destroy the monster on the first attack he will die.
If Yarra destroys the monster, he will gain XP of 2 per defeat.
Outcome 2:  Finds a new weapon:
There will be 5 weapons that can be found in the game. Each weapon will be allocated to a space. The weapon will give a modifier (an amount added to the result of the die roll).
    Crossbow: +3 on attack
    Flail:  +4 on attack
    Broad Sword: +5 on attack
    Dragon Slayer: +6 on attack
    Spell of The Gods: +7 on attack
Have the program choose 5 random spaces that will contain the weapons instead of monsters (except for space 1, and 28).
If you find a weapon which has an attack higher than the weapon you are carrying, equip the new weapon. Otherwise keep the weapon you previously had.
Outcome 3: Area is empty:
Have the program choose 7 random spaces that will be empty (will no contain a weapon or a monster)
Display the following message:
There is nothing for you to do, so you reflect upon your adventures thus far. You take the time to train and enhance your reflexes
Your XP increases by 1.
Encounter:
If the player encounters a monster, the player must roll the die to obtain an attack value. The players weapon provides an additional attack value to the to the value of the die. If the player fails to kill the monster with the attack, the monster will destroy the player.
For example, if player rolls a 4 but they have a Broad Sword (+4), their total attack is 4 + 4 = 8
End Game:
If the player reaches spot 28 (by either rolling enough to get to 28 or rolling more than 28, the player will face the dragon only if his XP is equal to or higher than 5.
If he doesnt have the XP required, the following message will display and end the game.
Alas, the dragons eyes stare at you and places you under his spell. You try to move but fail to do so and find yourself torched by the dragons fire. If only you had more experience, you could have seen it coming.
If the player does have the XP required, he will attack the dragon. The dragon will have an HP of 10. If he can kill the dragon, the following message will display:
Due to your cunning and experience, you have defeated the deadly dragon. Your quest has ended good sir. Youve obtained the Chalice of knowledge and all of earths mysteries are revealed.
Additional Requirements:
1.    Make sure you always display the player stats ((XP) and Current Weapon).
2.    Make sure you display the result of the die roll
3.    Make sure you display the total attack.
4.    Make sure you display the HP of the monster you encounter.

Please see attached document for further details. I already have a project in Python that I would like to recreate and/or enhance in Java for this assignment or we can choose any other project you are comfortable with also if agreed upon beforehand.

This assignment is broken up into 6 iterations.

Please note all of the yellow highlighted areas. Areas highlighted green may stay the same or will have a small change from the previous answer. I have modified the Guideline document as I will complete the necessary parts.