better way to script "react to some tiles"?

[Tanja]

a few days ago i have managed it to script a behaviour completely on my own (man i am so proud ).
there are some tiles belonging to "air streams". when the player touches them, they alter his velocity, e.g. an air stream blowing from the left has the alters the x with an delta of 0.35.
currently i have 16 tiles for that. directions are to the left, right, top, down, and then diagonally directions (upleft, downright).
the easiest and fastest way for me was to create 16 rules, one for each tile.

now i wonder if one could make the whole thing much more smarter.
because the air streams shall not only effect the player, but also some sprites and the bag when it is been dropped.
at the moment, i have copied all 16 rules into the bag script. because the bag is not so lightweighted as the air ship, i divided all deltas through 2. (0.35/2)
other sprites will have other needs.

maybe is there a better and smaller formula instead of 16 single rules? maybe i can store the 16 rules at a central place, and all sprites refer to it and bring in their own needed variables such this "divided through 2".

[bluemonkmn]

Yes, actually the intention of the rule system is to be very high-level, and not to have so many details in it.  The intention is to have all the more complicated code defined in source code that becomes rule functions.  So if you write a rule function called "ReactToAirTiles" you could do that, and then every sprite that needs to react to air tiles could use that rule function, and pass a parameter to say how much they will react.  For an example, look at the SGDK2 sample project.  There is a file in SourceCode called "TileSpecialization.cs".  Notice in there a function called "ReactToSprings".  Having all that code in the Source Code makes the rule much cleaner, so the player sprite can just call "ReactToSprings" instead of having all sorts of complicated rules mixed in the sprite definition.  Note, the function must be "public static" and must have a "Description" attribute (as shown on ReactToSprings) in order to be accessible by the rule functions.  Also note that the "namespace CustomObjects" at the top of the file causes the rule function to appear as "CustomObjects.TileSpecialization.ReactToSprings" in the rule function list.

If you want help writing the code, you could compile your project, and locate the code that was generated in the Sprites folder.  You could copy the generated code into a function in a Source Code file in your project and then just call that function instead of always copying the rules.

Hope this helps.

[Tanja]

okay, i get the point. and it sounds good. but - right at the moment it is too complicated for me to write the source code by myself. it would take more time than i need to copy and adjust the 16 rules. (i don't have the time, otherwise i would give it a try!)

but if you or someone else is interested in creating an feature for rivers, air streams, treadmills and so on, that would be a good thing.

an example:
an air stream that pushes you up, has a direction of 0 degrees. when pushing to diagonally up and right, 45 degrees and to the right 90 degrees.
if player touches tile in category "wind to the right", alterXvelocity: delta 0.35
wind that forces 45 degrees has a delta of 0.25
30 degrees: upwards 0.175 and sidewards 0.30
60 degrees: up 0.3, to the side 0.175

yeah, that's all.
in order to get that work, i had to create 16 tile categories. but maybe this has to be and cannot be reduced, i guess.

[bluemonkmn]

So you have all the air tiles, but now you need river and treadmill tiles too, and that's what you don't have time for? Or is writing the source code your problem?  The source code is already written if you have one set of rules that works.  When you compile the project, those rules are compiled into source code that you could copy from the generated Sprites (in the project directory where your SGDK2 file is).

[Tanja]

When you compile the project, those rules are compiled into source code that you could copy from the generated Sprites (in the project directory where your SGDK2 file is).

oh! sorry, that point i missed.
no no no, rivers and treadmills are quite the same in their functionality as an air stream, these were just examples. and sorry, with treadmills i meant conveyours and escalators all the time.

[Tanja]

i wanted to give that a try.
can it be that you changed the document "TileSpecializations.cs" into "SpriteCollection.cs"? The former i couldn't find, the latter had the "reactToSprings" function in it.
i also didn't find a a line with "public state" or "Definition". For Definition, i suppose these lines with the /// are meant. are these lines displayed as help when i would created a rule und choose this method?

i made a new source code file, and named it ReactToAirStreams.
Here it is (shortened):

namespace CustomObjects
{
   public class ReactToAirStreams
   {

   /// <summary>
   /// Makes a sprite reacting to air streams.
   /// </summary>
   /// <remarks>Makes a sprite reacting to air streams.</remarks>

         // if touching category -wind nach links-
         if (this.TouchTiles(TileCategoryName.wind_nach_links))
         {
          // go left
          this.AlterXVelocity(-0.35);
         }
    // if touching category -wind nach oben rechts 60
         if (this.TouchTiles(TileCategoryName.wind_nach_oben_rechts_60))
         {
            // go right 60
            this.AlterXVelocity(0.175);
            // go up 60
            this.AlterYVelocity(-0.3);
         }
           // if touching category -wind nach unten links 45-
         if (this.TouchTiles(TileCategoryName.wind_nach_unten_links_45))
         {
            // go left 45-
            this.AlterXVelocity(-0.25);
            // go down 45-
            this.AlterYVelocity(0.25);
         }

   }
}

i would like to add a parameter, like you said. but i don't know how to make it right. maybe it has to be two or three parameters.
the first parameter the user chooses should be the value which is here -0.35.
there it comes, my first problem. there are 16 air tiles for exactly 16 directions, and every tile has different angles to force the player in the specified direction.
for the user, it would be the easiest, when the function itself would calculate all angles from a given ground value.

but, if that all is too complicated, i can imagine that the values in the code shown above, are hard coded. and the only thing the user can change, is a parameter whichs divides this value through "x" (eg 2 because its a smaller object and the air streams can hold it much longer in the air).
maybe there is parameter for the "x" value, and another for the needed action (multiplying, dividing)

how would i code this?

[bluemonkmn]

TileSpecialization.cs only exists in the sample project (it's custom code, not part of the built-in code, so the icon is a "?" in the Source Code tree).  If you can find that, I think it will answer many of your questions.

[Tanja]

thanks, found it.

how can i say that these tiles are for all sprites and the player? there are some lines which indicate it is only for the Player.

using System.ComponentModel;

namespace CustomObjects
{

public class StreamTiles
   {
      private static System.Collections.Hashtable specialStreamTiles = new System.Collections.Hashtable();

      private int col;
      private int row;
      private int state;
      private int originalTile;
      private LayerBase layer;

      private StreamTiles(int col, int row, int originalTile, LayerBase layer)
      {
         this.col = col;
         this.row = row;
         this.originalTile = originalTile;
         this.layer = layer;
      }

      private static StreamTiles SpecialStreamTile(SpriteBase Player)
      {
         return specialStreamTiles[Player] as StreamTiles;
      }

      [Description("Causes a sprite to react to stream tiles such as winds or water streams")]
      public static void ReactToStreams(SpriteBase Player)
       {
         // if touching category -wind nach links-
         if (this.TouchTiles(TileCategoryName.wind_nach_links))
         {
          // go left
          this.AlterXVelocity(-0.35);
         }
      }
}
}

[bluemonkmn]

1) Just for documentation purposes you should name the parameter of ReactToStreams as "SpriteBase targetSprite" instead of "SpriteBase Player"
2) You'll need to replace every "this" and every "Player" with "targetSprite"
3) I don't see any reason for any of this code -- you may be able to simply delete it:

Code: [Select]

      private static System.Collections.Hashtable specialStreamTiles = new System.Collections.Hashtable();

      private int col;
      private int row;
      private int state;
      private int originalTile;
      private LayerBase layer;

      private StreamTiles(int col, int row, int originalTile, LayerBase layer)
      {
         this.col = col;
         this.row = row;
         this.originalTile = originalTile;
         this.layer = layer;
      }

      private static StreamTiles SpecialStreamTile(SpriteBase Player)
      {
         return specialStreamTiles[Player] as StreamTiles;
      }
4) When you call ReactToStreams from any sprite definition, just pass in "this" and it will react for that sprite.

[bluemonkmn]

BTW, I think it's best to only call TouchTiles once for each sprite, then use TileTouchingIndex to determine which tiles were actually touched.  This ensures that each touched tile is only processed once, and it's more efficient than repeatedly calling TouchTiles.  TouchTiles should use a category that includes all the tiles that you're interested in detecting.  For example:

Code: [Select]

public static void ReactToStreams(SpriteBase Player)
       {
         // if touching category wind
         if (targetSprite.TouchTiles(TileCategoryName.wind))
         {
          // if touching left wind tile
          if (TileTouchingIndex(20, false, true) >= 0)
          {
           // go left
           targetSprite.AlterXVelocity(-0.35);
          }
          // if touching right wind tile
          if (TileTouchingIndex(21, false, true) >= 0)
          {
           // go right
           targetSprite.AlterXVelocity(0.35);
          }
         }
      }
Also, if you want multiple tiles to affect the sprite more severely than a single tile you could do this:

Code: [Select]

public static void ReactToStreams(SpriteBase Player)
       {
         // if touching category wind
         if (targetSprite.TouchTiles(TileCategoryName.wind))
         {
          // for each touched left wind tile
          while (TileTouchingIndex(20, false, true) >= 0)
          {
           // go left
           targetSprite.AlterXVelocity(-0.35);
          }
          // for each touched right wind tile
          while (TileTouchingIndex(21, false, true) >= 0)
          {
           // go right
           targetSprite.AlterXVelocity(0.35);
          }
         }
      }(Note that passing "true" for "MarkAsProcessed" causes the next call to TileTouchingIndex to skip that tile because now it's done being processed.)

[Tanja]

okay, everything works! 
that is really cool. i tried also the "while"-version, it speeds up so fast oh gosh... with that you could make very hard race games....

(Note that passing "true" for "MarkAsProcessed" causes the next call to TileTouchingIndex to skip that tile because now it's done being processed.)

i think i don't quite understand this properly. everything is working fine now.

so. now to the next questions. how do i insert parameters?
instead of hard coding the speed, it should be accessable at the gui. also needed: a parameter whichs divides the speed through "x" (eg 2 because its a smaller object and the air streams can hold it much longer in the air).
maybe there is parameter for the "x" value, and another for the needed action (multiplying, dividing)

[bluemonkmn]

To add a parameter, just change:
public static void ReactToStreams(SpriteBase Target)
to
public static void ReactToStreams(SpriteBase Target, int Speed)

If you use "int" as the parameter type, then you have to use a whole number, but this allows you to use sprite parameters (which must be integers) to provide the value (then you could specify the specific value for each individual instance in the map editor if you want).  Of course, you have to convert the integer to a more useful number.  You could do that like this:
targetSprite.AlterXVelocity((float)Speed/100);

Then a speed value of 35 would go the same speed as your example.
I don't know if I answered all your question... I don't quite understand how you want the other parameter to work, but maybe this will help you.  Note that you can only have a total of 3 parameters, and one is already taken with Target (and now another with Speed) so you could only have one more exposed to the UI.

[Tanja]

ok, finally i found the formula.
x=cos(alpha)*speed
y=sin(alpha)*speed

here is one rule for one wind stream tile:
// if touching wind down- and leftwards in an 30

[bluemonkmn]

ok, finally i found the formula.
x=cos(alpha)*speed
y=sin(alpha)*speed

That's similar to the code in the PolarAccelerate function in SpriteBase.cs.  Maybe some updated version of that is actually what you want?

am i understandable? too sad i don't know how to write this mathematical stuff so it works for vb.

Why VB?  SGDK2 can't use VB code.

[Tanja]

good, looking at the code for polarAccelartion provided me the solution. 
i was looking for how to write this: targetSprite.AlterXVelocity((float)-(Math.Cos(63.4)*Speed)/100);

when you imagine a clock, at which point lies 0