PositionPrice should be used instead of TradePrice, but the % modification suggested by nonetheless doesn’t work actually, because you should also change the lines where TrailStart is used to compare with the current price.

I coded it with pips in my mind, so the code would need some in-depth modifications to work with percentages.

Line 56, for example, compares pips. It should be changed to compare percentages.

I think it woukd be better to convert a percentage into pips, in line 14:

TrailStart = (close / PipSize) * pc / 100

this will compute a percentage of the current price, before entering a trade, and convert it into pips.

You may also use your Equity instead of close, and change the expression:

TrailStart = (MyEquity / PipValue) * pc / 100

You can also use such expression for StepSize.

PriceDistance should be left as is, since it has no relation with risk and percentages.

With such minor modifications you will accommodate for percentages without modifying the logic of the code.

Your assumption is correct because you are using SP500 o Nasdaq, or any other index with a price/pip ratio of 1. Try applying that percentage to, say, Aud/Chf which is 0.7167 with a price/pip ratio of 1/10000th!

If you want to use some code for your personal use you can do whatever you want because that suits your needs and you know what it does, but to make a code portable it must be coded so that it can be used on every  instrument.

This is the new code with the addition of (optional) percentages as above (as suggested by nonetheless). I added a MINSTART to prevent TrailStart from dropping below ZERO when Equity (if you plan to use it) turns negative.

Define MyEquity somewhere in your code  (even to ZERO if you don’t plan to use it):

//------------------------------------------------------------------------------------------------------------------------------------------------
//                     Trailing Start
//------------------------------------------------------------------------------------------------------------------------------------------------
ONCE UseCLOSE = 1                                 //1=use CLOSE,  0=use High/Low
srcH = close                                      //defaults to CLOSE
srcL = close                                      //defaults to CLOSE
IF UseCLOSE = 0 THEN
   srcH = high
   srcL = low
ENDIF
ONCE UsePerCentage = 0                            //0=use Pips  (default), 1=use Percentages
ONCE UseEquity     = 0                            //0=use price (default), 1=use current Equity (initial Capital + StrategyProfit, as defined by variable MyEquity)
//
DirectionSwitch = (LongOnMarket AND ShortOnMarket[1]) OR (LongOnMarket[1] AND ShortOnMarket)  //True when there's been a change in the direction (likely to be due to a Stop & Reverse)
//
IF Not OnMarket OR DirectionSwitch THEN
   //
   // when NOT OnMarket or thare's been a change in direction, reset values to their default settings
   //
   StartPerCent  = 0.25        //0.25%  to start triggering Trailing Stop       (when UsePerCentage=1)
   StepPerCent   = 50          //50%    (of the 0.25% above) as a Trqiling Step (when UsePerCentage=1) (set to 100 to make StepSize=TrailStart, set to 200 to make it twice TrailStart)
   //
   TrailStart    = 30          //30     Start trailing profits from this point  (when UsePerCentage=0)
   MinStart      = 10          //10     Minimum value for TrailStart            (when UseEquity=1, to prevent TrailStart from dropping below ZERO when Equity turns negative)
   IF UsePerCentage THEN
      TrailStart = (close / PipSize) * StartPerCent / 100           //use current price (CLOSE) for calculations
      IF UseEquity THEN                                             //alternative calculations using EQUITY
         TrailStart = Max(MinStart,(MyEquity / PipValue) * StartPerCent / 100)  //MyEquity is the variable (feel free to use a different name) retaining your current equity
      ENDIF
   ENDIF
   //
   BasePerCent   = 0.200       //20.0%  Profit percentage to keep when setting BerakEven
   //
   StepSize      = 10          //10     Pip chunks to increase Percentage
   IF UsePerCentage THEN
      StepSize   = TrailStart * StepPerCent / 100
   ENDIF
   //
   PerCentInc    = 0.100       //10.0%  PerCent increment after each StepSize chunk
   RoundTO       = -0.5        //-0.5   rounds always to Lower integer,   +0.4 rounds always to Higher integer,     0 defaults PRT behaviour
   PriceDistance = 7 * pipsize //7      minimun distance from current price
   y1            = 0           //reset to 0
   y2            = 0           //reset to 0
   ProfitPerCent = BasePerCent //reset to desired default value
   //PositionCount = 0
   SellPrice     = 0
   SellPriceX    = 0
   ExitPrice     = 9999999
   ExitPriceX    = 9999999
ELSE
   //------------------------------------------------------
   // --- Update Stop Loss after accumulating new positions
   //------------------------------------------------------
   //PositionCount = max(PositionCount,abs(CountOfPosition))
   //
   // update Stop Loss only when PositionPrice has changed (actually when increased, we don't move it if there's been some positions exited)
   //
   //IF PositionCount <> PositionCount[1] AND (ExitPrice + SellPrice)<>9999999 THEN //go on only if Trailing Stop had already started trailing
   IF PositionPrice <> PositionPrice[1] AND (ExitPrice + SellPrice) <> 9999999 THEN //go on only if Trailing Stop had already started trailing
      IF LongOnMarket THEN
         q1         = PositionPrice + ((srcH - PositionPrice) * ProfitPerCent)      //calculate new SL
         SellPriceX = max(max(SellPriceX,SellPrice),q1)
         SellPrice  = max(max(SellPriceX,SellPrice),PositionPrice + (y1 * pipsize)) //set exit price to whatever grants greater profits, comopared to the previous one
      ELSIF ShortOnMarket THEN
         r1         = PositionPrice - ((PositionPrice - srcL) * ProfitPerCent)      //calculate new SL
         ExitPriceX = min(min(ExitPriceX,ExitPrice),r1)
         ExitPrice  = min(min(ExitPriceX,ExitPrice),PositionPrice - (y2 * pipsize)) //set exit price to whatever grants greater profits, comopared to the previous one
      ENDIF
   ENDIF
// --- Update END
ENDIF
//
IF LongOnMarket AND srcH > (PositionPrice + (y1 * pipsize)) THEN                              //LONG positions
   //
   // compute the value of the Percentage of profits, if any, to lock in for LONG trades
   //
   x1 = (srcH - PositionPrice) / pipsize                                     //convert price to pips
   IF x1 >= TrailStart THEN                                                //    go ahead only if N+ pips
      Diff1         = abs(TrailStart - x1)                                 //difference from current profit and TrailStart
      Chunks1       = max(0,round((Diff1 / StepSize) + RoundTO))           //number of STEPSIZE chunks
      ProfitPerCent = BasePerCent + (BasePerCent * (Chunks1 * PerCentInc)) //compute new size of ProfitPerCent
      ProfitPerCent = max(ProfitPerCent[1],min(100,ProfitPerCent))         //make sure ProfitPerCent doess not exceed 100%
      y1 = max(x1 * ProfitPerCent, y1)                                     //y1 = % of max profit
   ENDIF
ELSIF ShortOnMarket AND srcL < (PositionPrice - (y2 * pipsize)) THEN                             //SHORT positions
   //
   // compute the value of the Percentage of profits, if any, to lock in for SHORT trades
   //
   x2 = (PositionPrice - srcL) / pipsize                                     //convert price to pips
   IF x2 >= TrailStart THEN                                                //      go ahead only if N+ pips
      Diff2         = abs(TrailStart - x2)                                 //difference from current profit and TrailStart
      Chunks2       = max(0,round((Diff2 / StepSize) + RoundTO))           //number of STEPSIZE chunks
      ProfitPerCent = BasePerCent + (BasePerCent * (Chunks2 * PerCentInc)) //compute new size of ProfitPerCent
      ProfitPerCent = max(ProfitPerCent[1],min(100,ProfitPerCent))         //make sure ProfitPerCent doess not exceed 100%
      y2 = max(x2 * ProfitPerCent, y2)                                     //y2 = % of max profit
   ENDIF
ENDIF
//------------------------------------------------------------------------------
//                    manage actual Exit, if needed
//------------------------------------------------------------------------------
IF y1 THEN                                                                 //Place pending STOP order when y1 > 0   (LONG positions)
   SellPrice = max(SellPrice,PositionPrice + (y1 * pipsize))                  //convert pips to price
   //
   // check the minimun distance between ExitPrice and current price
   //
   IF abs(close - SellPrice) > PriceDistance THEN
      //
      // place either a LIMIT or STOP pending order according to current price positioning
      //
      IF close >= SellPrice THEN
         SELL AT SellPrice STOP
      ELSE
         SELL AT SellPrice LIMIT
      ENDIF
   ELSE
      //
      //sell AT MARKET when EXITPRICE does not meet the broker's minimun distance from current price
      //
      SELL AT Market
   ENDIF
ENDIF
IF y2 THEN                                                                 //Place pending STOP order when y2 > 0   (SHORT positions)
   ExitPrice = min(ExitPrice,PositionPrice - (y2 * pipsize))                  //convert pips to price
   //
   // check the minimun distance between ExitPrice and current price
   //
   IF abs(close - ExitPrice) > PriceDistance THEN
      //
      // place either a LIMIT or STOP pending order according to current price positioning
      //
      IF close <= ExitPrice THEN
         EXITSHORT AT ExitPrice STOP
      ELSE
         EXITSHORT AT ExitPrice LIMIT
      ENDIF
   ELSE
      //
      //ExitShort AT MARKET when EXITPRICE does not meet the broker's minimun distance from current price
      //
      EXITSHORT AT Market
   ENDIF
ENDIF