commit 3d114b8a637ab980c4065ce46d1ee8422a964496 Author: Sam Perry Date: Sat Oct 15 14:52:10 2016 +0100 Initial commit diff --git a/.git-hooks/pre-commit/check_untracked.py b/.git-hooks/pre-commit/check_untracked.py new file mode 100755 index 0000000..8f06f93 --- /dev/null +++ b/.git-hooks/pre-commit/check_untracked.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python + +import subprocess +import os +import pdb +import fnmatch + +import sys + +def main(): + p = subprocess.Popen(["git", "rev-parse", "--show-toplevel"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, err = p.communicate() + + out = out.strip('\n') + track_filepath = os.path.join(out, ".gittrack") + + p = subprocess.Popen(["git", "ls-files", out, "--exclude-standard", "--others"], stdout=subprocess.PIPE, stderr=subprocess.PIPE) + out, err = p.communicate() + + out = out.splitlines() + + try: + with open(track_filepath) as f: + content = f.read().splitlines() + except IOError: + return 0 + + + untracked = [] + for filepath in out: + for name in content: + if fnmatch.fnmatch(filepath, name): + untracked.append(filepath) + + if untracked: + print "The following files are not tracked: " + for i in untracked: + print i + print "Please either stage these files for the commit or add them to the project's .gitignore to disregard them." + return 1 + else: + return 0 + + + +if __name__ == "__main__": + exit(main()) diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2934343 --- /dev/null +++ b/.gitignore @@ -0,0 +1,37 @@ +.DS_Store +bin/ +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod +*.smod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +# Log files +*.log + +external/ +CMakeFiles/ diff --git a/.gittrack b/.gittrack new file mode 100644 index 0000000..6974c05 --- /dev/null +++ b/.gittrack @@ -0,0 +1 @@ +*.pde diff --git a/.overcommit.yml b/.overcommit.yml new file mode 100644 index 0000000..f0b94ee --- /dev/null +++ b/.overcommit.yml @@ -0,0 +1,41 @@ +# Use this file to configure the Overcommit hooks you wish to use. This will +# extend the default configuration defined in: +# https://github.com/brigade/overcommit/blob/master/config/default.yml +# +# At the topmost level of this YAML file is a key representing type of hook +# being run (e.g. pre-commit, commit-msg, etc.). Within each type you can +# customize each hook, such as whether to only run it on certain files (via +# `include`), whether to only display output if it fails (via `quiet`), etc. +# +# For a complete list of hooks, see: +# https://github.com/brigade/overcommit/tree/master/lib/overcommit/hook +# +# For a complete list of options that you can use to customize hooks, see: +# https://github.com/brigade/overcommit#configuration +# +# Uncomment the following lines to make the configuration take effect. + +#PreCommit: +# RuboCop: +# enabled: true +# on_warn: fail # Treat all warnings as failures +# +# TrailingWhitespace: +# enabled: true +# exclude: +# - '**/db/structure.sql' # Ignore trailing whitespace in generated files +# +#PostCheckout: +# ALL: # Special hook name that customizes all hooks of this type +# quiet: true # Change all post-checkout hooks to only display output on failure +# +# IndexTags: +# enabled: true # Generate a tags file with `ctags` each time HEAD changes + + +PreCommit: + CheckUntracked: + enabled: true + quiet: false + description: 'Check for files that should be tracked or ignored.' + required_executable: './.git-hooks/pre-commit/check_untracked.py' diff --git a/Assignment_2.pde b/Assignment_2.pde new file mode 100644 index 0000000..5d7cdc4 --- /dev/null +++ b/Assignment_2.pde @@ -0,0 +1,165 @@ +/* + * IDMT Mini-Assignment 2 + * + * Tank Wars: a simple game of throwing projectiles + * This is a skeleton with a few basic pieces filled + * in. You will need to fill in the rest to make the + * game work. + */ + +// Basic information on the terrain and the tanks + +float[] groundLevel; // Y coordinate of the ground for each X coordinate +float tank1X, tank1Y, tank2X, tank2Y; // Positions of the two tanks +float tankDiameter = 30; // Diameter of the tanks +float cannonLength = 20; // How long the cannon on each tank extends +float gravity = 0.05; // Strength of gravity + +// Current state of the game + +int playerHasWon = 0; // 1 if player 1 wins, 2 if player 2 wins, 0 if game in progress +boolean player1Turn = true; // true if it's player 1's turn; false otherwise +float tank1CannonAngle = PI/2, tank2CannonAngle = PI/2; // Direction the tank cannons are pointing +float tank1CannonStrength = 3, tank2CannonStrength = 3; // Strength of intended projectile launch + +// Location of the projectile + +boolean projectileInMotion = false; +float projectilePositionX, projectilePositionY; +float projectileVelocityX, projectileVelocityY; + +void setup() { + size(960, 480); // Set the screen size + + // Initialize the ground level + groundLevel = new float[width]; + float player1Height = random(height/2, height-5); + float player2Height = random(height/2, height-5); + for(float i = 0; i < width * 0.2; i++) { + groundLevel[(int)i] = player1Height; + } + for(float i = width * 0.2; i < width * 0.8; i++) { + groundLevel[(int)i] = player1Height + (player2Height - player1Height) * (i - width*0.2)/(width*0.6); + } + for(float i = width * 0.8; i < width; i++) { + groundLevel[(int)i] = player2Height; + } + + // Set the location of the two tanks so they rest on the ground at opposite sides + tank1X = width * 0.1; + tank1Y = player1Height; + tank2X = width * 0.9; + tank2Y = player2Height; +} + +void draw() { + // Main draw loop. Farm out the individual tasks to other functions + // for clarity (though it could be equivalently implemented entirely in this function.) + + background(200); + + drawGround(); + drawTanks(); + drawProjectile(); + drawStatus(); + + updateProjectilePositionAndCheckCollision(); +} + +// Draw the terrain under the tanks +void drawGround() { + /* TO IMPLEMENT IN STEP 1 */ + beginShape(); + + int idx = 0; + for (Iterator it = groundLevel.iterator(); it.hasNext(); idx++) { + + float level = it.next(); + vertex(idx, level) + } + + // See the groundLevel[] variable to know where to draw the ground + // Ground should be drawn in a dark gray +} + +// Draw the two tanks (including cannons) +void drawTanks() { + /* TO IMPLEMENT IN STEP 1 */ + + // Draw the two tanks as semicircles using the positions and sizes at the top of the file + // Tanks should be different colours + // Also be sure to draw the cannons, using the angles given at the top of the file +} + +// Draw the projectile, if one is currently in motion +void drawProjectile() { + if(!projectileInMotion) // Don't draw anything if there's no projectile in motion + return; + noStroke(); + fill(255, 255, 0); + ellipse(projectilePositionX, projectilePositionY, 8, 8); +} + +// Draw the status text on the top of the screen +void drawStatus() { + textSize(24); + textAlign(LEFT); + fill(0); + + if(playerHasWon == 1) + text("Player 1 Wins!", 10, 30); + else if(playerHasWon == 2) + text("Player 2 Wins!", 10, 30); + else if(player1Turn) { // player1Turn == true means it's player 1's turn + text("Player 1's turn", 10, 30); + textAlign(RIGHT); + text("Angle: " + tank1CannonAngle + " Strength: " + tank1CannonStrength, width - 10, 30); + } + else { // player1Turn == false + text("Player 2's turn", 10, 30); + textAlign(RIGHT); + text("Angle: " + tank2CannonAngle + " Strength: " + tank2CannonStrength, width - 10, 30); + } +} + +// Move the projectile and check for a collision +void updateProjectilePositionAndCheckCollision() { + if(!projectileInMotion) + return; + + /* TO IMPLEMENT IN STEP 3: UPDATE POSITION */ + // Tasks: increment the position according to the velocity + // For later: the velocity according to gravity (and optionally wind) + + /* TO IMPLEMENT IN STEP 4: GRAVITY */ + // Update the velocity of the projectile according to the value of gravity at the top of the file + + /* TO IMPLEMENT IN STEP 5: COLLISION DETECTION */ + // Compare the location of the projectile to the ground and to the two tanks + // When the projectile hits something, it stops moving (change projectileInMotion) + // When the projectile hits the ground, it's the next player's turn + // When the projectile hits a tank, the other player wins +} + +// Advance the turn to the next player +void nextPlayersTurn() { + player1Turn = !player1Turn; +} + +// Handle a key press: update the status of the current player's tank +void keyPressed() { + if(playerHasWon != 0) // Stop the game when someone has won + return; + if(projectileInMotion) // No keys respond while the projectile is firing + return; + + /* TO IMPLEMENT IN STEP 2 */ + + // Use the key variable to check which key was pressed. + // Arrow keys don't have a printable character, so they show up as CODED + // Use the left and right arrows to adjust the angle, the up and down arrows + // to adjust strength. + + // Space bar fires the projectile. Initially in step 2, just have it switch + // to the next player. +}