Esenthel Forum - Code Snippets

Position inside Waypoint

Sat, 27 Jul 2019 22:26:30 +0000

If we are using Waypoints to define/limit areas, sometimes we need to check if the position (of a character) is inside of a Waypoint.

For complex polygons there is an algorithm HERE, and here's the code for EE to use it:

Code:

/******************************************************************************/

/******************************************************************************/

//

struct saWaypointChecker

{

public:

    void init(C UID &waypointID);

    Bool posInside(C Vec2 &pos);

    C UID &waypointID(){    return T._waypointID;    }

    C Rect rect(){    return T._waypointRect;    }

private:

    volatile Bool _init = false;

    Game::Waypoint 

       *_waypoint   = nullptr;

    UID _waypointID = UIDZero;

    Memc _constant;

    Memc _multiple;

    Rect _waypointRect;

}

/******************************************************************************/

/******************************************************************************/

//

void saWaypointChecker::init(C UID &waypointID)

{

    C Flt minMax = 32767.0f;

    T._waypoint     = Game::World.findWaypoint(waypointID);

    T._waypointID   = (T._waypoint ? waypointID : UIDZero);

    T._waypointRect = Rect(minMax, minMax, -minMax, -minMax);

    // Perform precalculation

    if(T._waypoint)

    {

        Game::Waypoint &wp = *T._waypoint;

        T._constant.setNum(wp.points.elms());

        T._multiple.setNum(wp.points.elms());

        Int j = wp.points.elms() - 1;

        for(Int i = 0; i < wp.points.elms(); i++) 

        {

            if(wp.points[j].pos.z == wp.points[i].pos.z) 

            {

                T._constant[i] = wp.points[i].pos.x;

                T._multiple[i] = 0; 

            }

            else 

            {

                T._constant[i] = wp.points[i].pos.x - (wp.points[i].pos.z * wp.points[j].pos.x) / (wp.points[j].pos.z - wp.points[i].pos.z) + 

                                                      (wp.points[i].pos.z * wp.points[i].pos.x) / (wp.points[j].pos.z - wp.points[i].pos.z);

                T._multiple[i] = (wp.points[j].pos.x - wp.points[i].pos.x) / (wp.points[j].pos.z - wp.points[i].pos.z); 

            }

            j = i; 

            // Defining bounding Rect

            T._waypointRect.min.x = Min(T._waypointRect.min.x, wp.points[i].pos.x);

            T._waypointRect.min.y = Min(T._waypointRect.min.y, wp.points[i].pos.z);

            T._waypointRect.max.x = Max(T._waypointRect.max.x, wp.points[i].pos.x);

            T._waypointRect.max.y = Max(T._waypointRect.max.y, wp.points[i].pos.z);

        }

    }    

    T._init = (T._waypoint && T._waypointID != UIDZero);

}

Bool saWaypointChecker::posInside(C Vec2 &pos)

{

    if(!T._init)

    {

        return false;

    }

    // First and fastest check

    if(!T._waypointRect.includes(pos))

    {

        return false;

    }

    // If position is inside rect, perform more precise check

    if(T._waypoint)

    {

        Game::Waypoint &wp = *T._waypoint;

        Bool oddNodes = false, current = wp.points.last().pos.z > pos.y, previous; 

        for(Int i = 0; i < wp.points.elms(); i++) 

        {

            previous = current; 

            current = wp.points[i].pos.z > pos.y; 

            if(current != previous)

            {

                oddNodes ^= (pos.y * T._multiple[i] + T._constant[i] < pos.x); 

            }

        }

        return oddNodes;

    }

    return false;

}

/******************************************************************************/

/******************************************************************************/

the usage is the following (initialization to perform precalculations just once):

Code:

saWaypointChecker wpHandler;

... init just once ...

wpHandler.init(UID(0, 0, 0, 0)); // your Waypoint ID here

... and then check XZ position in any loop ...

if(wpHandler.posInside(pos.xz()))

{

    // do something

}

P.S. Greg, maybe you can move these precalculations to waypoint class and add "Waypoint.Cuts" function?

Algorithms (Esenthel Project)

Mon, 26 Oct 2015 08:00:45 +0000

Hello everyone,

I needed to test an algorithm that I had to use at work, so I did what anyone would do: Make a new application in Esenthel and slap some things together there just to see if it works!

Then, of course, I got a little bit carried away and added some more algorithms and put them together in a small, simple application.

So, I'm putting that project up here in case this is of interest to someone. It's very basic, really, but it can always be nice to have some more tutorials!

What it does (all algorithms are for image processing):
- Bilinear interpolation (on colours)
- Convert to Gray
- Blur
- Oil painting filter
- Sin-wave blur. My god, it's so useless, why did I put time in that?

Download

Enjoy!

Code Snippet for more efficient tessellation

Tue, 25 Aug 2015 12:51:11 +0000

I use tessellation on higher graphic settings, but, it completely kills the performance when you have lots of objects (solid + with transparency) in your scene.

By default, tessellation is applied to everything. All LODs and even transparant objects.
So, with the next snippet, we are are calling the shader with different parameters: Only allow tessellation if the material has no transparancy and if it is the first LOD of the mesh.

In Main:

Code:

/******************************************************************************/

// Only allow tessellation on solid objects with first LOD.

ShaderTech* get_shader(RENDER_MODE mode, Material *material[4], UInt mesh_base_flag, Int lod_index, Bool allow_tesselation)

{

   bool tessellate = false;

   // Some things should not be tessellated (like terrain when D.tessellateHeightmap == false), set_shader sets this for us

   if(allow_tesselation)

   {

      // If material is a normal material (no alpha)                      

      if(material[0] != null && material[0].technique == MTECH_DEFAULT) 

      {

         // We are in solid/simple rendering mode and this is the first LOD

         if(IsTessellationRenderMode(mode) && lod_index == 0)

         {

            tessellate = true;

         }

      }

   }

   return GetDefaultShader(mode, material, mesh_base_flag, lod_index, tessellate); 

}

/******************************************************************************/

bool IsTessellationRenderMode(RENDER_MODE mode)

{

   return (mode == RM_SIMPLE ||  mode == RM_SOLID);

}

/******************************************************************************/

In InitPre:

Code:

D.tesselation(true).tesselationDensity(50).tesselationHeightmap(true);

D.setGetShaderFunc(get_shader);

Step counter for mobile platforms

Mon, 24 Aug 2015 13:27:23 +0000

I thought I'd share this code. It's a simple step-counter for mobile devices. I don't suppose Esenthel will be used any time soon to make a 'personal health assistant', but it might be useful for interaction. I'm using it to make decisions based on whether the user is walking or not.

cheers,

yvan

PHP Code:

class stepDetector
{
   void activate()
   {
      int h = 480;
      offset = h * 0.5f;
      scale = - (h * 0.5f * (1.0f / (MAGNETIC_FIELD_EARTH_MAX)));
      
      MagnetometerRefresh();
   }
   
   void deactivate()
   {
      MagnetometerDisable();
   }
   
   void sensitivity(float value) // lower is more sensitive, default is 3
   {
      limit = value;
   }
   
   bool update()
   {
      bool result = false;
      
      // Device rotation also cause acceleration. To counter
      // this, rotation is measured with the magnetometer.      
      Vec magValue = Magnetometer();
      
      // Distance compared to the previous update
      magDist[magDistPtr] = Dist(magValue, lastMagValue);
      lastMagValue = magValue;
      
      // When 5 point average > 0.6 or current value > 1,
      // the device is rotated.
      if(getMagAverage() > 0.6 || magDist[magDistPtr] > 1.0)
      {
         magDistPtr++;
         if(magDistPtr == 5) magDistPtr = 0;
         return result;
      }
      
      magDistPtr++;
      if(magDistPtr == 5) magDistPtr = 0;
      
      // To avoid double triggers, a sleep period of 0.3 seconds
      // is added after a step
      if(sleep > 0)
      {
         sleep -= Time.ad();
         return result;
      }
      
      // don't do anything if the value hasn't changed
      Vec accValue = Accelerometer();
      if(accValue != lastAccValue)
      {
         // this part is based on code found at:
         // https://github.com/bagilevi/android-pedometer/blob/master/src/name/bagi/levente/pedometer/StepDetector.java
         
         lastAccValue = accValue;
         
         float calc = 0;
         calc += offset + accValue.x * scale;
         calc += offset + accValue.y * scale;
         calc += offset + accValue.z * scale;         
         calc /= 3;
         
         // if the movement direction has changed, this is a strong indication
         // of a step occurance
         int direction = (calc > lastCalc ?  1 : (calc < lastCalc ?  -1 : 0)); 
         if(direction == -lastDirection)
         {
            // direction changed
            int extType = (direction > 0 ?  0 :  1); // minimum or maximum?
            lastExtremes[extType] = lastCalc;
            float diff = Abs(lastExtremes[extType] - lastExtremes[1 - extType]);
            
            if(diff > limit)
            {
               bool isAlmostAsLargeAsPrevious = diff > (lastDiff * 2 / 3);
               bool isPreviousLargeEnough = lastDiff > (diff / 3);
               bool isNotContra = (lastMatch != 1 - extType);
               
               if(isAlmostAsLargeAsPrevious && isPreviousLargeEnough && isNotContra)
               {
                  // this counts as a step. Sleep for 0.3 seconds
                  result = true;
                  lastMatch = extType;
                  sleep = 0.3;
                  
               } else
               {
                  lastMatch = -1;
               }
            }
            lastDiff = diff;
         }
         
         lastDirection = direction;
         lastCalc = calc;
      }
      return result;
   }
   
   // Helper function to get an average magnetometer value
   float getMagAverage()
   {
      float result = 0;
      for(int i = 0;  i < 5; i++)
      {
         result += magDist[i];
      }
      
      result /= 10;
      return result;
   }
   

private:

   C float MAGNETIC_FIELD_EARTH_MAX = 60.f;
   
   // for accelerometer calculations
   float limit = 3;
   float lastCalc, lastDiff, scale, offset;
   float lastExtremes[2];
   
   int lastDirection ;
   int lastMatch = -1;
   
   Vec lastAccValue(0);
   
   // for magnetometer calculations
   Vec   lastMagValue(0);
   float magDist     [5];
   int   magDistPtr = 0 ; 
   
   float sleep = 0;
}

stepDetector StepDetector; 

A JointHelper object to assemble Jointed Objects

Wed, 06 May 2015 17:52:22 +0000

At present there is no visual way of placing any type of joint between any two physics-based objects. I have to do it all in code, trying to remember positions, rotations, constraint limits for exact placement of the specific joint type. So I decided to put my newly acquired knowledge of Esenthel Custom Parameters to some use, and I have put together a JointHelper object for use in the World Editor. This should also enable new users to gain a little understanding of Custom Parameters.

Here is the JointHelper object:

Basically, you place it (using the current tools in the World Editor) at the desired position between the two objects you wish to join.
The axis of rotation (for Hinge joints) and axis for lateral movement (for Sliding joints) is the GREEN Y axis, so be sure to orientate the JointHelper accordingly.
By selecting its Param tab you are able to change its parameters to suit your desired situation. These parameters are:

"actor0" : supply the name of the first Item object to be joined
"actor1" : supply the name of the second Item object to be joined (or "null" if only the "actor0" is valid)
"drawme" : tick this if you wish the joint name to be displayed (recommended only for debugging purposes)
"JOINT_TYPE" : supply the type of joint using the dropdown list
"limit1" : supply a lower constraint limit for the joint (further explained in the code comments)
"limit2" : supply an upper constraint limit for the joint
"name" : whatever unique name you wish to give for the JointHelper

The object Items to be joined have only one parameter:

"name" : whatever unique name you wish to give for the Item object

I have supplied an example project (with code), together with a simple set of primitive assets, which demonstrates the use of my JointHelper.
You can also have a bit of fun firing some missile balls at the assembled objects to determine which joints have been used.

Esenthel Project file

Zipped Assets

Auto screenshot make for iOS

Sat, 11 Apr 2015 00:50:21 +0000

I've used this code for auto-generation of screenshots needed for submitting apps to Apple App Store.
It will generate the 3.5, 4.0, 4.7, 5.5 inch and iPad JPG's.

Step 1 modify const Str ScreenShotPath="d:/Screens/";
Step 2 Run your game fullscreen
Step 3 call ScreenShot() anytime in your StateGame draw function
Step 4 Place 'ScreenShotFinish()' in global 'Shut'

Screenshots are created in multi-threaded mode on secondary threads so you can keep running the game, and correct aspect ratio is calculated.

Enjoy!

Code:

/******************************************************************************/

const Str ScreenShotPath="d:/Screens/";

/******************************************************************************/

class ScreenCapture

{

   Image src;

   VecI2 res;

   Str   name;

   ScreenCapture& create(C Image &src, C VecI2 &res, C Str &name)

   {

      src.copy(T.src, -1, -1, -1, -1, IMAGE_SOFT, 1);

      T.res=res;

      T.name=name;

      return T;

   }

   void process()

   {

      src.copy(src, res.x, res.y, -1, -1, -1, -1, FILTER_BEST);

      src.Export(name, 0.95); src.del(); name.del();

   }

   static void Process(ScreenCapture &sc, ptr user, int thread_index) {sc.process();}

}

/******************************************************************************/

Memx ScreenCaptures;

bool                TakingScreenShot, SkipGUI;

Threads             ScreenShotThreads;

/******************************************************************************/

void ScreenShot()

{

   if(!TakingScreenShot)

   {

      TakingScreenShot=true;

      SkipGUI=Kb.ctrl();

      if(!ScreenShotThreads.threads())ScreenShotThreads.create(true, Cpu.threads()-1);

      flt aspect=D.aspectRatio();

      void (*draw)()=StateActive.draw;

      Str path=FFirst(ScreenShotPath); FCreateDirs(path); path.tailSlash(true);

      Image capture;

      D.aspectRatio(1920./1080);

      draw();

      Renderer.capture(capture, -1, -1, IMAGE_R8G8B8, IMAGE_SOFT);

      ScreenShotThreads.queue(ScreenCaptures.New().create(capture, VecI2(2208, 1242), path+"5.5.jpg"), ScreenCapture.Process);

      ScreenShotThreads.queue(ScreenCaptures.New().create(capture, VecI2(1334,  750), path+"4.7.jpg"), ScreenCapture.Process);

      ScreenShotThreads.queue(ScreenCaptures.New().create(capture, VecI2(1136,  640), path+"4.0.jpg"), ScreenCapture.Process);

      D.aspectRatio(960./640);

      draw();

      Renderer.capture(capture, -1, -1, IMAGE_R8G8B8, IMAGE_SOFT);

      ScreenShotThreads.queue(ScreenCaptures.New().create(capture, VecI2(960, 640), path+"3.5.jpg"), ScreenCapture.Process);

      D.aspectRatio(2048./1536);

      draw();

      Renderer.capture(capture, -1, -1, IMAGE_R8G8B8, IMAGE_SOFT);

      ScreenShotThreads.queue(ScreenCaptures.New().create(capture, VecI2(2048, 1536), path+"iPad.jpg"), ScreenCapture.Process);

      D.aspectRatio(aspect);

      draw();

      TakingScreenShot=false;

      SkipGUI=false;

   }

}

void ScreenShotFinish()

{

   ScreenShotThreads.wait().del();

}

/******************************************************************************/

Creating/moving along a path

Mon, 06 Apr 2015 09:29:42 +0000

Hello everyone!

For my benchmarking tool, I needed a way to create and visualize smooth paths. And then, I needed a way to move an object (camera) along that path. Since it's a benchmarking tool, it has to work flawlessly at any framerate.
This required a bit more work than I had anticipated, since movement could just stop working or be totally wrong with low FPS, or high movement speed.
But after redesigning the movement calculation, it now works absolutely perfect under all conditions.

I present to you, a test project that allows you to:
- Place points by left-clicking on the screen. A continuous spline will be generated, connecting these points (you need a minimum of 4 points first).
- Move a dot along the path by holding Right mouse
- Set speed and resolution in real time
- Movement is always exact and smooth, no matter what framerate or dot-speed you run at.

I have made this test project in 2D so I could easily isolate just the path and movement code. I'm using the same code for my 3D application, all you need to do is replace Vec2 with Vec.
Lastly, I use "points" that I placed in the world editor, instead of placing them with clicking.

Have fun! I hope it's useful for someone.

Spline Project

(Yes, the project is just 3KB)

[Tuto]Ineisis - Inv & Item

Sun, 15 Feb 2015 10:47:36 +0000

Hello EWorld.

This post is to add Item and Inventory code for Ineisis. i copy mmo code for work.

Ok let's go.

1/ Create new Code in Shared => Net Inventory.cpp

Paste this code:

Code:

/******************************************************************************/

enum SLOT_TYPE // inventory item slot

{

   SLOT_HEAD    , // head         slot for helmet

   SLOT_NECK    , // neck         slot for amulet/necklace

   SLOT_ARM_L   , // left  arm    slot for weapon/shield/ammo

   SLOT_ARM_R   , // right arm    slot for weapon/shield/ammo

   SLOT_BODY    , // body         slot for armor/clothing

   SLOT_HANDS   , // hands        slot for gloves

   SLOT_LEGS    , // legs         slot for pants

   SLOT_FEET    , // feet         slot for shoes

   SLOT_FINGER_L, // left  finger slot for ring

   SLOT_FINGER_R, // right finger slot for ring

   SLOT_TEMP    , // temporary    slot (current item moved with mouse cursor)

   SLOT_SHLD     , // number of slots

   SLOT_NUM     , // number of slots

}

/******************************************************************************/

class NetInventory // net inventory

{

   Memc items;

   int           slots[SLOT_NUM]; // each array value represents a slot, and is equal to index of item in 'items' container or -1 if slot doesn't have an item

//   Reference slot[SLOT_NUM];

   NetInventory() {REPAO(slots)=-1;}

   // manage

   void del()

   {

      items.del();

      REPAO(slots)=-1;

   }

   // get

   bool valid(int slot)C {return InRange(slot, T.slots) && InRange(T.slots[slot], items);} // if 'slot' points to a valid item

   // network

   void compress(File &f, bool equipped_only=false) // compress data so it can be sent using network connection

   {

      if(equipped_only)

      {

         // check which items should be compressed

         int        equipped_items=0;

         Memc equipped; FREPA(items)equipped .New()=false; FREPA(slots)if(i!=SLOT_TEMP)if(InRange(slots[i], equipped))equipped[slots[i]]=true;

         Memc new_index; FREPA(items)new_index.New()=(equipped[i] ? equipped_items++ : -1);

         // compress

         f.putInt(equipped_items); FREPA(items)if(equipped[i])items[i].compress(f);

         FREPA(slots)if(i!=SLOT_TEMP)f.cmpIntV(InRange(slots[i], new_index) ? new_index[slots[i]] : -1);

      }else

      {

         // compress

         f.putInt(items.elms()); FREPA(items)items[i].compress(f);

         FREPA(slots)if(i!=SLOT_TEMP)f.cmpIntV(slots[i]);

      }

   }

   void decompress(File &f) // decompress data from data obtained using network connection

   {

      del();

      REP(f.getInt())items.New().decompress(f);

      FREPA(slots)if(i!=SLOT_TEMP)f.decIntV(slots[i]);

   }

   // io

   void save(File &f) // save item to file

   {

      items.save(f);

      f<
   }

   bool load(File &f) // load item from file, false on fail

   {

      del();

      if(!items.load(f))return false;

      f>>slots;

      return true;

   }

}

/******************************************************************************/

2/ Create new Code in Shared => Net Item.cpp

Paste this code:

Code:

class NetItem // net item

{

   Game.ObjParamsPtr obj;

   // manage

   void create(C UID &obj_id)

   {

      T.obj=obj_id;

   }

   // network

   virtual void compress(File &f) // compress data so it can be sent using network connection

   {

      f<
   }

   virtual void decompress(File &f) // decompress data from data obtained using network connection

   {

      obj=f.getUID();

   }

   // io

   void save(File &f) // save item to file

   {

      f.cmpUIntV(0); // version

      f<
   }

   bool load(File &f) // load item from file, false on fail

   {

      switch(f.decUIntV()) // version

      {

         case 0:

         {

            obj=f.getUID();

         }return true;

      }

      return false;

   }

}

/******************************************************************************/

Memx Items;

/******************************************************************************/

3/ Create new Code in Client => GUI Inventory.cpp

Paste this code:

Code:

/******************************************************************************

   'InventoryGui' is a set of visual gui objects which represent character's inventory.

/******************************************************************************/

class InventoryGui

{

   class InventoryWindow : Window

   {

      virtual void update(C GuiPC &gpc)

      {

         super.update(gpc);

         if(Gui.ms()==this && Ms.bp(1))

         {

            Ms.eat(1);

            hide();

         }

      }

   }

   Inventory    *inv=null; // Inventory which InventoryGui is linked with

   GuiObjs       gobjs; // gui objects

   List list; // list of items

   GuiImage      slot_image [SLOT_NUM]; // slot images  [slot index of SLOT_TYPE]

   Region       *slot_region[SLOT_NUM]; // slot regions [slot index of SLOT_TYPE]

   InventoryGui() {REPAO(slot_region)=null;}

   // manage

   void create()

   {

      gobjs.replaceWindow(); gobjs=UID(3696073335, 1090330182, 4248471980, 2484485872); gobjs.hide(); Gui+=gobjs;

      Window &window=gobjs.getWindow(S);

      window.move(Vec2(D.w()-0.05-window.rect().max.x, 0));

      window+=slot_image[SLOT_HEAD    ].create((slot_region[SLOT_HEAD    ]=&gobjs.getRegion("head"    )).rect());

      window+=slot_image[SLOT_NECK    ].create((slot_region[SLOT_NECK    ]=&gobjs.getRegion("neck"    )).rect());

      window+=slot_image[SLOT_ARM_L   ].create((slot_region[SLOT_ARM_L   ]=&gobjs.getRegion("arm l"   )).rect());

      window+=slot_image[SLOT_ARM_R   ].create((slot_region[SLOT_ARM_R   ]=&gobjs.getRegion("arm r"   )).rect());

      window+=slot_image[SLOT_BODY    ].create((slot_region[SLOT_BODY    ]=&gobjs.getRegion("body"    )).rect());

      window+=slot_image[SLOT_HANDS   ].create((slot_region[SLOT_HANDS   ]=&gobjs.getRegion("hands"   )).rect());

      window+=slot_image[SLOT_LEGS    ].create((slot_region[SLOT_LEGS    ]=&gobjs.getRegion("legs"    )).rect());

      window+=slot_image[SLOT_FEET    ].create((slot_region[SLOT_FEET    ]=&gobjs.getRegion("feet"    )).rect());

      window+=slot_image[SLOT_FINGER_L].create((slot_region[SLOT_FINGER_L]=&gobjs.getRegion("finger l")).rect());

      window+=slot_image[SLOT_FINGER_R].create((slot_region[SLOT_FINGER_R]=&gobjs.getRegion("finger r")).rect());

      window+=slot_image[SLOT_SHLD].create((slot_region[SLOT_SHLD]=&gobjs.getRegion("shld")).rect());

      REPAO(slot_image).rect_color.zero();

      // list

      {

         ListColumn lc[]=

         {

            ListColumn(MEMBER(Item, icon ), 0.21, "+"    ), // 0

            ListColumn(MEMBER(Item, name ), 0.52, "Nom" ), // 1

            ListColumn(MEMBER(Item, power), 0.21, "Dégât"), // 2

         };

         gobjs.getRegion("Backpack")+=list.create(lc, Elms(lc));

         list.column(0).text_align=0;

         list.column(2).precision=1; // set showing only 1 decimal precision for power float attribute

         list. cur_mode=LCM_MOUSE;

         list.drawMode(LDM_RECTS);

         list.flag|=LIST_SCALABLE;

         list.elmHeight(0.08);

         list.zoom_max*=1.44 ;

      }

   }

   // get

   bool visible()

   {

      if(Window *window=gobjs.findWindow(S))return window.visible();

      return false;

   }

   // operations

   void link(Inventory *inv) // link with 'inv' Inventory

   {

      if(T.inv!=inv)

      {

         T.inv=inv;

         setGui();

      }

   }

   void setGui() // set visual gui components

   {

      if(inv)

      {

         // set item list

         {

            // here we have to hide the items which are assigned to slots

            // create a 'visible' array which determines visibility of an element

            Memt visible; visible.setNum(inv.items.elms()); // allocate array of item visibility

            REPAO(visible)=true; // set all visibility by default to true

            REPA(inv.slots) // iterate through all slots

               if(inv.valid(i)) // if the slot is valid

                  visible[inv.slots[i]]=false; // set visibility for item assigned to a slot to false, to be hidden on the list

            list.setData(inv.items, visible); // set list data from items container and visibility list

         }

         // set slot images

         REP(SLOT_NUM) // for all slots

            if(i!=SLOT_TEMP) // skip temporary slot because it's not drawn using 'Image' class

               if(slot_region[i])

         {

            Rect      image_rect=slot_region[i].rect(); // gui rect

            GuiImage &image_item=slot_image [i]       ; // gui image

            if(!inv.valid(i))image_item.set(null);else // if there is no item then clear the item image slot

            {

               ImagePtr icon=inv.item(inv->slots[i]).icon; // access item's icon

               image_item.set(icon);                       // set slot image as the item's icon

               if(icon)                                    // set proper scaling

               {

                  Vec2 size=icon->size(); size*=PixelSize; // set default size

                  if(size.x>image_rect.w())size*=image_rect.w()/size.x; // clamp item size to background slot width

                  if(size.y>image_rect.h())size*=image_rect.h()/size.y; // clamp item size to background slot height

                  Rect rect(image_rect.center()); rect.extend(size/2);

                  image_item.rect(rect);

               }

            }

         }

      }else

      {

         list.clear();

         REPAO(slot_image).set(null);

      }

   }

   void toggle() {if(visible())hide();else show();} // toggle visibility

   void show() {gobjs.getWindow(S).show();}

   void hide() {gobjs.getWindow(S).hide();}

   // update

   void update(Player &owner) // handle moving items with mouse

   {

      if(inv)

      {

         if(Ms.bp(0)) // if mouse button pressed

         {

            if(InRange(inv.slots[SLOT_TEMP], inv.items)) // if we have an item attached with mouse

            {

               if(Gui.ms()==&list) // if mouse cursor is on the list

               {

                  inv.slots[SLOT_TEMP]=-1; // clear the slot reference which will result in "putting back the item into the list"

                  setGui();                // update visuals

                  owner.sendInvSlots();

               }

            }

            else // we don't have an item so we want to get one

            {

               if(Gui.ms()==&list) // from the list

               {

                  if(list())

                  {

                     inv.slots[SLOT_TEMP]=list.visToAbs(list.cur);

                     setGui(); // update visuals

                     owner.sendInvSlots();

                  }

               }

            }

            REPA(slot_image)

               if(Gui.ms()==&slot_image[i] || Gui.ms()==slot_region[i]) // if we want to swap temp item with i-th slot

                  if(inv.slotsCanBeSwapped(SLOT_TEMP, SLOT_TYPE(i)))

            {

               Swap(inv.slots[SLOT_TEMP], inv.slots[i]); // swap temporary with i-th slot

               setGui();                                 // update visuals

               owner.sendInvSlots();

            }

         }

      }

   }

   // draw

   void draw() // draw item being moved with mouse

   {

      if(inv && InRange(inv.slots[SLOT_TEMP], inv.items))

      {

         Vec2 pos=Ms.pos();

         inv.item(inv.slots[SLOT_TEMP]).drawIcon(pos);

      }

   }

}

InventoryGui InvGui;

/******************************************************************************/

4/ Create new Code in Client => Inventory.cpp

Paste this code:

Code:

/******************************************************************************/

class Inventory : NetInventory

{

  ~Inventory() {if(InvGui.inv==this)InvGui.link(null);}

   Inventory() {items.replaceClass();}

   // get

   Item& item(int i) {return (Item&)items[i];} // we can perform direct cast since 'items' had 'replaceClass' called in constructor

   bool slotCanBePutTo(SLOT_TYPE src, SLOT_TYPE dest) // test if slot 'src' can be put to 'dest' slot

   {

      if(!InRange(src, SLOT_NUM) || !InRange(dest, SLOT_NUM))return false;

      return valid(src) ? item(slots[src]).canBePutTo(dest) : true;

   }

   bool slotsCanBeSwapped(SLOT_TYPE a, SLOT_TYPE b) // test if slot 'a' can be swapped with slot 'b'

   {

      return slotCanBePutTo(a, b) && slotCanBePutTo(b, a);

   }

   // manage

   void create(NetInventory &src)

   {

      del();

      items.setNum(src.items.elms()); FREPA(src.items)item(i).create(src.items[i]);

      Copy(slots, src.slots);

      setGui();

   }

   /*void itemRemoved(Game.Obj &item) // called when an item is being removed

   {

      // perform check if it is a equipped item

     //  REPA(slot) // for all slots

        //  if(slots[i]==item) // if i-th slot is set to item which is being removed

           //  slots[i].clear(); // clear the slot so it can no longer be referenced to the removed item

   }*/

   void itemRemoved() // called when an item has been removed

   {

      setGui();

   }

   void itemAdded() // called when an item has been added

   {

      setGui();

   }

   void setGui()

   {

      if(InvGui.inv==this)InvGui.setGui();

   }

   // update

   void update(AnimatedSkeleton &skel, Player *owner)

   {

      if(owner && InvGui.inv==this)if(Player *player=CAST(Player, owner))InvGui.update(*player);

      // set matrixes for items in hands

      if(valid(SLOT_ARM_L))

      {

         if(C OrientP *point=skel.findPoint(8"HandL"))

         {

            Item   &item  =T.item(slots[SLOT_ARM_L]);

            Matrix  matrix=item.matrix(); // get current matrix

            item.matrix(Matrix().setPosDir(point.pos, point.cross(), point.dir)); // set new matrix

            item.update();

            // immediately overwrite item members after calling 'update'

            GetVel(item.vel, item.ang_vel, matrix, item.matrix()); // calculate velocities between old and new matrixes

         }

      }

      if(valid(SLOT_ARM_R))

      {

         if(C OrientP *point=skel.findPoint(8"HandR"))

         {

            Item   &item  =T.item(slots[SLOT_ARM_R]);

            Matrix  matrix=item.matrix(); // get current matrix

            item.matrix(Matrix().setPosDir(point.pos, point.cross(), point.dir)); // set new matrix

            item.update();

            // immediately overwrite item members after calling 'update'

            GetVel(item.vel, item.ang_vel, matrix, item.matrix()); // calculate velocities between old and new matrixes

         }

      }

      if(valid(SLOT_SHLD))

      {

         if(C OrientP *point=skel.findPoint(8"Shld"))

         {

            Item   &item  =T.item(slots[SLOT_SHLD]);

            Matrix  matrix=item.matrix(); // get current matrix

            item.matrix(Matrix().setPosDir(point.pos, point.cross(), point.dir)); // set new matrix

            item.update();

            // immediately overwrite item members after calling 'update'

            GetVel(item.vel, item.ang_vel, matrix, item.matrix()); // calculate velocities between old and new matrixes

         }

      }

   }

   // draw

   uint drawPrepare()

   {

      // draw items in hands

      uint modes=0;

      if(valid(SLOT_ARM_L))modes|=item(slots[SLOT_ARM_L]).drawPrepare();

      if(valid(SLOT_ARM_R))modes|=item(slots[SLOT_ARM_R]).drawPrepare();

      if(valid(SLOT_SHLD))modes|=item(slots[SLOT_SHLD]).drawPrepare();

      return modes;

   }

   void drawShadow()

   {

      // draw items in hands

      if(valid(SLOT_ARM_L))item(slots[SLOT_ARM_L]).drawShadow();

      if(valid(SLOT_ARM_R))item(slots[SLOT_ARM_R]).drawShadow();

      if(valid(SLOT_SHLD))item(slots[SLOT_SHLD]).drawShadow();

   }

}

/******************************************************************************/

5/ copy the "gui inventory" file located in MMO Source to you project.

6/ In Net Chr.cpp

=> class ClientChr : NetChr add this :

Code:

NetInventory      inv;

=> void create(CreateChr &cc) add this :

Code:

inv.items.New().create("ITEM UID");

=> virtual void save(File &f) add this :

Code:

inv.save(f);

=> virtual bool load(File &f) add this :

Code:

if(!inv.load(f))return false;

=> void compress(File &f) add this :

Code:

inv.compress(f);

=> void decompress(File &f) add this :

Code:

inv.decompress(f);

7/ In Commands.cpp

=> enum CLIENT_SERVER_COMMANDS just down why CS_CHR_ANIM, add this:

Code:

CS_CHR_INV_SLOTS    ,   // Inv

=> class ChrVisuals Copy this :

Code:

class ChrVisuals

{

   SockAddr addr;

   MeshPtr  mesh;

   NetInventory inv;

   void save(File &f)

   {

      addr.save(f);

      f<
      inv.compress(f, true);

   }

   void load(File &f)

   {

      addr.load(f);

      mesh=f.getUID();

     inv.decompress(f);

   }

}

void ServerWriteChrVisuals(File &f, ChrVisuals &cv)

{

   f.writeMem(); cv.save(f);

}

void ServerSendChrVisuals(Connection &conn, ChrVisuals &cv)

{

   File f; f.writeMem().putByte(CS_CHR_VISUALS); cv.save(f); f.pos(0); conn.send(f, -1, false);

}

void ClientRecvChrVisuals(File &f, ChrVisuals &cv)

{

   cv.load(f);

}

=> just down why

Code:

// CS_CHR_ANIM

/******************************************************************************/

void ClientSendChrAnim(Connection &conn, C UID &anim, C UID &sound=UIDZero)

{

   File f; f.writeMem().putByte(CS_CHR_ANIM)<
}

void ServerRecvChrAnim(File &f, UID &anim, UID &sound)

{

   f>>anim>>sound;

}

void ServerWriteChrAnim(File &f, C SockAddr &addr, C UID &anim, C UID &sound)

{

   f.writeMem().putByte(CS_CHR_ANIM); addr.save(f); f<
}

void ClientRecvChrAnim(File &f, SockAddr &addr, UID &anim, UID &sound)

{

   addr.load(f); f>>anim>>sound;

}

add this:

Code:

// CS_CHR_INV_SLOTS

/******************************************************************************/

void ClientSendChrInvSlots(Connection &conn, int (&slots)[SLOT_NUM])

{

   File f; f.writeMem().putByte(CS_CHR_INV_SLOTS); f<
}

void ServerRecvChrInvSlots(File &f, int (&slots)[SLOT_NUM])

{

   f>>slots;

}

8/ Create new Code in Client => Item.cpp

Paste this code:

Code:

/******************************************************************************/

class Item : NetItem

{

   ITEM_TYPE type=ITEM_NONE;

   byte      type2=0;

   flt       scale=1, power=0;

   Str       name;

   MeshPtr   mesh;

   ImagePtr  icon;

   Vec       vel, ang_vel;

   Actor       actor         ;

   //Particles particles;

   //bool particles_under_water=false;

   void create(NetItem &src)

   {

      SCAST(NetItem, T)=src;

      if(obj)

      {

         // name

         if(Param *p=obj->findParam("name"))name=p.asText();

         // type

         if(Param *p=obj->findParam("type" ))type =p.asEnum(ITEM_NONE);

         if(Param *p=obj->findParam("type2"))type2=p.asEnum();

         // power

         if(Param *p=obj->findParam("power"))power=p.asFlt();

         // icon

         if(Param *p=obj->findParam("icon"))icon=p.asID();

         scale=obj->scale();

         mesh =obj->mesh ();

      }

   }

   // get / set

   bool canBePutTo(SLOT_TYPE inv_slot) // test if item can be put to 'inv_slot' inventory slot

   {

      if(inv_slot==SLOT_TEMP)return true;

      switch(inv_slot)

      {

         case SLOT_HEAD : return type==ITEM_ARMOR && type2==ARMOR_HELMET  ;

         case SLOT_BODY : return type==ITEM_ARMOR && type2==ARMOR_BODY    ;

         case SLOT_HANDS: return type==ITEM_ARMOR && type2==ARMOR_GAUNTLET;

         case SLOT_LEGS : return type==ITEM_ARMOR && type2==ARMOR_PANTS   ;

         case SLOT_FEET : return type==ITEM_ARMOR && type2==ARMOR_BOOT    ;

         case SLOT_SHLD:

         case SLOT_ARM_L:

         case SLOT_ARM_R:

         {

            if(type==ITEM_WEAPON)return true;

            if(type==ITEM_MISC && Contains(name, "Torch"))return true;

         }break;

      }

      return false;

   }

   void matrix(Matrix &matrix)

   {

      T._matrix_scaled=T._matrix=matrix;

      T._matrix_scaled.scaleOrn(scale);

   }

   C Matrix& matrix      () {return _matrix       ;}

   C Matrix& matrixScaled() {return _matrix_scaled;}

   // update

   void update() {}

   // draw

   void drawIcon(C Vec2 &pos)

   {

      if(icon)icon->drawFit(Rect_LU(pos, icon->size()*PixelSize));

   }

   virtual uint drawPrepare()

   {

      if(mesh && Frustum(mesh->box, matrixScaled()))mesh->draw(matrixScaled(), vel, ang_vel);

      SetHighlight((Cur.obj, this && Cur.highlight) ? Color(34, 85, 85, 0) : TRANSPARENT); //uint modes=super.drawPrepare();

      SetHighlight(                                                          TRANSPARENT);

     // if(particles.is() && !particles_under_water)

     // {

         //modes|=IndexToFlag(particles.renderMode());

         //modes|=IndexToFlag(RM_BLEND); // single particle

         //Vec center;

         //flt opacity=particles.opacity(¢er);

         //LightSqr(6*opacity, center).add(true, this);

     // }

      return 0;

   }

  virtual void drawShadow()

   {

      if(mesh && Frustum(mesh->box, matrixScaled()))mesh->drawShadow(matrixScaled());

      //if(CurrentLight.src!=this); //super.drawShadow();

   }

//virtual void drawPalette () {if(!particles_under_water){particles.draw();}}

  //virtual void drawPalette1() {if(!particles_under_water){particles.draw();}}

   //virtual void drawBlend   () {if(!particles_under_water){particles.draw(); DrawParticle(*Images(UID(4250561076, 1214902943, 3956203709, 646772750)), 0, Color(255, 255, 170, 0), 0.07, 0.9, 0, particles.shape.pos()*particles.matrix, Vec(0));}}

   // network

   virtual void decompress(File &f) // decompress data from data obtained using network connection

   {

      super.decompress(f);

      create(T);

   }

private:

   Matrix _matrix, _matrix_scaled;

}

/******************************************************************************/

9/ In Player.cpp

=> class Player : Game.Chr , BlendObject add this:

Code:

Player() {InvGui.link(&inv);}

   Inventory      inv;

Code:

// *************************Inv**************** //

   void sendInvSlots() // send current equipped items (slots) to server

   {

      ClientSendChrInvSlots(Server, inv.slots);

   }

   //************************************************ //

=> void Player.create(ClientChr &chr) add this:

Code:

inv.create(chr.inv);

=> bool Player.update() add this:

Code:

inv.update(skel,  this);

   if(InvGui.inv==&inv && !inv.valid(SLOT_TEMP))

         {

           if(Kb.bp(KB_I))InvGui.toggle();

         }

=> uint Player.drawPrepare() add this:

Code:

SetHighlight(DamageColor(damage_time));

      uint draw_mask=~0;

      bool hide_head=(ViewMode==VIEW_FPP && !Renderer.mirror());

      if(  hide_head)FlagDisable(draw_mask, IndexToFlag(DG_CHR_HEAD));

      SetDrawMask(draw_mask); mesh->draw(skel);

      SetDrawMask();

      SetHighlight();

      inv.drawPrepare(); // ADD THIS

10/ In Game.cpp => bool InitGame() add this:

Code:

InvGui.create();

=> void ShutGame() add this:

Code:

InvGui  .hide();

=> void DrawGame() add this:

Code:

InvGui.draw();

11/ In Constants.cpp => add this:

Code:

const flt PixelSize=0.002;

If you have any questions, Post here. Thanks

[Tuto] Restater.Bat for application

Sun, 25 Jan 2015 21:32:16 +0000

Hello,

I share this tutorial, here's how to create a restarter for an application. Example: if your server.exe shutdown => restater.bat restart server app.

Ok, let's go.

1= Create a new file.TXT

2= Opens with BlocNote / Notepad++

3= Copy this code:

Code:

:1

start /WAIT server.exe

goto 1

4= Replace your NameAPP = server.exe

5= Save File =>.bat (Ex: Restater.bat)

6= Place the file in folders of NameApp.exe.

Run !

Thanks, Bye

Reliable UDP

Wed, 10 Dec 2014 00:31:36 +0000

I noticed there was no UDP (FastConnection) tutorial included with EE.

I have been converting my game to RUDP and so decided to make a little tutorial using what I learned. Its useful to see how to use UDP in EE as well as a simple way to do reliable-ordered UDP. See the attached esenthelproject, I have also included the code for people who are not using the latest EE.

Features
Multiple clients
Auto dropping timed-out clients
Can send packets both reliably and unreliably
Ping calculation
Packet loss calculation

Project includes a ReliableFastConnectionClass, a Demo Client, and Demo Server.

Why use this over RakNet? Because its simpler! 100% EE Script code.

What it missing that would be nice:
Handshakes, Encryption, Packet combining, Limiting Packets to 1500 bytes or auto-fragmenting into smaller, sequential delivery rather than strict ordered etc.. etc..

I didn't put more effort into it than I needed to, I only use EE on the client so that is why the server isn't more complete (testing for malformed packets, buffer overrun etc), a malicious client could kill it pretty easy!

The class

Code:

// communication constants

   const Byte RFC_PING = 0;

   const Byte RFC_PING_REPLY = 1;

   const Byte RFC_UNRELIABLE = 2;

   const Byte RFC_RELIABLE = 3;

   const Byte RFC_CONFIRM_RELIABLE = 4;

class ReliableFastConnection : FastConnection // UDP connection with optional reliable-ordered delivery

{

   // things that can be tweaked..

   Int pingFrequency = 10; //times per second to ping, 0 = server, > 0 = client

   Int reliableTimeout = 100; // time in milliseconds from last reliable message to try sending it again

   Int connectionTimeout = 15; // time in seconds that if no ping is received toremoved the ActiveDestination from remoteAddresses

   // things not to be tweaked..

   SockAddr localListenAddress;

   Flt lastPingTime = 0; //seconds since app start, used to decide if we need to send another ping or not (client only)

   Flt ping = 0; //round trip latency ms

   Memc ping_times; // container for storing the last 10 ping times

   Flt packet_loss = 0; // percentage of ping packets that don't make it across the wire averaged over 10 seconds

   Memc pings_received_last_10_secs; // pings that have been recieved in last 10 seconds

   ULong reliable_received = 0; // data in bytes received

   ULong unreliable_received = 0;

   ULong reliable_sent = 0; 

   ULong unreliable_sent = 0;

   struct PacketAddr

   {

      Byte data[65536];

      UShort length;

      SockAddr address;

      void from_file(File &f,  SockAddr addr)

      {

         address = addr;

         f.pos(0);

         length = f.size();

         f.get(data, length);

      }

   }

   struct ActiveDestination

   {

      SockAddr address;

      Flt received_ping_at_time = 0; // the last time we got a ping in local time, not remote tag time

      ULong local_synchro_on_local  = 0; // what our last reliable packet sent out was tagged with

      ULong local_synchro_on_remote = 0; // the last confirmed received reliable packet from the remote connection

      ULong remote_synchro_on_local = 0; // the last reliable packet recieved from the remote connection was tagged with this

      Memc reliable_queue; 

      Flt lastReliableTime = 0;

   }

   Memc remoteAddresses;

   Memc received_queue; // this is currently not put into ActiveDestination like reliable_queue, but it certainly could be..

   // connect(..) doesn't actually send anything to the remote host, its really just setting the remote address and opening the local UDP

   // port for listening, after all, UDP is really connection-less, we establish a "connection" through keep-alive pinging in the update loop.

   void connect(SockAddr remoteaddr,  SockAddr listenaddr) // only the client uses this

   {

      ActiveDestination actdest;

      actdest.address = remoteaddr; 

      remoteAddresses.add(actdest); // client will only have 1 destination address.

      listen(listenaddr);

      return;

   }

   void listen(SockAddr addr) // server will just listen, not use connect

   {

      create(addr);

      localListenAddress = addr;

      return;

   }

   void send_reliable(SockAddr addr, File &f) // this actually just adds to a queue

   {

      PacketAddr padd;

      padd.from_file(f, addr);

      if(remoteAddresses_has_remote(addr))

      {

         get_remoteAddress(addr).reliable_queue.add(padd); // add to end of queue

      }

      return;

   }

   void send_unreliable(SockAddr destination, File &f)

   {

      File f2;

      f2.writeMem().putByte(RFC_UNRELIABLE).putUShort(f.size());

      f.pos(0); // make sure it is at the beginning of the file before copying

      f.copy(f2);

      f2.pos(0);

      send(destination, f2);

      unreliable_sent += f.size(); // we ar enot including the RFC header and UShort size

   }

   Bool update()

   { 

      Int bytes_received = 0;

      Byte datarec[65536];

      SockAddr sender_addr;

      bytes_received = receive(sender_addr, datarec); 

      while(bytes_received > -1) // needs to be loop more than one command recieved at once is possible? seems like it shoudl onyl return 1 packet at a time, but maybe need multiple calls to receive if low framerate?

      {

         File f;f.readMem(datarec, bytes_received);

         //while(!f.end())  // should not need this? we will only send 1 command per packet, doing multiple commands per packet  makes it harder when we decide to ignore the rest of a packet like in RFS_RELIABLE case below, we would need to make sure to read out the rest of the data in the packet otherwise will will get buggy stuff

         {

            Byte command = f.getByte();

            switch(command)

            {

               case RFC_PING: // only server will receive this, client pings server, not vice-versa

                  {

                    Flt ptime = f.getFlt();

                    ULong loc_synchro_on_remote = f.getULong(); // learn what was the last reliable client got from the server was, lets us know if we need to resend

                    if(remoteAddresses_has_remote(sender_addr))

                     {

                        ActiveDestination & adest = get_remoteAddress(sender_addr);

                        adest.local_synchro_on_remote = loc_synchro_on_remote;

                        adest.received_ping_at_time = Time.realTime();

                        File f2;

                        f2.writeMem().putByte(RFC_PING_REPLY).putFlt(ptime).putULong(adest.remote_s​ynchro_on_local).pos(0); // let the client know what the last reliable the server got from it was

                        send(sender_addr,  f2); 

                     }

                     else

                     {

                        ActiveDestination actdest;

                        actdest.address = sender_addr;

                        actdest.received_ping_at_time = Time.realTime();

                        remoteAddresses.add(actdest);

                        File f2;

                        f2.writeMem().putByte(RFC_PING_REPLY).putFlt(ptime).putULong(actdest.remote​_synchro_on_local).pos(0); // let the client know what the last reliable the server got from it was

                        send(sender_addr,  f2);

                     }

                  }  

                  break;

               case RFC_PING_REPLY: // client will recieve this

                  {

                    Flt lastPingTimeReceived = f.getFlt();

                    // for packet loss calculation

                    pings_received_last_10_secs.add(lastPingTimeReceived);

                    // calculate ping

                    if(ping_times.elms() > 9)

                     {

                        ping_times.add(Time.realTime() - lastPingTimeReceived);

                        ping_times.remove(0, true);

                        Flt ping_time_total = 0;

                        REPA(ping_times){ping_time_total +=ping_times[i];}

                        ping = (ping_time_total / ping_times.elms()) * 1000; // make it in milliseconds

                     }

                     else

                     {

                        ping_times.add(Time.realTime() - lastPingTimeReceived);

                     }

                     // check to see if we need to increase our local synchro

                     test_local_synchro_on_remote(f.getULong(), remoteAddresses[0].local_synchro_on_remote, remoteAddresses[0]); 

                  }

                  break;

               case RFC_UNRELIABLE: 

                  {

                     UShort length_of_packet = f.getUShort(); // datarec may contain more than one packet, so we need to only get one at a time

                     File f2;

                     f2.writeMem();

                     f.copy(f2, length_of_packet); // hopefully f.copy advances pos() of f.. need ot maek sure otherwise this wont work, it will just keep reading the same packet over and over

                     PacketAddr padd;

                     padd.from_file(f2, sender_addr);

                     received_queue.add(padd);

                     unreliable_received += length_of_packet;

                  }

                  break;

               case RFC_RELIABLE: 

                  {

                     ULong synchro = f.getULong();

                     if(remoteAddresses_has_remote(sender_addr))

                     {

                        ActiveDestination & adest = get_remoteAddress(sender_addr);

                        if(synchro ==  (adest.remote_synchro_on_local + 1)) // is it the next synchro message? we need to make sure its not a repeat of something we already received

                        {

                           UShort length_of_packet = f.getUShort(); // datarec may contain more than one packet, so we need to only get one at a time

                           File f2;

                           f2.writeMem();

                           f.copy(f2, length_of_packet); // hopefully f.copy advances pos() of f.. need ot maek sure otherwise this wont work, it will just keep reading the same packet over and over

                           PacketAddr padd;

                           padd.from_file(f2, sender_addr);

                           received_queue.add(padd);

                           adest.remote_synchro_on_local += 1;

                           reliable_received += length_of_packet;

                           // now we need to send a confirmation back immediately so remote doesn't have to wait for next ping

                           File f3;

                           f3.writeMem().putByte(RFC_CONFIRM_RELIABLE).putULong(adest.remote_synchro_on_loc​al).pos(0); // let the remote know what the last reliable the server got from it was

                           send(sender_addr,  f3);

                        }

                     }

                  }

               case RFC_CONFIRM_RELIABLE: 

                  {

                     REPA(remoteAddresses)if(remoteAddresses[i].address == sender_addr)

                     test_local_synchro_on_remote(f.getULong(), remoteAddresses[i].local_synchro_on_remote, remoteAddresses[i]); // check to see if we need to increase our local synchro

                  }   

                  break;

               default:

                  Exit("RFC Default, something went wrong, no matching command!");

                  break;

            }

         bytes_received = receive(sender_addr, datarec); // read the next packet, if it exists

         }

       }

      send_ping(); // currently only works for client

      send_from_reliable_queues();

      if(pingFrequency == 0)remove_dead_remote_addresses(); // only server should do this for now, unless server->client pings are implemented

      return true;

   }

private: 

   void remove_dead_remote_addresses()

   {

      Bool removed_one = false;

      REPA(remoteAddresses)

      {

         if(((Time.realTime() - remoteAddresses[i].received_ping_at_time) > connectionTimeout) && !removed_one)

         {

            remoteAddresses.remove(i);

            removed_one =true;

            break;

         }

      }

   }

   void send_from_reliable_queues()

   {

      REPA(remoteAddresses)

      if(remoteAddresses[i].reliable_queue.elms()) // if there is stuff in the queue

         if(remoteAddresses[i].local_synchro_on_local == remoteAddresses[i].local_synchro_on_remote) // if the destination address has received  all previous reliable messages

         {

            actually_send_reliable(remoteAddresses[i].reliable_queue.first(),remoteAddresses[i].lastReliableTime, ++remoteAddresses[i].local_synchro_on_local);

         }

         else if((Time.realTime() - remoteAddresses[i].lastReliableTime) > (reliableTimeout/1000) ) // destination has not received our last sent reliable, and timeout has occured to send it again

         {

            actually_send_reliable(remoteAddresses[i].reliable_queue.first(),remoteAddresses[i].lastReliableTime, remoteAddresses[i].local_synchro_on_local);

         }

   }

   void send_ping()

   {

      if(pingFrequency > 0) // is a client so ping

         if((Time.realTime() - lastPingTime) > (1/pingFrequency))

         {

            File f;

            f.writeMem().putByte(RFC_PING).putFlt(Time.realTime()).putULong(remoteAddre​sses[0].remote_synchro_on_local).pos(0); //remote_synchro_on_local let the server know what the last reliable the client got from it was

            //send(destinationAddress,  f);

            send(remoteAddresses[0].address,  f);

            lastPingTime = Time.realTime();

            // update pack loss stuff only for client

            update_packet_loss();

            packet_loss = ((pingFrequency * 10) - pings_received_last_10_secs.elms()) / 100.0;

            if(packet_loss < 0) packet_loss = 0.0;

            if(Time.realTime() < 10.0)packet_loss = 0; // jus tignor eit the first 10 secs of app opening

         }

   }

   void actually_send_reliable(PacketAddr &padd, Flt &last_reliable_sent_time, ULong synchro_to_tag_packet_with)

   {

        File f;

        f.writeMem().putByte(RFC_RELIABLE).putULong(synchro_to_tag_packet_with).put​UShort(padd.length); // tag as reliable, put the synchro, add the length of the packet

        f.put(padd.data, padd.length); // add packet

        f.pos(0);

        send(padd.address,  f);

        last_reliable_sent_time = Time.realTime();

        reliable_sent += padd.length; // we are not including the RFC header and UShort size

   }

   void update_packet_loss()

   {

      REPA(pings_received_last_10_secs)

      {

         Bool removed_one = false;

         if(Time.realTime() - pings_received_last_10_secs[i] > 10 &&  !removed_one)

         {

            pings_received_last_10_secs.remove(i);

            removed_one = true;

            update_packet_loss();

         }

      }

   }

   void test_local_synchro_on_remote(ULong test_synchro, ULong &loc_synchro_on_remote,  ActiveDestination &adest)

   {

      if(test_synchro == loc_synchro_on_remote + 1) // server has confirmed a new reliable

      {

         loc_synchro_on_remote += 1;

         adest.reliable_queue.remove(0, true); // this will shift memory, is this too slow?

      }

   }

   Bool remoteAddresses_has_remote(SockAddr address) // is the remote address in remoteAddresses?

   {

      Bool found_remote = false;

      REPA(remoteAddresses)if(address == remoteAddresses[i].address){ found_remote = true; break;}

      return found_remote;

   }

   ActiveDestination& get_remoteAddress(SockAddr address) 

   {

      REPA(remoteAddresses)if(address == remoteAddresses[i].address) return remoteAddresses[i];

      Exit("Couldn't find remote addess, make sure to callremoteAddresses_has_remote first");

      return remoteAddresses[0];

   }

}

The client demo

Code:

/******************************************************************************

   This tutorial presents a sample  Reliable UDP Client Connection.

   It can be used together with second tutorial "Demo Server"

/******************************************************************************/

Str destinationIP = "127.0.0.1";

Str last_message_string = "nothing";

// destinationPort and listenPort must be different if server is run on localhost, 

// because only one process can listen to a UDP port at one time,

// otherwise they can be the same port, and probably should be to help with

// NAT transversal (so that end users don't need to forward ports on router).

Int destinationPort = 8791;

//Int listenPort = 8790; 

ReliableFastConnection connection;

/******************************************************************************/

void InitPre()

{

   EE_INIT();

   App.flag=APP_WORK_IN_BACKGROUND|APP_NO_PAUSE_ON_WINDOW_MOVE_SIZE; // specify work in background flag to work also when not focused

   App.x=1;

   D.mode(500, 400);

   D.scale(1.25);

}

bool Init()

{

   SockAddr remoteAddress;

   remoteAddress.setIP(destinationIP, destinationPort);

   if(Contains(destinationIP, "127.0.0.1")) //can't listen and send from 2 apps on same ip:port over UDP

   {

      SockAddr address;

      address.setIP(destinationIP, destinationPort);

      SockAddr localAddress;

      localAddress.setLocalFast(destinationPort + Random(1, 1000)); // choose random port, hopefully no conflicts

      connection.connect(remoteAddress, localAddress);

   }

   else

   {

      SockAddr localAddress;

      localAddress.setLocalFast(destinationPort); // if we are not running server and client on same PC it is OK to use the same listen port on server and client

      connection.connect(remoteAddress, localAddress);

   }

   return true;

}

/******************************************************************************/

void Shut()

{

}

/******************************************************************************/

bool Update()

{

   if(Kb.bp(KB_ESC))return false;

   connection.update();

   if(Kb.b(KB_R)) //flood reliable

   {

      File f; f.writeMem().putStr(S+ "Reliable Random # :" + Random(0, 1000)).pos(0);

      connection.send_reliable(connection.remoteAddresses[0].address, f); //connection.remoteAddresses[0].address is kind of awkward, clients will only have 1 remoteAddress

   }

   if(Kb.b(KB_U)) //flood unreliable

   {

      File f; f.writeMem().putStr(S+ "UNreliable Random # :" + Random(0, 1000)).pos(0);

      connection.send_unreliable(connection.remoteAddresses[0].address, f);

   }

   return true;

}

/******************************************************************************/

void Draw()

{

   D.clear(TURQ); 

   {

      D.text(0, 0.7, S+"Press 'U' to send unreliable packets, 'R' to send reliable packets.");

      if(connection.received_queue.elms())

      {

         File f;

         f.writeMem();

         f.put(connection.received_queue.last().data, connection.received_queue.last().length);

         f.pos(0);

         last_message_string = f.getStr();

         connection.received_queue.clear();

      }

      D.text(0, 0.6, S+"Last Packet Received Had String: " + last_message_string);

      D.text(0, 0.5, S+"packet_loss "+ connection.packet_loss * 100 + "%");

      D.text(0, 0.4, S+"connection rec: "+ connection.received());

      D.text(0, 0.3, S+"connection sent: "+ connection.sent());

      D.text(0, 0.2, S+"connectdes: "+connection.remoteAddresses[0].address.asText());

      D.text(0, 0.1, S+"connectloc: "+connection.localListenAddress.asText());

      D.text(0, 0.0, S+"FPS "+ Time.fps());

      D.text(0, -0.1, S+"remote_synchro_on_local "+ connection.remoteAddresses[0].remote_synchro_on_local);

      D.text(0, -0.2, S+"local_synchro_on_remote "+ connection.remoteAddresses[0].local_synchro_on_remote);

      D.text(0, -0.3, S+"local_synchro_on_local "+ connection.remoteAddresses[0].local_synchro_on_local);

      D.text(0, -0.4, S+"ping "+ connection.ping);

      D.text(0, -0.5, S+"reliable_sent "+ connection.reliable_sent);

      D.text(0, -0.6, S+"unreliable_sent "+ connection.unreliable_sent);

   }

}

The server demo

Code:

/******************************************************************************

   This tutorial presents a sample  Reliable UDP Server Connection.

   It can be used together with second tutorial "Demo Client"

/******************************************************************************/

Int listenPort = 8791; 

ReliableFastConnection connection;

Str last_message_string = "nothing";

/******************************************************************************/

void InitPre()

{

   EE_INIT();

   App.flag=APP_WORK_IN_BACKGROUND|APP_NO_PAUSE_ON_WINDOW_MOVE_SIZE; // specify work in background flag to work also when not focused

   App.x=1;

   D.mode(500, 400);

   D.scale(1.25);

}

bool Init()

{

   SockAddr addr;

   addr.setLocalFast(listenPort);

   connection.listen(addr);

   connection.pingFrequency = 0; // server doesn't send pings

   return true;

}

/******************************************************************************/

void Shut()

{

}

/******************************************************************************/

bool Update()

{

   if(Kb.bp(KB_ESC))return false;

   connection.update();

   if(Kb.b(KB_R)) //flood reliable to all connected (have received recent ping) clients

   {

      File f; f.writeMem().putStr(S+ "From Server Reliable# :" + Random(0, 1000)).pos(0);

      REPA(connection.remoteAddresses)connection.send_reliable(connection.remoteA​ddresses[i].address, f);

   }

   if(Kb.b(KB_U)) //flood unreliable to all connected (have received recent ping) clients

   {

      File f; f.writeMem().putStr(S+ "From Server UNreliable# :" + Random(0, 1000)).pos(0);

      REPA(connection.remoteAddresses)connection.send_unreliable(connection.remot​eAddresses[i].address, f); 

   }

   return true;

}

/******************************************************************************/

void Draw()

{

   D.clear(TURQ);

   {

      D.text(0, 0.7, S+"Press 'U' to send unreliable packets, 'R' to send reliable packets.");

      if(connection.received_queue.elms())

      {

         File f;

         f.writeMem();

         f.put(connection.received_queue.last().data, connection.received_queue.last().length);

         f.pos(0);

         last_message_string = f.getStr();

         connection.received_queue.clear();

      }

      D.text(0, 0.6, S+"Last Packet Received Had String: " + last_message_string);

      D.text(0, 0.5, S+"FPS "+ Time.fps());

      D.text(0, 0.4, S+"connection.received()"+ connection.received());

      D.text(0, 0.3, S+"connection.sent()"+ connection.sent());

      D.text(0, 0.2, S+"connection.unreliable_received "+ connection.unreliable_received);

      D.text(0, 0.1, S+"connection.reliable_received "+ connection.reliable_received);

      D.text(0, 0.0, S+"number of clients: "+connection.remoteAddresses.elms());

      D.text(0, -0.1, S+"connection.localListenAddress: "+connection.localListenAddress.asText());

      //D.text(0, -0.2, S+"remote_synchro_on_local "+ connection.remote_synchro_on_local);

      //D.text(0, -0.3, S+"local_synchro_on_remote "+ connection.local_synchro_on_remote);

      //D.text(0, -0.4, S+"local_synchro_on_local "+ connection.local_synchro_on_local);

      //D.text(0, 0.0, S+"Received Data: "+data);

   }

}

ReliableFastConnection7.zip (Size: 6.82 KB / Downloads: 16)

Rebuild MipMaps Tool

Sun, 12 Oct 2014 04:34:29 +0000

Recently I've released an update that improves quality of texture mip maps, this however affects only newly created images/textures.

Run this utility on an existing project, to rebuild all your existing images/textures mip-maps.

Usage Instructions:
-compile the tool but don't run yet
-enable "editor network interface" in the editor
-switch to your desired project (open it in the editor) to rebuild mip maps
-now run the previously compiled utility

Warning:
After rebuilding all texture mip-maps, Android and iOS Optimized textures will need to be rebuilt by the editor!
This may take a long time.

Rebuild Mip-Maps Esenthel Project.7z (Size: 1.2 KB / Downloads: 15)

Lambda in EE

Thu, 27 Mar 2014 15:54:38 +0000

Hi!

Just wanted to share a micro code snippet, hope you like it!
Most people know Lambda-functions in C++11, i think this way of using them is very cool:

Code:

D.screen_changed = 

    [] (Flt old_width, Flt old_height) -> void

    {

        // paste your screen changes here

    };

No need to declare separate functions to perform screen changing! You can paste this code in Init() state

EDIT:
Of course it works with button functions also

Code:

button->func([](Ptr)

    { 

        Gui.msgBox("Test", "Lambda test in button function"); 

    }       );

EDIT2:
And, and, and... No need to create static void's inside classes!

Code:

struct MyStruct

{

    Window wnd;

    Button btn;

    //... here we create window and button ...//

    btn->func(

        [](Ptr strct) -> void

        {

            ((MyStruct*)strct)->wnd.fadeToggle();

        }, this);            

}

More precision to pathfinder.

Thu, 17 Oct 2013 00:34:23 +0000

Since I am having issues with pathfinder at ramps (confirmed in pathfinder tutorial, EE 1.0 and 2.0), I did an algorithm to give more precision:

Code:

Game::Chr::actionMoveTo(pos);

Int precision = 2;

for(Int x = 0; x< precision; x++)

        {

            if(path.elms()>1)

            {

                Int tocheck = path.elms()-1;

                Int index = 0;

                FREP(tocheck)

                {

                    Vec midpoint = (path[index] + path[index+1]) / 2.f;

                    Vec surface_pos;

                    if(Game::World.path().nearestSurface(midpoint, Vec(0.9f,0.9f,0.9f), surface_pos))

                    {

                        path.NewAt(index+1) = surface_pos;

                        index+=2;

                    }

                    else

                    {

                        index++;

                    }

                }

            }

        }

Save/Load Engine Settings

Mon, 14 Oct 2013 05:02:01 +0000

Small tutorial showing how to load a few basic engine settings:

Code:

/******************************************************************************/

void SaveSettings(TextData &data)

{

   data.getNode("Width"     ).value=S+D.x();

   data.getNode("Height"    ).value=S+D.y();

   data.getNode("Fullscreen").value=S+D.full();

}

void LoadSettings(TextData &data)

{

   int x=-1, y=-1, full=-1;

   if(TextNode *node  =data.findNode("Fullscreen"))full=node  .asInt();

   if(TextNode *width =data.findNode("Width"     ))x   =width .asInt();

   if(TextNode *height=data.findNode("Height"    ))y   =height.asInt();

   D.mode(x, y, full);

}

void SaveSettings(C Str &name="Settings.txt")

{

   TextData settings; SaveSettings(settings); settings.save(name);

}

void LoadSettings(C Str &name="Settings.txt")

{

   TextData settings; if(settings.load(name))LoadSettings(settings);

}

/******************************************************************************/

void InitPre()

{

   EE_INIT();

   App.flag|=APP_MAXIMIZABLE|APP_MINIMIZABLE|APP_RESIZABLE|APP_FULL_TOGGLE;

   LoadSettings();

}

bool Init()

{

   return true;

}

void Shut()

{

   SaveSettings();

}

bool Update()

{

   if(Kb.bp(KB_ESC))return false;

   return true;

}

void Draw()

{

   D.clear();

}

/******************************************************************************/

Simple Rigid Follow Cam

Mon, 27 May 2013 19:58:57 +0000

I tried a bunch of different ways to set the camera, but it always ended up wonky in some way, whether jumping around at the top and bottom of the rotation arc, or by not allowing going upside-down.

This code will follow an object around at a certain offset. If your character goes up side down, so will the camera(hence, I call it 'rigid'). This might be fun to attach as a 3rd person car camera, or for a jet plane or a spaceship.

The easiest way to make this work is to call something similar to this pseudo code:
SetCustomCam(mychar.matrix(), mychar.....getPoint("camera_slot").pos, mychar.....getPoint("camera_slot").dir, false);

Now you can do a barrel roll!

Alternatively,
SetCustomCam(mychar.matrix(), Vec(0, 5, 0), interestingObjectPos);

A periscope feel!

If you want to move the camera around, you can modify offset.

Code:

void SetCustomCam( C Matrix &mat,                  // Matrix that belongs to the object for the cam to follow

                   C Vec &offset,                  // The offset in local coords

                   C Vec &facing,                  // The direction to face

                   bool  facingIsLocation = true ) // Whether the direction is a point in the world to face or a normalized direction                                

{

   Vec pos = offset;                               // The offset to move the camera by

   pos.mul( mat.orn( ) );                          // Transform the local vector by the rotation

   pos += mat.pos;                                 // Apply to world coords

   Vec up( 0, 1, 0 );                              // Create the up vector

   up .mul(mat.orn( ) );                           // Rotate the up vector so the camera up is relative to the object up

   Vec dir = facingIsLocation ?                     

      !( facing - pos ) :                          // Set the direction towards a point

      dir = facing      ;                          // Set the direction the same as passed in

   Cam.setPosDir( pos, dir, up );                  // Apply the transforms to the camera

   Cam.updateVelocities(  ).set(  );               // Update Velocities for effects and set the camera active

}

Hopefully, this will save someone a lot of the time it took me to experiment.

Auto Fov

Thu, 16 May 2013 17:29:30 +0000

Let say that you like 65º of FOVY for 1,33 aspect ratio (for example 1024x768).

When you change aspect ratio, you will see a different viewport because fov must be changed too.

I want to share this function for those ppl working with different resolutions or for mobiles.

Code:

// deg param is relative to 1.3333 aspect ratio.

Flt AutoFov(Flt deg, FOV_MODE fov)

{

    if(fov == FOV_X)

    {

        Flt vertical = 2 * Atan( Tan(DegToRad(deg)/2.f) * (1.f / 1.3333f) );

        Flt finalHorizontal = 2 * Atan( Tan(vertical/2.f) * D.w() );

        return finalHorizontal;

    }

    else

    {

        Flt horizontal = 2 * Atan( Tan(DegToRad(deg)/2.f) * 1.3333f );

        Flt finalVertical = 2 * Atan( Tan(horizontal/2.f) * (1.f / D.w()) );

        return finalVertical;

    }

}

How it works:

1) Set aspect ratio of 1.333 => D.mode(1024,768);
2) Choice a fov value playing with D.viewFov(); For this example D.viewFov(65,FOV_Y);
3) Change the resolution => D.mode(1280,720);
4) Change D.viewFov(65,FOV_Y) by D.viewFov(AutoFov(65,FOV_Y),FOV_Y);

You will get the same viewport for any resolution. It also works with FOV_X.

EE 2.0 Example Project - Tower Defense!

Fri, 05 Apr 2013 14:29:02 +0000

Hey there EE community!

For learning purposes, I was working on a tower defense project using Esenthel. Along the way, I decided to make it open-source so that everyone can benefit from it (or curse at me for how I programmed it..).

Features:

- Lots of comments that should make clear what I did
- Custom RTS camera controls (zoom in/out, move with WASD, rotate)
- Load world from editor
- Load waypoints from editor
- Enemies spawn in waves and run along waypoints
- GUI to place turrets and upgrade them.
- Placeable turrets (1 type so far), turrets shoot at, and kill, enemies
- Turrets rotate when idle, turn to enemies, fire with particles
- Turrets construct gradually, using mesh masking.
- Turrets can't be placed on the road
- ...

Not included (yet):
- Sounds
- Winning/losing
- Resources
- Turrets can be placed on top of each other

I'm not a superb programmer by any means. This project taught me a lot, so I would do things a bit differently if I would start over-new. Different turret types has to be more flexible, same with enemies.

Published Project (.exe (32/64bit) + packed data)

Source Project

Make sure to read the ReadMe in the sources for the licenses.

If you have any suggestions, feel free to post them here. In the meantime, I hope this can show people a bit more of how Esenthel works.

Lightmaps for RM_SIMPLE

Tue, 29 Jan 2013 21:21:07 +0000

Thanks esenthel for the last sdk update. This is a custom shader for lightmaps + alpha test on RM_SIMPLE renderer mode.

Code:

#include "Main.h"

/******************************************************************************/

// VERTEX SHADER

/******************************************************************************/

void VS

(

   // vertex input

   VtxInput vtx,

   // output

   out Vec4 oPos:POSITION,

   out Vec2 oDiffuseTex:TEXCOORD0,

   out Vec2 oLightTex:TEXCOORD1

)

{

   oDiffuseTex=vtx.tex();

   oLightTex=vtx.tex1();

   oPos=Project(TransformPos(vtx.pos4()));

}

/******************************************************************************/

// PIXEL SHADER

/******************************************************************************/

Vec4 PS

(

   Vec2 DiffuseTex:TEXCOORD0,

   Vec2 LightTex:TEXCOORD1

):COLOR

{

    // Alpha test

    if(Tex(Col, DiffuseTex).a<1.f-MaterialColor().a)

        discard;

        // Diffuse texture color * Material Color * Lightmap color

    return Vec4(Tex(Col, DiffuseTex).rgb * MaterialColor().rgb * Tex(Lum, LightTex).rgb,1.f);

}

/******************************************************************************/

// TECHNIQUE

/******************************************************************************/

TECHNIQUE(Main, VS(), PS()); 

/******************************************************************************/

And the screenshots:
iOS

Android

Both running at 60 fps.

Server sided AI

Mon, 07 Jan 2013 16:56:21 +0000

Hello, I have made up my mind, and I have decided that I will now start my programming series for this Community. I came to this conclusion because I think there are too few Examples / Tutorials. Today I begun working on the basic structure of the Server and Client.

When I have enough time to spend on this, I will not be making separate files or posts. This will eventually be one bigger sized project. But hold your thoughts, I am not aiming on creating a fully functional huge project for you, I am here to provide a basic structure of which i would like to call Project X Online. This will not be in the size of an MMO, but will give a beginning for people to work from.

This project will be using EE's Networking for folks who would like to use EE MMO to integrate, or Ineisis.
As of right now, i will provide you with the beginning of this, which contains:

Client,

Basic AI (Movement, visual, name)
Player class for the future
Connection to server
Menu state for the future

Server,

AI Movement
AI Spawn
AI Radius for movement
Client connections
Image Map used for checking (Not provided fully yet)

NOTE: I will not comment basic C++, I hope that you have understanding in C++ and also a little of Esenthel, so that this will give you more of an Idea.

I would also like to thank Esenthel for providing us with this Engine, and credit also goes to Yvan for giving me an Idea from his previous post for the AI. ( http://www.esenthel.com/community/showth...p?tid=4573 )

Best regards TBJOKERS.

ProjectX.rar (Size: 142.93 KB / Downloads: 199)

EE containers & C++11 ranged for loops

Thu, 18 Oct 2012 08:40:54 +0000

If anyone miss C++11 functionality with EE containers, here is a little helper class that can be used:

Code:

template  class Container>

struct ArrayIter

{

public:

  ArrayIter(Ptr array, Int idx) :

     _array(array),

     _idx(idx)

  {}

  bool operator!=(const ArrayIter & right) const { return _idx != right._idx; }

  const ArrayIter & operator++() { ++_idx; return *this; }

  T & operator*() const;

protected:

  Ptr _array;

  Int  _idx;

};

template  class Ancestor>

struct Array : public Ancestor

{

  typedef ArrayIter Iterator;

  const Iterator begin() const { return Iterator(this, 0); }

        Iterator begin()       { return Iterator(this, 0); }

  const Iterator end()   const { return Iterator(this, elms()); }

        Iterator end()         { return Iterator(this, elms()); }

};

template  class Container>

T & ArrayIter::operator*() const

{

  return static_cast *>(_array)->operator[](_idx);

}

so you can use it like this:

Code:

typedef Array ObjPlayers;

ObjPlayers players;

for (auto & player : players) player.drawPrepare();

C++11 is supported (not yet fully though) with VS2012. We are using it for a couple of months already for developing EE and I strongly encourage you to do so if you would like it too..