Loading...

java2

Open Posted By: highheaven1 Date: 01/05/2021 High School Report Writing

 

1 Input

The program reads data from one file, items-0x.txt. Each line in this file represents one item. The first item on every line denotes the Item type–the remainder of the line varies by item type.

Tool Pickaxe Diamond 100 1 Fortune 5
Tool Shovel Gold 20 3 Unbreaking 2
Tool Pickaxe Diamond 100 1 Fortune 5
Potion Speed-II-Potion Spd*2 1
Food Tomato Hunger-10 2
Disposable PotatoCamera ImageQuality-97% 5
Disposable PotatoCamera ImageQuality-97% 5
Tool Axe Stone 10 2 Unbreaking 2
Armour Boots Diamond 100 10 Protection 3 lightning
Armor Boots Diamond 100 10 FeatherFalling 4 lightning

Each Item type is denoted by a keyword:

  • Tool indicates a Tool object.
  • Armour and Armor indicate an Armour object.
  • Food, Potion, and Disposable indicate a Consumable object.

After the leading keywords, each line has a distinct structure:

  1. The remainder of a Tool line contains–in order–a name, material, durability, speed, modifier, and modifier level. Tool Items are not stackable.
  2. The remainder of a Armour line contains–in order–a name, material, durability, defense, modifier, modifier level, and element. Armour Items are not stackable.
  3. The remainder of a Consumable line contains–in order–a name, effect, and # uses. Consumable Items are stackable.

In each of the above classes, you will need to:

  1. Set the stackable attribute–i.e., super.stackable. The attribute, stackable, is a private data member of Item.
  2. Set the name attribute–i.e., super.name. The attribute, name, is a protected data member of Item.


 

2 Output

If the program is run with the first provided input file, items-01.txt, the following output should be generated:

Processing Log:
(S) Pickaxe
(S) Shovel
(S) Pickaxe
(S) Speed-II-Potion
(S) Tomato
(S) PotatoCamera
(S) PotatoCamera
(S) Axe
(S) Boots
(S) Boots

Player Storage Summary:
-Used  90% of 10 slots
 Nme: Pickaxe
 Dur: 100
 Spd: 1
 Mtl: Diamond
 Mdr: Fortune (Lvl 5)

 Nme: Shovel
 Dur: 20
 Spd: 3
 Mtl: Gold
 Mdr: Unbreaking (Lvl 2)

 Nme: Pickaxe
 Dur: 100
 Spd: 1
 Mtl: Diamond
 Mdr: Fortune (Lvl 5)

 Nme: Speed-II-Potion
 Eft: Spd*2
 Use: 1
 Qty: 1

 Nme: Tomato
 Eft: Hunger-10
 Use: 2
 Qty: 1

 Nme: PotatoCamera
 Eft: ImageQuality-97%
 Use: 5
 Qty: 2

 Nme: Axe
 Dur: 10
 Spd: 2
 Mtl: Stone
 Mdr: Unbreaking (Lvl 2)

 Nme: Boots
 Dur: 100
 Def: 10
 Mtl: Diamond
 Mdr: Protection (Lvl 3)
 Emt: lightning

 Nme: Boots
 Dur: 100
 Def: 10
 Mtl: Diamond
 Mdr: FeatherFalling (Lvl 4)
 Emt: lightning

Your output–including labels and spacing–must match the expected output.


 

3 Your Tasks

The key abstractions employed in this program are Inventory, Item, ItemStack, Tool, Armour, and Consumable.

Do not change the packages. The package must remain package edu.odu.cs.cs330.items; for Tool, Armour, and Consumable. Changing the package is an automatic fail. Is this strict? Absolutely. However, I am explicitly instructing you to use this package.

You have a few tasks to complete. First, start with the Armour and Consumable ADTs:

  1. Complete the Default Constructor for each class.
  2. Complete the Copy Constructor for each class.
  3. Complete the clone method for each class.
  4. Complete the read method in each class.
  5. Complete the toString method in each class.

The first few tasks should be familiar–they were your tasks in Assignment 4!. You will then need to complete:

  1. Armour.equals
  2. Armour.hashCode
  3. Consumable.equals
  4. Consumable.hashCode

The rules for computing hash codes and checking for equivalence are listed the Javadoc comments (i.e., in comments before the function).



 

Adding the Tool Class

Your final set of tasks involve completing the Tool class.

  1. Complete the Tool Constructor.
  2. Complete the Tool Copy Constructor.
  3. Complete the Tool clone method.
  4. Complete the Tool read method.
  5. Complete the Tool toString method.
  6. Complete the Tool equals method.
  7. Complete the Tool hashCode method.


Category: Accounting & Finance Subjects: Finance Deadline: 12 Hours Budget: $150 - $300 Pages: 3-6 Pages (Medium Assignment)

Attachment 1

gradlew

#!/usr/bin/env bash ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS="" # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn ( ) { echo "$*" } die ( ) { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin, switch paths to Windows format before running java if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "[email protected]" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=$((i+1)) done case $i in (0) set -- ;; (1) set -- "$args0" ;; (2) set -- "$args0" "$args1" ;; (3) set -- "$args0" "$args1" "$args2" ;; (4) set -- "$args0" "$args1" "$args2" "$args3" ;; (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules function splitJvmOpts() { JVM_OPTS=("[email protected]") } eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong if [[ "$(uname)" == "Darwin" ]] && [[ "$HOME" == "$PWD" ]]; then cd "$(dirname "$0")" fi exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "[email protected]"

gradlew.bat

@if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS= @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windows variants if not "%OS%" == "Windows_NT" goto win9xME_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega

src/main/java/edu/odu/cs/cs330/Storage.java

src/main/java/edu/odu/cs/cs330/Storage.java

package  edu . odu . cs . cs330 ;

import  java . io . FileReader ;
import  java . io . BufferedReader ;
import  java . io . IOException ;
import  java . util . Scanner ;

import  edu . odu . cs . cs330 . items . * ;

/**
 * This is the Storage Driver. It contains the main function, supporting
 * functions, and all argument parsing.
 */
public   class   Storage   {
     /**
     * This is the first Java Assignment, Item Storage in Java.
     *
     *  @param  argv[1] items filename
     *  @param  argv[2] inventories filename
     */
     public   static   void  main ( String []  argv )
     {
         BufferedReader  infile  =   null ;
         Inventory  inv  =   null ;
         int  invSize  =   0 ;

         if   ( argv . length  <   1 )   {
             System . err . println ( "Usage: java -jar Storage.jar items-file" );
             System . exit ( 1 );
         }

         // If an inventory size was specified, parse it.
         try   {
            invSize  =   Integer . parseInt ( argv [ 1 ]);
         }
         catch   ( IndexOutOfBoundsException  e )   {
            invSize  =   Inventory . DEFAULT_SIZE ;   //default to Inventory.DEFAULT_SIZE
         }
         catch   ( NumberFormatException  e )   {
             System . err . println ( "Inventory size must be an integer" );
             System . exit ( 2 );
         }

         // Default to Inventory.DEFAULT_SIZE if invSize is invalid--i.e., <= 0
         if   ( invSize  <   1 )   {
            invSize  =   Inventory . DEFAULT_SIZE ;
         }

         try   {
            infile  =   new   BufferedReader ( new   FileReader ( argv [ 0 ]));
            inv  =  createInventory ( infile ,  invSize );
            infile . close ();

         }
         catch   ( IOException  e )   {
             System . err . println ( "Error: "   +  argv [ 0 ]   +   " could not be opened or read" );
             System . exit ( 3 );
         }

         // Print the Inventory
        printInventorySummary ( inv );
     }

     /**
     * Read an input stream and generate an Inventory.
     *
     *  @param  ins source from which to read Items
     *  @param  size desired number of Inventory slots
     *
     *  @return  initialized Inventory
     *
     *  @throws  IOException if an input error occurs
     */
     public   static   Inventory  createInventory ( BufferedReader  ins ,   int  size )
         throws   IOException
     {
         Scanner    scanner    =   new   Scanner ( ins );
         Inventory  inventory  =   new   Inventory ( size );

         System . out . println ( "Processing Log:" );

         while   ( scanner . hasNext ())   {
             Item  item  =   ItemFactory . parseItemLine ( scanner );

             if   ( item  !=   null )   {
                 boolean  success  =  inventory . addItems ( new   ItemStack ( item ));

                 if   ( success )   {
                     System . out . println ( " (S) "   +  item . getName ());
                 }
                 else   {
                    System . out . println ( " (D) "   +  item . getName ());
                 }
             }
         }
         System . out . println ();

         return  inventory ;
     }

     /**
     * Print the final Inventory summary.
     *
     *  @param  inv Inventory to print
     */
     public   static   void  printInventorySummary ( Inventory  inv )
     {
         System . out . println ( "Player Storage Summary:" );
         System . out . println ( inv );
     }
}

src/main/java/edu/odu/cs/cs330/items/Armour.java

src/main/java/edu/odu/cs/cs330/items/Armour.java

package  edu . odu . cs . cs330 . items ;

import  java . util . Scanner ;

/**
 * This class represents one piece of armour--as found in most video games.
 * This includes boots and helmets.
 *
 * Armour may not be stacked. All Constructors must initialize Item::stackable
 * to false.
 */
public   class   Armour   extends   Item   {
     /**
     * Durability decreases each time armour is used.
     */
     protected   int  durability ;

     /**
     * The amount of damage that can be negated.
     */
     protected   int   defense ;

     /**
     * Base material out of which the armour is constructed.
     */
     protected   String  material ;

     /**
     * Type of enchantment afforded (e.g. protection, feather_falling, or
     * unbreaking)
     */
     protected   String  modifier ;

     /**
     * Enchantment level applied.
     */
     protected   int  modifierLevel ;

     /**
     * Associated element--e.g., ice, fire, and lightning.
     */
     protected   String  element ;

     /**
     * Default to a armour with an empty name, zero durability, zero defense,
     * blank material, no modifier a zero modifier level, and a blank element.
     */
     public   Armour ()
     {
         super ( "" );

         this . durability     =   0 ;
         this . defense        =   0 ;
         this . material       =   "" ;
         this . modifier       =   "" ;
         this . modifierLevel  =   1 ;
         this . element        =   "" ;
     }

     /**
     * Duplicate a piece of armour.
     *
     *  @param  src armour to duplicate
     */
     public   Armour ( Armour  src )
     {
         super ( src . name );

         this . durability     =  src . durability ;
         this . defense        =  src . defense ;
         this . material       =  src . material ;
         this . modifier       =  src . modifier ;
         this . modifierLevel  =  src . modifierLevel ;
         this . element        =  src . element ;
     }

     /**
     * Retrieve armour durability.
     *
     *  @return  remaining durability
     */
     public   int  getDurability ()
     {
         return   this . durability ;
     }

     /**
     * Set armour durability.
     *
     *  @param  dur new durability value
     */
     public   void  setDurability ( int  dur )
     {
         this . durability  =  dur ;
     }

     /**
     * Retrieve armour defense.
     *
     *  @return  total defense provided
     */
     public   int  getDefense ()
     {
         return   this . defense ;
     }

     /**
     * Set armour defense.
     *
     *  @param  def replacement defense
     */
     public   void  setDefense ( int  def )
     {
         this . defense  =  def ;
     }

     /**
     * Retrieve armour material.
     *
     *  @return  base material
     */
     public   String  getMaterial ()
     {
         return   this . material ;
     }

     /**
     * Set armour Material.
     *
     *  @param  mat replacement material type
     */
     public   void  setMaterial ( String  mat )
     {
         this . material  =  mat ;
     }

     /**
     * Retrieve armour modifier.
     *
     *  @return  buff/debuff provided
     */
     public   String  getModifier ()
     {
         return   this . modifier ;
     }

     /**
     * Set armour modifier.
     *
     *  @param  mod updated modifier
     */
     public   void  setModifier ( String  mod )
     {
         this . modifier  =  mod ;
     }

     /**
     * Retrieve armour modifier level.
     *
     *  @return  buff/debuff level
     */
     public   int  getModifierLevel ()
     {
         return   this . modifierLevel ;
     }

     /**
     * Set armour modifier level.
     *
     *  @param  level replacement modifier level
     */
     public   void  setModifierLevel ( int  level )
     {
         this . modifierLevel  =  level ;
     }

     /**
     * Retrieve armour element.
     *
     *  @return  element
     */
     public   String  getElement ()
     {
         return   this . element ;
     }

     /**
     * Set armour element.
     *
     *  @param  ele new element
     */
     public   void  setElement ( String  ele )
     {
         this . element  =  ele ;
     }

    @ Override
     public   boolean  isStackable ()
     {
         return   false ;
     }

     /**
     * Read Armour attributes.
     */
    @ Override
     public   void  read ( Scanner  snr )
     {
         super . name     =  snr . next ();
     }

     /**
     * Clone--i.e., copy--this Armour.
     */
    @ Override
     public   Item  clone ()
     {
         return   new   Armour ( this );
     }

     /**
     * Check for logical equivalence--based on name, material, modifier, and
     * element.
     *
     *  @param  rhs object for which a comparison is desired
     */
    @ Override
     public   boolean  equals ( Object  rhs )
     {
         if   ( ! ( rhs