Verb:draw

Called on This asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this: "Found custom string at thing_one.try_draw_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this: {
       "Player Two": "Found custom string at thing_one.try_draw_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this: "Found custom string at thing_one.do_draw_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this: {
       "Player Two": "Found custom string at thing_one.do_draw_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_with_this: "Found custom string at thing_one.try_draw_with_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_with_this: {
       "Player Two": "Found custom string at thing_one.try_draw_with_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_with_this: "Found custom string at thing_one.do_draw_with_this",
   });
   

2. In this example, we use the name of a player character asset as a nested object key. This variation results in a singular response only when that particular player character uses the verb on this asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_with_this: {
       "Player Two": "Found custom string at thing_one.do_draw_with_this['Player Two']",
     },
   });
   

Called on This asset in a phrase such as "draw this with that", where This is the direct object and That is the indirect object.

try_draw_this_preposition_that mirrors try_draw_that_preposition_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this_with_that: "Found custom string at thing_one.try_draw_this_with_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this_with_that: {
       "Thing Two": "Found custom string at thing_one.try_draw_this_with_that['Thing Two']",
     },
   });
   

Called on This asset in a phrase such as "draw this with that", where This is the direct object and That is the indirect object.

do_draw_this_preposition_that mirrors do_draw_that_preposition_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this_with_that: "Found custom string at thing_one.do_draw_this_with_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this_with_that: {
       "Thing Two": "Found custom string at thing_one.do_draw_this_with_that['Thing Two']",
     },
   });
   

Called on That asset in a phrase such as "draw this with that", where That is the indirect object and This is the direct object.

try_draw_that_preposition_this mirrors try_draw_this_preposition_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_draw_that_with_this: "Found custom string at thing_two.try_draw_that_with_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for This particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_draw_that_with_this: {
       "Thing One": "Found custom string at thing_two.try_draw_that_with_this['Thing One']",
     },
   });
   

Called on That asset in a phrase such as "draw this with that", where That is the indirect object and This is the direct object.

do_draw_that_preposition_this mirrors do_draw_this_preposition_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_draw_that_with_this: "Found custom string at thing_two.do_draw_that_with_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for This particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_draw_that_with_this: {
       "Thing One": "Found custom string at thing_two.do_draw_that_with_this['Thing One']",
     },
   });
   

Called on This asset in a phrase such as "draw from this to that", where This is the direct object and That is the indirect object.

try_draw_preposition_this_preposition_that mirrors try_draw_preposition_that_preposition_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_from_this_to_that: "Found custom string at thing_one.try_draw_from_this_to_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_from_this_to_that: {
       "Thing Two": "Found custom string at thing_one.try_draw_from_this_to_that['Thing Two']",
     },
   });
   

Called on This asset in a phrase such as "draw from this to that", where This is the direct object and That is the indirect object.

do_draw_preposition_this_preposition_that mirrors dodraw_preposition_that_preposition_this. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_from_this_to_that: "Found custom string at thing_one.do_draw_from_this_to_that",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_from_this_to_that: {
       "Thing Two": "Found custom string at thing_one.do_draw_from_this_to_that['Thing Two']",
     },
   });
   

Called on That asset in a phrase such as "draw from this to that", where That is the indirect object and This is the direct object.

try_draw_preposition_that_preposition_this mirrors try_draw_preposition_this_preposition_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_draw_from_that_to_this: "Found custom string at thing_two.try_draw_from_that_to_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for This particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_draw_from_that_to_this: {
       "Thing One": "Found custom string at thing_two.try_draw_from_that_to_this['Thing One']",
     },
   });
   

Called on That asset in a phrase such as "draw from this to that", where That is the indirect object and This is the direct object.

do_draw_preposition_that_preposition_this mirrors do_draw_preposition_this_preposition_that. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_draw_from_that_to_this: "Found custom string at thing_two.do_draw_from_that_to_this",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response for This particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_draw_from_that_to_this: {
       "Thing One": "Found custom string at thing_two.do_draw_from_that_to_this['Thing One']",
     },
   });
   

Called on This asset in a phrase such as "draw this from that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

try_draw_this_preposition_that_preposition_other mirrors try_draw_preposition_that_this_preposition_other. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this_to_that_with_other: "Found custom string at thing_one.try_draw_this_to_that_with_other",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this_to_that_with_other: {
       "Thing Two": "Found custom string at thing_one.try_draw_this_to_that_with_other['Thing Two']",
     },
   });
   

3. This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     try_draw_this_to_that_with_other: {
       "Thing Two": {
         "Thing Three": "Found custom string at thing_one.try_draw_this_to_that_with_other['Thing Two']['Thing Three']"
       },
     },
   });
   

Called on This asset in a phrase such as "draw this from that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

do_draw_this_preposition_that_preposition_other mirrors do_draw_preposition_that_this_preposition_other. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this_to_that_with_other: "Found custom string at thing_one.do_draw_this_to_that_with_other",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this_to_that_with_other: {
       "Thing Two": "Found custom string at thing_one.do_draw_this_to_that_with_other['Thing Two']",
     },
   });
   

3. This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     do_draw_this_to_that_with_other: {
       "Thing Two": {
         "Thing Three": "Found custom string at thing_one.do_draw_this_to_that_with_other['Thing Two']['Thing Three']"
       },
     },
   });
   

Called on That asset in a phrase such as "draw this to that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

try_draw_that_preposition_this_preposition_other mirrors try_draw_this_preposition_that_preposition_other. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_drawto_that_this_with_other: "Found custom string at thing_two.try_drawto_that_this_with_other",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_drawto_that_this_with_other: {
       "Thing One": "Found custom string at thing_two.try_drawto_that_this_with_other['Thing One']",
     },
   });
   

3. This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     try_drawto_that_this_with_other: {
       "Thing One": {
         "Thing Three": "Found custom string at thing_two.try_drawto_that_this_with_other['Thing One']['Thing Three']"
       },
     },
   });
   

Called on That asset in a phrase such as "draw this to that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

do_draw_that_preposition_this_preposition_other mirrors do_draw_this_preposition_that_preposition_other. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we set the value of the top level object key to a string. This variation results in the same response regardless of what This is moved to.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_drawto_that_this_with_other: "Found custom string at thing_two.do_drawto_that_this_with_other",
   });
   

2. In this example, we use the name of an asset as a nested object key. This variation results in a singular response when This is moved to That particular asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_drawto_that_this_with_other: {
       "Thing One": "Found custom string at thing_two.do_drawto_that_this_with_other['Thing One']",
     },
   });
   

3. This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     do_drawto_that_this_with_other: {
       "Thing One": {
         "Thing Three": "Found custom string at thing_two.do_drawto_that_this_with_other['Thing One']['Thing Three']"
       },
     },
   });
   

Called on This asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThis: function () {
       let msg = "Found custom method at thing_one.tryDrawThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.tryDrawThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.tryDrawThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw this". Since no indirect object is given, we treat the player character as an indirect object.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThis: function () {
       let msg = "Found custom method at thing_one.doDrawThis()";
       MyGame.print(msg);
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.doDrawThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.doDrawThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw on this". Since no indirect object is given, we treat the player character as an indirect object. This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawWithThis: function () {
       let msg = "Found custom method at thing_one.tryDrawWithThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawWithThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.tryDrawWithThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.tryDrawWithThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw on this". Since no indirect object is given, we treat the player character as an indirect object. This example uses "with" as the preposition, but any preposition can set a unique response.

Note that sentence structures are commonly mutated during the doTry verb phase, so try and do may act on different sentence structures.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of which player character uses the verb.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawWithThis: function () {
       let msg = "Found custom method at thing_one.doDrawWithThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawWithThis: {
       "Player Two": function () {
         let msg = "Found custom method at thing_one.doDrawWithThis['Player Two']()";
         MyGame.print(msg);
       },
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this particular verb action, asset1 is the player character, because we've treated it as the indirect object in absence of a player specified object.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Player Two":
           let msg = "Found custom method at thing_one.doDrawWithThis('Player Two')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw this with that", where This is the direct object and That is the indirect object.

tryDrawThisPrepositionThat mirrors tryDrawThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisWithThat: function () {
       let msg = "Found custom method at thing_one.tryDrawThisWithThat()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisWithThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.tryDrawThisWithThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisWithThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.tryDrawThisWithThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw this with that", where This is the direct object and That is the indirect object.

doDrawThisPrepositionThat mirrors doDrawThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisWithThat: function () {
       let msg = "Found custom method at thing_one.doDrawThisWithThat()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisWithThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.doDrawThisWithThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisWithThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.doDrawThisWithThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "draw this with that", where That is the indirect object and This is the direct object.

tryDrawThatPrepositionThis mirrors tryDrawThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawThatWithThis: function () {
       let msg = "Found custom method at thing_two.tryDrawThatWithThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawThatWithThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.tryDrawThatWithThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawThatWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.tryDrawThatWithThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "draw this with that", where That is the indirect object and This is the direct object.

doDrawThatPrepositionThis mirrors doDrawThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "with" as the preposition, but any preposition can set a unique response.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawThatWithThis: function () {
       let msg = "Found custom method at thing_two.doDrawThatWithThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawThatWithThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.doDrawThatWithThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawThatWithThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.doDrawThatWithThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw from this to that", where This is the direct object and That is the indirect object.

tryDrawPrepositionThisPrepositionThat mirrors tryDrawPrepositionThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawFromThisToThat: function () {
       let msg = "Found custom method at thing_one.tryDrawFromThisToThat()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawPrepositionThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawFromThisToThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.tryDrawFromThisToThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawFromThisToThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.tryDrawFromThisToThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw from this to that", where This is the direct object and That is the indirect object.

doDrawPrepositionThisPrepositionThat mirrors doDrawPrepositionThatPrepositionThis. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "from" and "to" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawFromThisToThat: function () {
       let msg = "Found custom method at thing_one.doDrawFromThisToThat()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawPrepositionThisPrepositionThat from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawFromThisToThat: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.doDrawFromThisToThat['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawFromThisToThat: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.doDrawFromThisToThat('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "draw from this to that", where This is the direct object and That is the indirect object.

tryDrawPrepositionThatPrepositionThis mirrors tryDrawPrepositionThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "from" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatFromThis: function () {
       let msg = "Found custom method at thing_two.tryDrawToThatFromThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawPrepositionThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatFromThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.tryDrawToThatFromThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatFromThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.tryDrawToThatFromThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "draw from this to that", where This is the direct object and That is the indirect object.

doDrawPrepositionThatPrepositionThis mirrors doDrawPrepositionThisPrepositionThat. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "from" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatFromThis: function () {
       let msg = "Found custom method at thing_two.doDrawToThatFromThis()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawPrepositionThatPrepositionThis from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatFromThis: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.doDrawToThatFromThis['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatFromThis: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.doDrawToThatFromThis('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw this to that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

tryDrawThisPrepositionThatPrepositionOther mirrors tryDrawPrepositionThatThisPrepositionOther. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisToThatWithOther: function () {
       let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawThisPrepositionThatPrepositionOther from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisToThatWithOther: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

   This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisToThatWithOther: { 
       "Thing Two": {
         "Thing Three": function (params) {
           let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther['Second Thing']['Third Thing']()";
           MyGame.print(msg);
         }
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisToThatWithOther: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

   This logic can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     tryDrawThisToThatWithOther: function ({asset1, asset2}) {
       switch (asset1.name) {
         case "Thing Two":
           if(asset2.name === "Thing Three"){
             let msg = "Found custom method at thing_one.tryDrawThisToThatWithOther('Second Thing', 'Third Thing')";
             MyGame.print(msg);
           }
           else return;
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on This asset in a phrase such as "draw this to that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

doDrawThisPrepositionThatPrepositionOther mirrors doDrawPrepositionThatThisPrepositionOther. One is called on a direct object; the other on an indirect object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what That asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisToThatWithOther: function () {
       let msg = "Found custom method at thing_one.doDrawThisToThatWithOther()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawThisPrepositionThatPrepositionOther from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisToThatWithOther: { 
       "Thing Two": function (params) {
         let msg = "Found custom method at thing_one.doDrawThisToThatWithOther['Second Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

   This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisToThatWithOther: { 
       "Thing Two": {
         "Thing Three": function (params) {
           let msg = "Found custom method at thing_one.doDrawThisToThatWithOther['Second Thing']['Third Thing']()";
           MyGame.print(msg);
         }
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisToThatWithOther: function ({asset1}) {
       switch (asset1.name) {
         case "Thing Two":
           let msg = "Found custom method at thing_one.doDrawThisToThatWithOther('Second Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

   This logic can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing One",
     doDrawThisToThatWithOther: function ({asset1, asset2}) {
       switch (asset1.name) {
         case "Thing Two":
           if(asset2.name === "Thing Three"){
             let msg = "Found custom method at thing_one.doDrawThisToThatWithOther('Second Thing', 'Third Thing')";
             MyGame.print(msg);
           }
           else return;
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "draw this to that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

tryDrawPrepositionThatThisPrepositionOther mirrors tryDrawThisPrepositionThatPrepositionOther. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatThisWithOther: function () {
       let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of tryDrawPrepositionThatThisPrepositionOther from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatThisWithOther: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

   This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatThisWithOther: { 
       "Thing One": {
         "Thing Three": function (params) {
           let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther['First Thing']['Third Thing']()";
           MyGame.print(msg);
         }
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatThisWithOther: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

   This logic can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     tryDrawToThatThisWithOther: function ({asset1, asset2}) {
       switch (asset1.name) {
         case "Thing One":
           if(asset2.name === "Thing Three"){
             let msg = "Found custom method at thing_two.tryDrawToThatThisWithOther('First Thing', 'Third Thing')";
             MyGame.print(msg);
           }
           else return;
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

Called on That asset in a phrase such as "draw this to that with other", where This is the direct object, That is the indirect object, and Other is assumed to be a second indirect object (likely a tool).

doDrawPrepositionThatThisPrepositionOther mirrors doDrawThisPrepositionThatPrepositionOther. One is called on an indirect object; the other on a direct object. These are equivalent, and you may place code on whichever asset makes sense to you.

This example uses "to" and "with" as the prepositions, but any prepositions can set unique responses.

1. In this example, we ignore the passed parameter. This variation results in the same response regardless of what This asset is.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatThisWithOther: function () {
       let msg = "Found custom method at thing_two.doDrawToThatThisWithOther()";
       MyGame.print(msg);    
     },
   });
   

2. To limit the method to act only on a certain asset, change the value of doDrawPrepositionThatThisPrepositionOther from a method to an object, use the asset's name as a key on the object, and set that key's value to a method instead.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatThisWithOther: { 
       "Thing One": function (params) {
         let msg = "Found custom method at thing_two.doDrawToThatThisWithOther['First Thing']()";
         MyGame.print(msg);
       }
     },
   });
   

   This nested key / value approach can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatThisWithOther: { 
       "Thing One": {
         "Thing Three": function (params) {
           let msg = "Found custom method at thing_two.doDrawToThatThisWithOther['First Thing']['Third Thing']()";
           MyGame.print(msg);
         }
       }
     },
   });
   

3. Finally, in this example, we apply per-asset logic based on the value of asset1, which is available via our passed parameter. In this verb action, asset1 is the second noun.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatThisWithOther: function ({asset1}) {
       switch (asset1.name) {
         case "Thing One":
           let msg = "Found custom method at thing_two.doDrawToThatThisWithOther('First Thing')";
           MyGame.print(msg);
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });
   

   This logic can be extended to handle the Other asset.

   MyGame.createAsset({
     class: "Thing",
     name: "Thing Two",
     doDrawToThatThisWithOther: function ({asset1, asset2}) {
       switch (asset1.name) {
         case "Thing One":
           if(asset2.name === "Thing Three"){
             let msg = "Found custom method at thing_two.doDrawToThatThisWithOther('First Thing', 'Third Thing')";
             MyGame.print(msg);
           }
           else return;
           break;
         default:
           // do nothing and allow the default result
           break;
       }
       return;
     },
   });