//PARSE WITH NORMAL TADS OPERATORS
#pragma C-



modify breakVerb
  verb = 'break' 'ruin' 'destroy' 'chop'
  sdesc = "break"
  doAction = 'Break'
  ioAction(withPrep) = 'BreakWith'
;

modify attackVerb
    verb = 'attack' 'kill' 'hit'
    sdesc = "attack"
    doAction = 'Attack'
    prepDefault = withPrep
    ioAction(withPrep) = 'AttackWith'
;

burnVerb:  deepverb
  verb = 'burn' 'light'
  sdesc = "burn"
  doAction = 'Burn'
  ioAction(withPrep) = 'BurnWith'
;

Pourverb:  deepverb
  sdesc = "pour"
  verb = 'pour'
  doAction = 'Pour'
  ioAction(onPrep) = 'PourOn'
;

Emptyverb:  deepverb
  sdesc = "empty"
  verb = 'empty'
  doAction = 'Empty'
;

Fillverb:  deepverb
  sdesc = "fill"
  verb = 'fill'
  doAction = 'Fill'
  ioAction(withPrep) = 'FillWith'
;

modify class item
  verDoLift( actor ) = self.verDoTake( actor )
  doLift( actor ) = self.doTake( actor )
;



modify class thing
  type = nil
  verDoTalkTo( actor ) = {}
  doTalkTo( actor ) =
  {
    "\^<<self.thedesc>> doesn&rsquo;t seem interested.\n";
  }
  verDoOil(actor) = 
  {
    "You cannot oil <<self.thedesc>>";
  }
  verDoLift( actor ) = 
  {
    "You cannot lift <<self.thedesc>>";
  }
  verDoBreak(actor) = {}
  doBreak(actor) =
  {
    askio(withPrep);
  }
  verDoAttack(actor) = {}
  doAttack(actor) =
  {
    askio(withPrep);
  }
  verIoBreakWith(actor) = {}
  ioBreakWith(actor, dobj) =
  {
    "\^<<self.thedesc>> cannot be used to break anything.\n";
  }
  verDoAttackWith(actor, iobj) = {}
  verDoBreakWith(actor, iobj) = {}
  verDoBurn(actor) = 
  {
    if ( self.type = nil )
    "\^<<self.thedesc>> cannot be burned.\n";
  }
  doBurn(actor) =
  {
    self.tmpList := actor.contents + actor.location.contents;
    self.tmpObj := car( tmpList );
    self.tmpFObj := nil;
    while ( tmpObj <> nil )
    {
      if ( tmpObj.isfire )
      tmpFObj := tmpObj;
      tmpList := cdr( tmpList );
      tmpObj := car( tmpList );
    }
    if ( tmpFObj <> nil )
    {
      "(With <<tmpFObj.thedesc>>)\n";
      if ( not actor.isCarrying( tmpFObj ) )
      {
        "(First taking <<tmpFObj.thedesc>>)\n";
        tmpFObj.doTake( actor );
      }
      tmpFObj.ioBurnWith(actor, self);
    }
    else
    askio(withPrep);
  }
  verIoBurnWith(actor) = 
  {
    "\^<<self.thedesc>> cannot be used to burn things.\n";
  }
  verDoBurnWith(actor, iobj) = {}
  verDoTake( actor ) =
  {
    if ( self.ishot )
    "\^<<self.thedesc>> is too hot to touch right now, you\'ll have to wait for it to cool down.\n";
  }
  verDoTouch( actor ) =
  {
    if ( self.ishot )
    "\^<<self.thedesc>> is too hot to touch right now, you\'ll have to wait for it to cool down.\n";
  }
  doTouch( actor ) =
  {
    "You feel nothing notable.\n";
  }
  verIoPourOn( actor ) = {}
  ioPourOn( actor, dobj ) =
  {
    if( isclass( dobj, liquidcont ) ) //IF DOBJ IS CONTAINER ASSUME PLAYER MEANS CONTENTS OF CONTAINER
    dobj := car( dobj.contents );

    "You pour <<dobj.thedesc>> out and watch as it ";
    if( !isclass(self, wood) and !isclass(self, earth) )//EARTH AND WOOD ABSORB LIQUID
    "runs across the surface of <<self.thedesc>> and pours out onto the ground.";
    else
    "slowly soaks into <<self.thedesc>>, disappearing in moments.";

    if( dobj.isdynamic ) //DELETE DYNAMIC OBJECTS
    delete dobj;
    else
    dobj.moveInto( nil ); //STATIC OBJECTS ARE MOVED INTO NIL
  }
  scriptNum = 0
  script = 
  {
    self.scriptNum++;
    switch( self.scriptNum )
    {
      case 1:
      break;
      case 2:
      break;
      case 3:
      {
        self.ishot := nil;
        unnotify (self, &script);
        self.scriptNum := 0;
      }
    }
  }
;



class firestarter:  thing
  isfire = true
  verIoBurnWith(actor) = {}
  ioBurnWith(actor, dobj) =
  {
    if ( self.isfire )
    {
      if ( actor.isCarrying( dobj ) )
      "It would likely be less painful if you avoided burning things while you were carrying them.\n";
      else if ( dobj.type = fragile )
      {
      "The heat from <<self.thedesc>> causes <<dobj.thedesc>> to blacken and crack but it does not burn.\n";
      dobj.burned.moveInto( dobj.location );
      dobj.moveInto( nil );
      }
      else if ( dobj.type = hard )
      {
      "\^<<self.thedesc>> causes <<dobj.thedesc>> to heat up but it refuses to burn.\n";
      dobj.ishot := true;
      notify (dobj, &script, 0);
      }
      else if ( dobj.type = wood )
      {
      "The fire from <<self.thedesc>> quickly catches and <<dobj.thedesc>> ";
        if ( dobj.contents )
        {
          self.tmpList := dobj.contents;
          self.passList := [];
          self.tmpObj := car( tmpList );
          while ( tmpObj <> nil )
          {
            outhide( true );
            self.ioBurnWith( actor, tmpObj );
            outhide( nil );
            if ( tmpObj.location <> nil )
            {
              tmpObj.moveInto( dobj.location );
              self.passList := self.passList + tmpObj;
            }
            else
            tmpObj.burned.moveInto( dobj.location );
            tmpList := cdr( tmpList );
            self.tmpObj := car( tmpList );
          }
        }
      "goes up in flames. Within moments it has burnt down to nothing and the flame subsides.\n";
      if ( length( self.passList ) <> 0 )
      "\^<<listcont( self.passList )>> <<length( self.passList ) = 1 ? "has" : "have">> survived the flames.\n";
      dobj.burned.moveInto( dobj.location );
      dobj.moveInto( nil );
      }
      else if ( dobj.type = earth )
      {
      "You attempt to burn <<dobj.thedesc>> with <<self.thedesc>> but it refuses to catch.\n";
      }
      else
      {
        "\^<<dobj.thedesc>> cannot be burned.\n";
      }
    }
    else
    {
    "\^<<self.thedesc>> can no longer be used to burn things.\n";
    }
  }
;



class fragile:  thing
  type = fragile
  doTouch( actor ) =
  {
    "\^<<self.thedesc>> feels rather fragile.\n";
  }
  verDoBreak(actor) = {}
  doBreak(actor) =
  {
    "You throw <<self.thedesc>> against the ground, shattering it into hundreds of tiny pieces.\n";
    self.broken.moveInto( self.location );
    if ( self.contents <> nil )
    {
      self.tmpList := self.contents;
      self.tmpObj := car( tmpList );
      while ( tmpObj <> nil )
      {
        tmpObj.moveInto( self.location );
        tmpList := cdr( tmpList );
        self.tmpObj := car( tmpList );
      }
    }
    self.moveInto( nil );
  }
  verIoAttackWith(actor) = {self.verIoBreakWith(actor);}
  verIoBreakWith(actor) =
  {
    if ( not actor.isCarrying( self ) )
    "You aren't carrying <<self.thedesc>>\n";
  }
  ioAttackWith(actor, dobj) = {self.ioBreakWith(actor, dobj);}
  ioBreakWith(actor, dobj) =
  {
    if ( dobj.type = fragile )
    {
      "As you smash <<self.thedesc>> and <<dobj.thedesc>> together both shatter into hundreds of tiny pieces.\n";
      self.broken.moveInto( self.location );
      if ( self.contents <> nil )
      {
        self.tmpList := self.contents;
        self.tmpObj := car( tmpList );
        while ( tmpObj <> nil )
        {
          tmpObj.moveInto( self.location );
          tmpList := cdr( tmpList );
          self.tmpObj := car( tmpList );
        }
      }
      dobj.broken.moveInto( dobj.location );
      if ( dobj.contents <> nil )
      {
        self.tmpList := dobj.contents;
        self.tmpObj := car( tmpList );
        while ( tmpObj <> nil )
        {
          tmpObj.moveInto( dobj.location );
          tmpList := cdr( tmpList );
          tmpObj := car( tmpList );
        }
      }
      self.moveInto( nil );
      dobj.moveInto( nil );
    }
    if ( dobj.type = hard or dobj.type = wood or dobj.type = earth )
    {
      "The sudden force causes <<self.thedesc>> to shatter into hundreds of tiny pieces.\n";
      self.broken.moveInto( self.location );
      if ( self.contents <> nil )
      {
        self.tmpList := self.contents;
        self.tmpObj := car( tmpList );
        while ( tmpObj <> nil )
        {
          tmpObj.moveInto( self.location );
          tmpList := cdr( tmpList );
          tmpObj := car( tmpList );
        }
      }
      self.moveInto( nil );
    }
    if ( dobj.type = liquid )
    {
      "\^<<dobj.thedesc>> is a liquid. It is a generally accepted fact that liquids cannot be broken.\n";
    }
    if ( dobj.type = nil )
    {
      "\^<<dobj.thedesc>> cannot be broken.\n";
    }
  }
;




class liquidcont:  container
  verIoPutIn( actor ) = {}
  ioPutIn( actor, dobj ) =	
  {
    if ( not actor.isCarrying( self ) )  //IMPLICIT TAKE FOR FILL COMMAND
    {
      "(First taking <<self.thedesc>>)\n";
      self.doTake( actor );
    }

    if ( !isclass(dobj, liquid) )
    "\^<<self.thedesc>> is only suitable for holding liquids. ";
    else if ( itemcnt(self.contents) != 0 )
    "\^<<self.thedesc>> already contains <<listcont(self)>>. ";
    else
    pass ioPutIn;
  }
  verDoFillWith( actor, iobj ) = {}
  verDoFill(actor) = {}
  doFill(actor) =
  {
    askio(withPrep);
  }
  holds = 
  {
    if ( itemcnt(self.contents) != 0 )
    "It currently contains <<listcont(self)>>. ";
    else
    "It is currently empty. ";
  }
  verDoEmpty( actor ) =
  {
    if( itemcnt(self.contents) = 0 )
    "\^<<self.thedesc>> is already empty.\n";
  }
  doEmpty( actor ) = 
  {
    tmpObj := car( self.contents );
    tmpObj.doDrop( actor );
  }
  verDoPour( actor ) = 
  {
    if( itemcnt(self.contents) = 0 )
    "\^<<self.thedesc>> is already empty.\n";
  }
  doPour( actor ) = ( self.doEmpty( actor ) )
  verDoPourOn( actor, iobj ) = 
  {
    if( itemcnt(self.contents) = 0 )
    "\^<<self.thedesc>> is already empty.\n";
  }
;



class liquid:  thing
  type = liquid
  verIoBreakWith(actor) =
  {
    if ( not actor.isCarrying( self ) )
    "You aren't carrying <<self.thedesc>>. ";
  }
  ioBreakWith(actor, dobj) =
  {
    "\^<<self.thedesc>> is a liquid. Liquids are notoriously ineffective when used to break things. ";
  }
  doTouch( actor ) =
  {
    "\^<<self.thedesc>> feels like any other liquid might. ";
  }
  verDoTake( actor ) = 
  {
    if ( Me.isCarrying( self ) )
    "You already have <<self.thedesc>>. ";
  }
  doTake( actor ) =
  {
    if ( isclass(self.location, liquidcont) ) //IS IT IN A CONTAINER?
    {
      "You take <<self.location.thedesc>> of <<self.sdesc>>. "; //TAKE THE CONTAINER OF LIQUID
      self.location.moveInto(actor);
    }
    else
    "You&rsquo;ll have to put <<self.thedesc>> in something. "; //NEEDS A CONTAINER FIRST
  }
  doPutOn(actor, io) =
  {
    io.ioPourOn(actor, self);
  }
  verDoPour( actor ) = {}
  doPour( actor ) = ( self.doDrop( actor ) )
  verDoPourOn( actor, iobj ) = {}
  doPourOn(actor, io) =
  {
    io.ioPourOn(actor, self);
  }
  verDoPutOn( actor, iobj ) = {}
  verIoFillWith( actor ) = {}
  ioFillWith( actor, dobj ) =
  {
    dobj.ioPutIn( actor, self ); //FILL WITH IS JUST PUT IN WITH THE NOUNS REVERSED
  }
  verDoDrop( actor ) = 
  {
    if ( not Me.isCarrying( self ) )
    "You\'re not carrying <<self.thedesc>>.\n";
  }
  doDrop( actor ) =
  {
    "You pour <<self.thedesc>> out onto the ground.\n";
    if( self.isdynamic )
    delete self; //DELETE DYNAMIC OBJECTS
    else
    self.moveInto( nil ); //STATIC OBJECTS JUST GET MOVED INTO NIL
  }
;



class hard:  thing
  type = hard
  doTouch( actor ) =
  {
    "You feel nothing notable. \^<<self.thedesc>> is solid.\n";
  }
  verIoAttackWith(actor) = {self.verIoBreakWith(actor);}
  verIoBreakWith(actor) =
  {
    if ( not actor.isCarrying( self ) )
    "You aren't carrying <<self.thedesc>>\n";
  }
  ioAttackWith(actor, dobj) = {self.ioBreakWith(actor, dobj);}
  ioBreakWith(actor, dobj) =
  {
    if( dobj.specialbreak = true ) //ALLOW OVERRIDE OF BREAK FOR SPECIFIC ITEMS
    dobj.broke( self );
    else
    {
      if ( dobj.type = fragile or dobj.type = wood )
      {
        "You swing <<self.thedesc>> violently and smash <<dobj.thedesc>> to bits.\n";
        dobj.broken.moveInto( dobj.location );
        if ( dobj.contents <> nil )
        {
          self.tmpList := dobj.contents;
          self.tmpObj := car( tmpList );
          while ( tmpObj <> nil )
          {
            tmpObj.moveInto( dobj.location );
            tmpList := cdr( tmpList );
            tmpObj := car( tmpList );
          }
        }
        dobj.moveInto( nil );
      }
      if ( dobj.type = hard )
      {
        if ( dobj.hashardshocked )
        {
          "It hurt like all heck the first time you tried that, what makes you think things will go better if 
          you try again?\n";
        }
        else
        {
          "The force of the blow sends a violent shockwave up <<self.thedesc>> causing your hands to go numb 
          with pain and thoroughly convincing you that you do not want to try that again.\n";
          dobj.hashardshocked := true;
        }
      }
      if ( dobj.type = earth )
      {
        "There is a hollow <Q>thud</Q> as <<self.thedesc>> hits <<dobj.thedesc>> but nothing obvious happens.\n";
      }
      if ( dobj.type = liquid )
      {
        "\^<<dobj.thedesc>> is a liquid. It is a generally accepted fact that liquids cannot be broken.\n";
      }
      if ( dobj.type = nil )
      {
        "\^<<dobj.thedesc>> cannot be broken.\n";
      }
    }
  }
;



class wood:  thing
  type = wood
  doTouch( actor ) =
  {
    "You can feel the grains in the wood of <<self.thedesc>>.\n";
  }
  verIoAttackWith(actor) = {self.verIoBreakWith(actor);}
  verIoBreakWith(actor) =
  {
    if ( not actor.isCarrying( self ) )
    "You aren't carrying <<self.thedesc>>\n";
  }
  ioAttackWith(actor, dobj) = {self.ioBreakWith(actor, dobj);}
  ioBreakWith(actor, dobj) =
  {
    if ( dobj.type = fragile )
    {
      "You swing <<self.thedesc>> violently and smash <<dobj.thedesc>> to bits.\n";
      dobj.broken.moveInto( dobj.location );
      if ( dobj.contents <> nil )
      {
        self.tmpList := dobj.contents;
        self.tmpObj := car( tmpList );
        while ( tmpObj <> nil )
        {
          tmpObj.moveInto( dobj.location );
          tmpList := cdr( tmpList );
          tmpObj := car( tmpList );
        }
      }
      dobj.moveInto( nil );
    }
    if ( dobj.type = wood or dobj.type = hard )
    {
      if ( dobj.haswoodshocked )
      {
        "It hurt like all heck the first time you tried that, what makes you think things will go better if 
        you try again?\n";
      }
      else
      {
        "The force of the blow sends a violent shockwave up <<self.thedesc>> causing your hands to go numb 
        with pain and thoroughly convincing you that you do not want to try that again.\n";
        dobj.haswoodshocked := true;
      }
    }
    if ( dobj.type = earth )
    {
      "There is a hollow <Q>thud</Q> as <<self.thedesc>> hits <<dobj.thedesc>> but nothing obvious happens.\n";
    }
    if ( dobj.type = liquid )
    {
      "\^<<dobj.thedesc>> is a liquid. It is a generally accepted fact that liquids cannot be broken.\n";
    }
    if ( dobj.type = nil )
    {
      "\^<<dobj.thedesc>> cannot be broken.\n";
    }
  }
;



class earth:  thing
  type = earth
  verIoAttackWith(actor) = {self.verIoBreakWith(actor);}
  verIoBreakWith(actor) =
  {
    if ( not actor.isCarrying( self ) )
    "You aren't carrying <<self.thedesc>>\n";
  }
  ioAttackWith(actor, dobj) = {self.ioBreakWith(actor, dobj);}
  ioBreakWith(actor, dobj) =
  {
    if ( dobj.type = fragile )
    {
      "You swing <<self.thedesc>> violently and smash <<dobj.thedesc>> to bits.\n";
      dobj.broken.moveInto( dobj.location );
      if ( dobj.contents <> nil )
      {
        self.tmpList := dobj.contents;
        self.tmpObj := car( tmpList );
        while ( tmpObj <> nil )
        {
          tmpObj.moveInto( dobj.location );
          tmpList := cdr( tmpList );
          tmpObj := car( tmpList );
        }
      }
      dobj.moveInto( nil );
    }
    if ( dobj.type = wood or dobj.type = hard or dobj.type = earth )
    {
      "There is a hollow <Q>thud</Q> as <<self.thedesc>> hits <<dobj.thedesc>> but nothing obvious happens.\n";
    }
    if ( dobj.type = liquid )
    {
      "\^<<dobj.thedesc>> is a liquid. It is a generally accepted fact that liquids cannot be broken.\n";
    }
    if ( dobj.type = nil )
    {
      "\^<<dobj.thedesc>> cannot be broken.\n";
    }
  }
;





//