CPSC 219代做、代写Java语言设计

项目预算：开发周期：发布时间：要求地区：

CPSC 219: Introduction to Computer Science II
Assignment 1: Procedural Java – Snake Game
Course: CPSC233S24
Due Date: Friday, Sept. 27, 2024
Instructor: Steve Sutcliffe Version: 1.1.1
Weight: 10%
Objective:
Write a Java program with a standard procedural structure and save the work to a repository.
Group Size: 1‐2
This assignment can be completed independently, or you may pair with another individual from the same tutorial. You and your partner must write all the code you submit. Refer to the plagiarism guide at the end of this document for more details. You and your partner should be able to answer any questions about the codebase and fully understand what the code is doing. Individual marks may differ from the overall assignment grade based on how well you can answer these questions. If working with a partner, you and your partner must submit a solution to D2L. If a Git repository is required, you may use the same repository or separate repositories.
Technology
Java (JDK) 22, Git
Submission instructions
You must submit your assignment electronically in D2L, commit it to a repository in GitLab (csgit.ucalgary.ca), and have all of the TAs and instructors set as developers on the repository.
Submit your completed SnakeGame.java to D2L. Do not submit *.class files or any other files. Include your name and UCID at the top (and your partner’s if you have one). Additionally, submit a text document with the link to your repository (name the document gitlink.txt).
Please use the Assignment 1 Dropbox in D2L to submit your codebase. This submission must include all required .java files, which will be listed later. If you complete this assignment with a partner, you and your partner must submit the assignment to the Assignment 1 Dropbox in D2L.
In D2L, you can submit multiple times over the top of a previous submission. Do not wait until the last minute to attempt to submit! D2L is notorious for glitches and hangups at the 11th hour.
Your assignment must be completed in Java (not Kotlin or others) and executable with Java version 22 (JDK 22). You must only use standard libraries. Failure to submit the required .java files in D2L will be treated as a non‐ submission for the assignment. TAs will not grade .class files and will not make requests for missing files. Do not submit complete IntelliJ project folders in D2L.

Overview
You will complete a Java program that simulates a simplified version of the classic Snake game. The game's objective is for the player to navigate the snake around a grid, eating food to grow longer while avoiding collisions with the walls or itself. Your program must adhere to procedural programming principles and use global variables to maintain the game state. You will create one Java file: SnakeGame.java. The program will be text‐based and should use methods from both files to function correctly.
Game Description
In this simplified Snake game, the player controls a snake that moves around a grid. The snake grows longer each time it eats food, and the game ends if the snake collides with itself or the walls.
Game Specifications:
GAME BOARD
The game grid will be 20 (wide) x 10 (tall), and the walls will be marked with ‘#’ symbols.
THE SNAKE
The snake is represented by one or more ‘S’ characters. Whenever the game starts, it should start at a random location. When the game first starts, the length of the snake is 3. However, only the head is visible as the player moves, the remaining segments of the snake become visible. Whenever the snake eats a fruit (the ‘@’) the snake will grow in length (up to a maximum of 100 segments). If the snake hits a wall (the ‘#’) or itself the game ends.
The player can move the snake up, down, left, or right using the ‘w’, ‘a’, ‘s’, ‘d’ keys and they can quit the game using the ‘q’ key.
FOOD
The food is represented by an ‘@’ character and appears at random locations, but it cannot appear on the snake (S) or on the walls (#).
THE WALLS
The walls form the perimeter of the game board, and are represented by the ‘#’ symbol. The food and segments of the snake cannot be on the wall. A segment of the wall must be at 0,0 (see achievements).

EXAMPLE
Below is an example of the first few steps in the game:
####################
#..S...............#
#..................#
#..................#
#....@.............#
#..................#
#..................#
#..................#
#..................#
####################
Enter: w/a/s/d/q
s
####################
#..S...............#
#..S...............#
#..................#
#....@.............#
#..................#
#..................#
#..................#
#..................#
####################
Enter: w/a/s/d/q
s
####################
#..S...............#
#..S...............#
#..S...............#
#....@.............#
#..................#
#..................#
#..................#
#..................#
####################
Enter: w/a/s/d/q
s

####################
#..................#
#..S...............#
#..S...............#
#..S.@.............#
#..................#
#..................#
#..................#
#..................#
####################
Enter: w/a/s/d/q
d
####################
#..................#
#..................#
#..S...............#
#..SS@.............#
#..................#
#..................#
#..................#
#..................#
####################
Enter: w/a/s/d/q
d
####################
#..................#
#.................@#
#..S...............#
#..SSS.............#
#..................#
#..................#
#..................#
#..................#
####################

Requirements
Global Variables: Use global variables to maintain the game state, including the snake's position, the length of the snake, and the game grid.
Procedural Design: Your implementation must be procedural without custom classes and objects.
Documentation: Provide clear comments and documentation within your code explaining each function's functionality and the program's overall structure.
Display: in the console, display the game grid, the food and the snake
User Interaction: Input commands to move the snake ('w' for up, 's' for down, 'a' for left, 'd' for right, ‘q’ to quit).
Check for collisions and generate new food after the snake “eats” the existing food.
End the game when the snake collides with the walls or itself.
The snake should start as three segments long and should “grow” (add another segment) each time after it “eats” the food.
A starting file has been provided for you. You must use the variables and methods present in that file (e.g., initializeGame()), but you can add any additional variables and methods you need.
Demonstration
You must demonstrate your assignment to the tutorial leader to receive a mark for this assignment. The tutorial leader will ask questions to test your understanding of your submitted code. Your assignment will receive an F if you cannot sufficiently answer any of the questions from a TA or instructor. A demo is required in order to receive any grade for this assignment.
Grading
You will receive a B‐grade if you complete everything this assignment requires. You can complete additional requirements to improve your grade beyond a B+ (see the A Grade Range Requirements). These additional tasks are designed to challenge you further and provide an opportunity to demonstrate a deeper understanding of the material and greater skill.
The most important part of these assignments is your understanding of the code. You need to be able to demonstrate that you understand the code you are submitting. Failure to explain your code will be considered a case of copying code from another source (ChatGPT, another student, etc.) and qualify for academic misconduct.

B GRADE RANGE REQUIREMENTS:
Submission Complete: The assignment was submitted on time to D2L with all required files (SnakeGame.java and gitlink.txt) and a link to GitLab with the TAs and instructor as developers.
Functionality: The program works as required and meets the specifications (initializing the game, displaying the grid, moving the snake, and generating food).
Code Base: All of the required methods and variables are present and the code makes logical sense. Code Documentation: Code is well documented.
Demonstration: The student satisfactorily answers the tutorial leader's questions about the code and clearly understands the implementation.
A GRADE RANGE REQUIREMENTS
To improve your grade beyond a B, you need to complete all of the tasks outlined in the B Grade Range Requirements and the additional tasks below. The TAs will not help you with these.
Obstacles: Add random obstacles ('%') to the grid that the snake must avoid. These obstacles should not move but provide additional challenges for navigation.
Wrap‐Around Movement: Implement wrap‐around movement so that the snake can move off one grid edge and reappear on the opposite edge in areas with gaps in the wall (you will also need to implement the gaps in the wall).
C GRADE RANGE REQUIREMENTS
Submission: The assignment is submitted on time to D2L with all required files and a link to the repository with the TAs and instructor as developers.
Code Explanation: The student satisfactorily answers the tutorial leader's questions about the code and clearly understands the implementation.
One or more of the following apply:
Limited Functionality: The game grid displays the walls, the food and the starting location of the snake, but other functionality is missing or broken.
Limited/No Documentation: Significant parts of the code are not adequately documented.
Code Quality: The code breaks a few of the requirements (e.g., methods and variables required to be used, or is not procedural, etc).
D Grade Range
Significant portions of the program are missing or broken, however, required files were submitted. Explanations of the code are poor.
F Grade
Submission was missing or the student is not able to answer the questions of the TA adequately.

LATE POLICY
The following late policy from SENG300 will be used if you are out of the five grace days:
assessment_grade = raw_grade * (1 – max(0, (hours_late ‐ 1) / 47))
This means there is a maximum of 1 hour grace period before the penalties begin. After 48 hours, the assignment is worth 0.

INCOMPLETE
This assignment will be marked as “Incomplete” if any of the conditions below apply to your assignment. If your assignment is incomplete, you must submit the missing components within two days. Failure to submit incomplete assignment components will result in an (F) for that assignment. Each missing component will decrease your letter grade for the assignment by half a letter grade step.
Incomplete conditions:
 GitLab repo incomplete (missing link, TAs and instructor not established as a developer)
 Required *.java files missing in D2L
 Required *.java files missing in the repository
Plagiarism
Discussing the assignment requirements with others is reasonable and an excellent way to learn. However, the work you hand in must ultimately be your work. This is essential for you to benefit from the learning experience and for the instructors and TAs to grade you fairly. Handing in work that is not your original work but is represented as such is plagiarism and academic misconduct. Penalties for academic misconduct are outlined in the university calendar.
Here are some tips to avoid plagiarism in your programming assignments.
1. Cite all sources of code you hand in that are not your original work. You can put the citations into comments in your program. For example, if you find and use code found on a website, include a comment that says, for example:
# The following code is from
Use the complete URL so that the marker can check the source.
2. A tool like chat‐GPT can be used to improve small code blocks. For example, five lines of code. If you get help from code assistance like Chat‐GPT, you should comment above the block of code you requested assistance on debugging or improving and cite the tool used to get that suggestion. Using a tool like chat‐ GPT to write the majority of your assignment requirements will be treated as plagiarism if found without citation, and with citation, it will be treated as 0 for the component the student did not complete. Code improvement of short length will get credit if commented/cited properly.
3. Citing sources avoids accusations of plagiarism and penalties for academic misconduct. However, you may still get a low grade if you submit code not primarily developed by yourself. Cited material should never be used to complete core assignment specifications. Before submitting, you can and should verify any code you are concerned about with your instructor/TA.
4. Discuss and share ideas with other programmers as much as you like, but make sure that when you write your code, it is your own. A good rule of thumb is to wait 20 minutes after talking with somebody before writing your code. If you exchange code with another student, write code while discussing it with a fellow student, or copy code from another person’s screen, this code is not yours.
5. Collaborative coding outside your team is strictly prohibited. Your assignment submission must be strictly your code. Discussing anything beyond assignment requirements and ideas is a strictly forbidden form of collaboration. This includes sharing code, discussing the code itself, or modelling code after another

student's algorithm. You cannot use (even with citation) another student’s code.
6. Making your code available, even passively, for others to copy or potentially copy is also plagiarism.
7. We will look for plagiarism in all code submissions, possibly using automated software designed for the
task. For example, see Measures of Software Similarity (MOSS ‐ https://theory.stanford.edu/~aiken/moss/).
8. Remember, if you are having trouble with an assignment, it is always better to go to your TA and/or instructor for help rather than plagiarizing. A common penalty is an F on a plagiarized assignment.
9. See the Course Outline for the policy on Generative AI use (such as ChatGPT). Generally, you can use ChatGPT to help understand concepts and to debug code. Always cite your use of Generative AI and explain what the code does.