TriForce

by ludohoebi in category Trend at 11/08/2016
Description

TriForce V7.0 10/12/2016

Enfin la nouvelle version! Après une longue attente avec l'erreur 500, je vous propose "déjà" la version 7.0 que j'ai modifié à peine hier...

Quoi de nouveau? Pas mal de changement et à vrai dire, je ne sais même plus où j'en étais...

Cette nouvelle version à pour objectif de travailler à la fois, en multi-Timeframes et en multi-graphiques. Comme vus sur le screen, on peut avoir l'intégralité des infos de 4 devises différentes sur un seul écran...

- Point et Figure sans limite de temps. Il évalue suivant x pips de retour et 1 pip de progression, la tendance générale. Plus le paramètre "pip" est haut, moins il y aura de mouvement de retournement... On peut voir sur le graphique 2 valeurs. La première est la tendance générale. La seconde, les valeurs numériques. La version "graphique" à été supprimée pour éviter d'avoir trop d'informations. Il est neutre si la valeur est inférieure à la précédente...

- HeikinAshi modifié pour ceux qui n'ont pas encore connaissance de cette particularité. Il fonctionne sur 5 valeurs. La version de base, uniquement 2. Donc 5 couleurs. Orange pour Neutre. Foncé pour un signal faible. Clair pour un signal fort. Pour le reste, à vous de découvrir. Il est disponible sur le graphique pour la couleur, en haut à gauche pour les valeurs ;)

- Nouveauté! Ajout des principaux Chandeliers japonais: Englobante, Hamari, Gaps et bien entendu Doji! Ceux-ci sont ensuite filtré par l'indicateur suivant, la EXMA...

- La EXMA est une version adaptée de l'Exponential Moving Average. Celle-ci est dépendante d'une période fixe en paramètre. Gros changement avec la version précédente dépendante du Timeframe choisi (trop relou)... La couleur varie suivant le Median ;)

- Des Valeurs sur les positions prises avec le EA non disponible. C'est une stratégie que je garde pour moi mais il suffit d'avoir un EA avec des positions "label": "TriForce"+Symbol.Code. La partie centrale est donc inutile sans la stratégie mais je ne vais pas faire un indicateur pour moi et un pour les autres non plus. 600 lignes de code, c'est pas rien lol Vous avez malgré tout le paramètre pour désactiver cette zone centrale...

- Différents Timeframes pour une vue d'ensemble (à droite). Mieux, sur ce point vous êtes gâtés! Ceux-ci sont non seulement visible avec la force. Mais ils s'adaptent à un schéma particulier. 1/3 de la barre précédente, signal en attente. 1/2 signal en vue d'une "percée", attendre. 2/3, retournement possible. Complet, englobante. Le tout en plus, prenant en compte les chandeliers (voir plus haut)!

- Non, ce n'est pas encore fini lol Dernier point important, le fibonnaci est aussi d'actualité. Fibonnaci modifié dépendant de la Période d'un Timeframe et évaluant sa progression suivant le "nombre d'or" sur 4 zones! En y regardant de plus prêt, je vous laisse découvrir, vous remarquerez principalement 2 types de signaux. Le rebond et l'élastique. Parfais pour savoir si la tendance est en attente ou si elle peut au besoin changer...

Je n'ai pas encore testé l'indicateur sous cette nouvelle version mais je pense que cela devrait être intéressant à moins d'avoir l'un ou l'autre bug non visible pour l'instant. Voilà, bon trade à tous et merci d'avance pour vos commentaires ;)

Je donne cet indicateur gratuitement mais si vous le souhaitez, n'hésitez pas à faire une petite donation, ça fait toujours plaisir pour le travail fourni / I send this for Free, but if you need, you can send me donation here: PayPal.Me/hoebi

Download
1289 downloads
How to install
Notification Publishing copyrighted material is strictly prohibited. If you believe there is copyrighted material in this section you may use the Copyright Infringement Notification form to submit a claim.
Formula / Source Code
Language: C#
Trading Platform: cAlgocTrader
using System;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;

namespace cAlgo.Indicators
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AutoRescale = true)]
    public class TriForce_IND : Indicator
    {
        [Parameter("Période", DefaultValue = 15)]
        public int Pe { get; set; }

        [Parameter("pip size", DefaultValue = 3)]
        public int pip { get; set; }

        [Parameter("Période Robot", DefaultValue = 20)]
        public int PeR { get; set; }

        [Parameter("Candle", DefaultValue = 3)]
        public int ct { get; set; }

        [Parameter("Long Timeframe")]
        public TimeFrame LTF { get; set; }

        [Parameter("Capital risk max %", DefaultValue = 5)]
        public int CRK { get; set; }

        [Parameter("View Timeframe", DefaultValue = true)]
        public bool vvol { get; set; }

        [Parameter("View Positions", DefaultValue = true)]
        public bool vpos { get; set; }

        private IndicatorDataSeries _xOpen, _xClose, V;

        private Colors color, bdcolor1, lbdcolor1;

        private int ix, lix, mt;

        private double HAval, LHAval, _xHigh, _xLow;

        private double actlast, actnow;
        private double dir = 0;
        private double di1, di2, di3, di4;

        private Colors Cr, Co, Cg, Cdr, Cdg, EmaC;

        private double O, C, H, L;

        private double stoplossBuy, stoplossSell;

        protected override void Initialize()
        {
            _xOpen = CreateDataSeries();
            _xClose = CreateDataSeries();
            V = CreateDataSeries();
            actnow = MarketSeries.Close.LastValue;
            mt = 1;

            Cr = Colors.Red;
            Co = Colors.Orange;
            Cg = Colors.YellowGreen;
            Cdr = Colors.DarkRed;
            Cdg = Colors.Green;
        }

        public override void Calculate(int i)
        {
            ChartObjects.RemoveAllObjects();

            //--------------------------------------------------------Variables globales

            lix = ix;
            ix = i;
            lbdcolor1 = bdcolor1;
            O = MarketSeries.Open[i];
            C = MarketSeries.Close[i];
            H = MarketSeries.High[i];
            L = MarketSeries.Low[i];

            //--------------------------------------------------------HA/MMA/PFX Début        

            ////Variables de base

            double HAvaly = Symbol.PipSize;
            string StD = "";
            double dstD = 0;
            bool Engl = false;
            bool Doji = false;
            bool FGaps = false;
            bool Hama = false;

            actnow = MarketSeries.Close[i - Pe + 1];
            dir = di1 = di2 = di3 = di4 = 0;

            double rtx = 0;

            double exp;
            string tdn4, tdn5, tdn6 = "wait";
            int Pema = Pe;
            Colors EmaCx;

            ////Calculs de Base

            if (lix != ix)
            {
                LHAval = HAval;
            }

            var xClose = (((Math.Min(O, C) + L) / 2) + ((Math.Max(O, C) + H) / 2)) / 2;
            double xOpen;
            if (i > 0)
                xOpen = (_xOpen[i - 1] + _xClose[i - 1]) / 2;
            else
                xOpen = (O + C) / 2;

            _xHigh = Math.Max(Math.Max(H, xOpen), xClose);
            _xLow = Math.Min(Math.Min(L, xOpen), xClose);

            _xClose[i] = xClose;
            _xOpen[i] = xOpen;


            var emaopen = (((Math.Min(O, C) + L) / 2) + ((Math.Max(O, C) + H) / 2)) / 2;
            exp = 8.0 / (Pema + 1);
            var exmax = V[i - 1];
            var exma1 = (double.IsNaN(exmax)) ? emaopen : emaopen * exp + exmax * (1 - exp);
            V[i] = exma1;

            //--------------------------------------------------------HA/MMA/PFX Boucle

            for (int Pex = i - Pe; Pex <= i; Pex++)
            {
                //Variables de boucle
                var ox = MarketSeries.Open[Pex];
                var cx = MarketSeries.Close[Pex];
                var hx = MarketSeries.High[Pex];
                var lx = MarketSeries.Low[Pex];
                var me = MarketSeries.Median[Pex];
                var lcx = MarketSeries.Close[Pex - 1];
                var lox = MarketSeries.Open[Pex - 1];
                var lhx = MarketSeries.High[Pex - 1];
                var llx = MarketSeries.Low[Pex - 1];

                var lHAvaly = HAvaly;
                var HAvalyx = Math.Max(_xClose[Pex], _xOpen[Pex]) - Math.Min(_xClose[Pex], _xOpen[Pex]);
                HAvaly = (HAvalyx > lHAvaly) ? HAvalyx : lHAvaly;
                var lval = _xClose[Pex - 1] - _xOpen[Pex - 1];
                var val = _xClose[Pex] - _xOpen[Pex];
                color = (_xOpen[Pex] > _xClose[Pex] && MarketSeries.Close[Pex] < _xClose[Pex] && lval < val) ? Cdr : (_xOpen[Pex] > _xClose[Pex] && MarketSeries.Close[Pex] < _xClose[Pex] && lval >= val) ? Cr : (_xOpen[Pex] < _xClose[Pex] && MarketSeries.Close[Pex] > _xClose[Pex] && lval > val) ? Cdg : (_xOpen[Pex] < _xClose[Pex] && MarketSeries.Close[Pex] > _xClose[Pex] && lval <= val) ? Cg : Co;

                var hlx = ((hx - lx) * 3) / 2;
                var mxh = ((hx + lx) / 2) + (((hx - lx) / 100) * 33);
                var mxl = ((hx + lx) / 2) - (((hx - lx) / 100) * 33);
                var ex = 3 * (Math.Max(ox, cx) - Math.Min(ox, cx));
                var ey = 3 * (Math.Max(lox, lcx) - Math.Min(lox, lcx));
                Doji = ((ox == cx && ox >= mxh) || (ox == cx && ox <= mxl)) ? true : false;
                Engl = ((Math.Max(ox, cx) > Math.Max(lox, lcx) && Math.Min(ox, cx) < Math.Min(lox, lcx)) || (Math.Max(ox, cx) > Math.Max(MarketSeries.Open[Pex - 2], MarketSeries.Close[Pex - 2]) && Math.Min(ox, cx) < Math.Min(MarketSeries.Open[Pex - 2], MarketSeries.Close[Pex - 2]))) ? true : false;
                FGaps = ((ox < cx && lox < lcx && lcx < ox && Engl == false) || (ox > cx && lox > lcx && lcx > ox && Engl == false)) ? true : false;
                Hama = (ex < (ey / 2) && Math.Max(ox, cx) < Math.Max(lox, lcx) && Math.Min(ox, cx) > Math.Min(lox, lcx)) ? true : false;
                var dstup = hx + (((hx - lx) / 100) * 33);
                var dstdn = lx - (((hx - lx) / 100) * 33);

                var lastactnow = actnow;
                var lastdir = dir;

                var lEmac = EmaC;
                EmaC = (V[Pex] < cx && V[Pex] < me) ? Cg : (V[Pex] > cx && V[Pex] > me) ? Cr : lEmac;
                tdn6 = (EmaC == Cg) ? "Buy" : "Sell";

                //Point et Figure

                if (dir >= 0)
                {
                    if (cx < (actnow - ((pip * mt) * Symbol.PipSize)))
                    {
                        di1 = di2;
                        di2 = di3;
                        di3 = di4;
                        di4 = dir;
                        var newactnow = actnow - ((pip * mt) * Symbol.PipSize);
                        actlast = actnow;
                        actnow = newactnow;
                        dir = -(pip * mt);

                        var dirx = Math.Floor(((actnow - (mt * Symbol.PipSize)) - cx) / (mt * Symbol.PipSize));
                        var newactnowx = actnow - ((mt * dirx) * Symbol.PipSize);
                        actnow = newactnowx;
                        dir = dir - dirx - 1;
                    }

                    if (cx > (actnow + (mt * Symbol.PipSize)))
                    {
                        var dirx = Math.Floor((cx - (actnow + (mt * Symbol.PipSize))) / (mt * Symbol.PipSize));
                        var newactnowx = actnow + ((mt * dirx) * Symbol.PipSize);
                        actnow = newactnowx;
                        dir = lastdir + dirx;
                    }
                }

                else if (dir <= 0)
                {
                    if (cx > (actnow + ((pip * mt) * Symbol.PipSize)))
                    {
                        di1 = di2;
                        di2 = di3;
                        di3 = di4;
                        di4 = dir;
                        var newactnow = actnow + ((pip * mt) * Symbol.PipSize);
                        actlast = actnow;
                        actnow = newactnow;
                        dir = (pip * mt);

                        var dirx = Math.Floor((cx - (actnow + (mt * Symbol.PipSize))) / (mt * Symbol.PipSize));
                        var newactnowx = actnow + ((mt * dirx) * Symbol.PipSize);
                        actnow = newactnowx;
                        dir = dir + dirx + 1;
                    }

                    if (cx < (actnow - (mt * Symbol.PipSize)))
                    {
                        var dirx = Math.Floor(((actnow - (mt * Symbol.PipSize)) - cx) / (mt * Symbol.PipSize));
                        var newactnowx = actnow - ((mt * dirx) * Symbol.PipSize);
                        actnow = newactnowx;
                        dir = lastdir - dirx;
                    }
                }

                rtx = (dir > 0) ? actnow - ((pip * mt) * Symbol.PipSize) : actnow + ((pip * mt) * Symbol.PipSize);
                var rty = (dir > 0) ? actnow + (mt * Symbol.PipSize) : actnow - (mt * Symbol.PipSize);

                //Création graphique

                ChartObjects.DrawLine("Candle" + Pex, Pex, MarketSeries.Open[Pex], Pex, MarketSeries.Close[Pex], color, ct, LineStyle.Solid);
                ChartObjects.DrawLine("Line" + Pex, Pex, MarketSeries.High[Pex], Pex, MarketSeries.Low[Pex], color, 1, LineStyle.Solid);

                StD = (Doji == true && ox < me && ox > V[Pex]) ? "D\n▼" : (Doji == true && ox > me && ox < V[Pex]) ? "▲\nD" : "";
                dstD = (_xOpen[Pex] < _xClose[Pex]) ? dstdn : dstup;
                ChartObjects.DrawText("Doji" + Pex, StD, Pex, dstD, VerticalAlignment.Center, HorizontalAlignment.Center, color);
                StD = (Engl == true && ox > cx && ox > V[Pex]) ? "E\n▼" : (Engl == true && ox < cx && ox < V[Pex]) ? "▲\nE" : "";
                dstD = (ox < cx) ? dstdn : dstup;
                ChartObjects.DrawText("Englobant" + Pex, StD, Pex, dstD, VerticalAlignment.Center, HorizontalAlignment.Center, color);
                StD = (FGaps == true && ox > cx && ox > V[Pex]) ? "G\n▼" : (FGaps == true && ox < cx && ox < V[Pex]) ? "▲\nG" : "";
                dstD = (ox < cx) ? dstdn : dstup;
                ChartObjects.DrawText("Gaps" + Pex, StD, Pex, dstD, VerticalAlignment.Center, HorizontalAlignment.Center, color);
                StD = (Hama == true && ox > cx && lox < lcx && ox > V[Pex]) ? "H\n▼" : (Hama == true && ox < cx && lox > lcx && ox < V[Pex]) ? "▲\nH" : "";
                dstD = (ox < cx) ? dstdn : dstup;
                ChartObjects.DrawText("Hamari" + Pex, StD, Pex, dstD, VerticalAlignment.Center, HorizontalAlignment.Center, color);

                ChartObjects.DrawLine("Rx", i - 1, rtx, i + 1, rtx, Colors.Blue);
                ChartObjects.DrawLine("Rz", i - 1, actnow, i + 1, actnow, Colors.BlueViolet);
                ChartObjects.DrawLine("Ry", i - 1, rty, i + 1, rty, Colors.Cyan);

                ChartObjects.DrawLine("EMA" + Pex, Pex - 1, V[Pex - 1], Pex, V[Pex], EmaC, 2);

            }

            //--------------------------------------------------------HA/MMA/PFX Fin

            ///HeikinAshi & Chandeliers FIN

            var HAvalx = Math.Max(_xClose[i], _xOpen[i]) - Math.Min(_xClose[i], _xOpen[i]);
            HAval = (_xClose[i] > _xOpen[i]) ? 100 * (HAvalx / HAvaly) : -(100 * (HAvalx / HAvaly));

            tdn5 = (color == Cg) ? "Buy" : (color == Cdg) ? "Wait on Buy" : (color == Cr) ? "Sell" : (color == Cdr) ? "Wait on Sell" : "Wait";

            ///Point et Figure FIN

            var Colorsb = (actlast > actnow) ? Cr : Cg;
            var Colors2 = (actlast < actnow) ? Cr : Cg;
            var Colors3 = Colorsb;
            var Colors4 = Colors2;
            var Colors5 = Colorsb;

            bdcolor1 = (Math.Max(dir, -dir) >= Math.Max(di4, -di4)) ? Colorsb : Co;
            var bdcolor2 = (Math.Max(di4, -di4) >= Math.Max(di3, -di3)) ? Colors2 : Co;
            var bdcolor3 = (Math.Max(di3, -di3) >= Math.Max(di2, -di2)) ? Colors3 : Co;
            var bdcolor4 = (Math.Max(di2, -di2) >= Math.Max(di1, -di1)) ? Colors4 : Co;

            var mx = Math.Max(Math.Max(Math.Max(di1, di2), Math.Max(di3, di4)), dir);
            var my = Math.Min(Math.Min(Math.Min(di1, di2), Math.Min(di3, di4)), dir);
            var div = Math.Max(mx, -my);
            var btx = (((MarketSeries.High.Maximum(Pe) - MarketSeries.Low.Minimum(Pe)) / 4) / Symbol.PipSize) / div;

            var fpfx = Math.Max(Math.Max(Math.Max(Math.Max(dir, -dir), Math.Max(di1, -di1)), Math.Max(Math.Max(di2, -di2), Math.Max(di3, -di3))), Math.Max(di4, -di4));
            var fpfy = Math.Min(Math.Min(Math.Min(Math.Max(dir, -dir), Math.Max(di1, -di1)), Math.Min(Math.Max(di2, -di2), Math.Max(di3, -di3))), Math.Max(di4, -di4));
            var fpfmax = fpfx - fpfy;
            var fpfpc = (dir > 0) ? 100 * ((dir - fpfy) / fpfmax) : -(100 * (((-dir) - fpfy) / fpfmax));

            tdn4 = (bdcolor1 == Cg) ? "Buy" : (bdcolor1 == Cr) ? "Sell" : "Wait";

            ///EXMA

            EmaCx = (tdn6 == "Buy") ? Cg : (tdn6 == "Sell") ? Cr : Co;

            //Création des textes bis

            ChartObjects.DrawText("Tdnha", "\n\n\n\nHeikinAshi: " + tdn5, StaticPosition.TopLeft, color);
            ChartObjects.DrawText("HAvx", "\n\n\n\n\nHA: " + Convert.ToString(Math.Round(LHAval, 2)) + " / " + Convert.ToString(Math.Round(HAval, 2)) + " %", StaticPosition.TopLeft, color);

            ChartObjects.DrawText("Tdnpf", "Point & Figure: " + tdn4, StaticPosition.TopLeft, bdcolor1);
            ChartObjects.DrawText("pxf5", "\n" + Convert.ToString(Math.Round(di1, 0)), StaticPosition.TopLeft, Colors5);
            ChartObjects.DrawText("pxf4", "\n        " + Convert.ToString(Math.Round(di2, 0)), StaticPosition.TopLeft, bdcolor4);
            ChartObjects.DrawText("pxf3", "\n                " + Convert.ToString(Math.Round(di3, 0)), StaticPosition.TopLeft, bdcolor3);
            ChartObjects.DrawText("pxf2", "\n                        " + Convert.ToString(Math.Round(di4, 0)), StaticPosition.TopLeft, bdcolor2);
            ChartObjects.DrawText("pxf1", "\n                                " + Convert.ToString(Math.Round(dir, 0)), StaticPosition.TopLeft, bdcolor1);
            ChartObjects.DrawText("fpfperc", "\n\nP&F: " + Convert.ToString(Math.Round(fpfpc, 2)) + " %", StaticPosition.TopLeft, bdcolor1);

            ChartObjects.DrawText("Tdnema", "\n\n\n\n\n\n\nEXMA: " + tdn6, StaticPosition.TopLeft, EmaCx);

            //--------------------------------------------------------Calcul Tvol

            if (vvol == true)
            {
                var rxx = TFstr(MarketSeries.TimeFrame.ToString());

                double prcx = 0;
                double pipx = 0;
                double totx = 0;
                string direct = "Wait";

                for (int rx = rxx; rx <= 10; rx++)
                {
                    var TFx = TTF(rx);
                    var _MS = MarketData.GetSeries(TFx);
                    var open = _MS.Open.LastValue;
                    var close = MarketSeries.Close.LastValue;
                    var high = _MS.High.LastValue;
                    var low = _MS.Low.LastValue;
                    var median = _MS.Median.LastValue;
                    var lopen = _MS.Open.Last(1);
                    var lclose = _MS.Close.Last(1);
                    var llopen = _MS.Open.Last(2);
                    var llclose = _MS.Close.Last(2);
                    var stade1 = (lclose > lopen) ? lclose - ((Math.Max(lclose, lopen) - Math.Min(lclose, lopen)) / 3) : lclose + ((Math.Max(lclose, lopen) - Math.Min(lclose, lopen)) / 3);
                    var stade2 = (lclose > lopen) ? lclose - (((Math.Max(lclose, lopen) - Math.Min(lclose, lopen)) / 3) * 2) : lclose + (((Math.Max(lclose, lopen) - Math.Min(lclose, lopen)) / 3) * 2);
                    direct = ((lclose >= lopen && close > lclose) || (lclose <= lopen && close >= lopen)) ? "Buy" : ((lclose >= lopen && close <= lclose && close > stade1) || (lclose <= lopen && close >= stade2 && close < lopen)) ? "Wait Buy" : ((lclose >= lopen && close <= stade2 && close > lopen) || (lclose <= lopen && close >= lclose && close < stade1)) ? "Wait Sell" : ((lclose >= lopen && close <= lopen) || (lclose <= lopen && close < lclose)) ? "Sell" : "Wait";
                    prcx = Math.Round(((Math.Max(open, close) - Math.Min(open, close)) / Math.Max(open, close)) * 100, 2);
                    pipx = Math.Round((Math.Max(open, close) - Math.Min(open, close)) / Symbol.PipSize, 0);
                    var pip = (close > open) ? pipx : -pipx;
                    totx = (close > open) ? Math.Round((high - open) / Symbol.PipSize, 0) : Math.Round((open - low) / Symbol.PipSize, 0);
                    var tot = Math.Round((pipx / totx) * 100, 0);
                    var Color = (direct == "Buy") ? Colors.YellowGreen : (direct == "Wait Buy") ? Colors.DarkGreen : (direct == "Sell") ? Colors.Red : (direct == "Wait Sell") ? Colors.DarkRed : Colors.Orange;
                    char rpl = '\n';
                    var rpu = rx;
                    var rll = new string(rpl, rpu);
                    var sbl = TTS(rx);

                    var xhlx = ((high - low) * 3) / 2;
                    var xmxh = ((high + low) / 2) + (((high - low) / 100) * 33);
                    var xmxl = ((high + low) / 2) - (((high - low) / 100) * 33);
                    var xex = 3 * (Math.Max(open, close) - Math.Min(open, close));
                    var xey = 3 * (Math.Max(lopen, lclose) - Math.Min(lopen, lclose));
                    var Dojix = ((open == close && open >= xmxh) || (open == close && open <= xmxl)) ? true : false;
                    var Englx = ((Math.Max(open, close) > Math.Max(lopen, lclose) && Math.Min(open, close) < Math.Min(lopen, lclose)) || (Math.Max(open, close) > Math.Max(llopen, llclose) && Math.Min(open, close) < Math.Min(llopen, llclose))) ? true : false;
                    var FGapsx = ((open < close && lopen < lclose && lclose < open && Englx == false) || (open > close && lopen > lclose && lclose > open && Englx == false)) ? true : false;
                    var Hamax = (xex < (xey / 2) && Math.Max(open, close) < Math.Max(lopen, lclose) && Math.Min(open, close) > Math.Min(lopen, lclose)) ? true : false;

                    var LongChand = (Dojix == true && open < median) ? "DOJI ▼" : (Englx == true && open > close) ? "ENGLOBANTE ▼" : (FGapsx == true && open > close) ? "GAPS ▼" : (Hamax == true && open > close && lopen < lclose) ? "HAMARI ▼" : (Dojix == true && open > median) ? "DOJI ▲" : (Englx == true && open < close) ? "ENGLOBANTE ▲" : (FGapsx == true && open < close) ? "GAPS ▲" : (Hamax == true && open < close && lopen > lclose) ? "HAMARI ▲" : "";

                    ChartObjects.DrawText("Time" + rx, rll + LongChand + " (" + Convert.ToString(tot) + "%) " + sbl, StaticPosition.TopRight, Color);
                }
            }

            //--------------------------------------------------------Calcul position

            if (vpos == true)
            {
                var _posbuy = Positions.Find("TriForce" + Symbol.Code, Symbol, TradeType.Buy);
                var _possell = Positions.Find("TriForce" + Symbol.Code, Symbol, TradeType.Sell);

                Colors PosColor;
                Colors pColor;

                double netprofitpos = Symbol.PipSize;
                double netpippos = Symbol.PipSize;
                double pospipmax = 0;
                int posc = 0;

                PosColor = (Account.UnrealizedNetProfit > 0) ? Cg : (Account.UnrealizedNetProfit < 0) ? Cr : Co;

                var postype = (_posbuy == null && _possell == null) ? "En attente: " : (_posbuy == null && _possell != null) ? "Vente en cours: " : (_posbuy != null && _possell == null) ? "Achat en cours: " : "Multipositions: ";

                var lslb = stoplossBuy;
                var lsls = stoplossSell;

                stoplossBuy = (_posbuy == null) ? C - ((MarketSeries.High.Maximum(PeR) - MarketSeries.Low.Minimum(PeR)) / 2) : lslb;
                stoplossSell = (_possell == null) ? C + ((MarketSeries.High.Maximum(PeR) - MarketSeries.Low.Minimum(PeR)) / 2) : lsls;

                foreach (var _pos in Positions)
                {
                    var lposc = posc;
                    var lnetpippos = netpippos;
                    var lpospipmax = pospipmax;
                    var lpospipmaxsell = pospipmax;
                    double profit = 0;
                    double onpip = 0;
                    double startline = 0;

                    if (_pos.Label == "TriForce" + Symbol.Code)
                    {
                        posc = lposc + 1;
                        profit = _pos.NetProfit;
                        onpip = _pos.Pips;
                        startline = _pos.EntryPrice;
                    }

                    pColor = (_pos.TradeType == TradeType.Buy && profit > 0) ? Cg : (_pos.TradeType == TradeType.Sell && profit > 0) ? Cr : Co;
                    pospipmax = (_pos.Pips > lpospipmax) ? _pos.Pips : lpospipmax;

                    ChartObjects.DrawLine(Convert.ToString(_pos.EntryPrice), MarketSeries.OpenTime.GetIndexByTime(_pos.EntryTime), startline, i, C, pColor, 2);
                }

                var Cap = (posc == 0 || posc == 1) ? 2 : CalcCap(posc);
                var pipBuy = Convert.ToInt32((Math.Max(C, stoplossBuy) - Math.Min(C, stoplossBuy)) / Symbol.PipSize);
                var pipSell = Convert.ToInt32((Math.Max(C, stoplossSell) - Math.Min(C, stoplossSell)) / Symbol.PipSize);
                var mise = (Account.Balance / 100) * CRK;
                var xpipvalb = mise / (pipBuy + Symbol.Spread);
                var xpipvals = mise / (pipSell + Symbol.Spread);
                var volbasebuy = Convert.ToInt64(xpipvalb / Symbol.PipValue);
                var volbasesell = Convert.ToInt64(xpipvals / Symbol.PipValue);
                var volL = Symbol.VolumeMin;
                var volM = Symbol.VolumeMax;
                var volumexb = (volbasebuy < volL) ? volL : (volbasebuy > volM) ? volM : volbasebuy;
                var volumexs = (volbasesell < volL) ? volL : (volbasesell > volM) ? volM : volbasesell;
                var volumebuy = Convert.ToInt64(Math.Floor(Convert.ToDouble(volumexb / Symbol.VolumeMin)) * Symbol.VolumeMin);
                var volumesell = Convert.ToInt64(Math.Floor(Convert.ToDouble(volumexs / Symbol.VolumeMin)) * Symbol.VolumeMin);

                ChartObjects.DrawText("PosProfit", postype + Convert.ToString(Math.Round(Account.UnrealizedNetProfit, 2)) + " € (" + Convert.ToString(Math.Round(pospipmax, 2)) + " pip) Spread: " + Convert.ToString(Math.Round((Symbol.Ask - Symbol.Bid) / Symbol.PipSize, 2)), StaticPosition.TopCenter, PosColor);
                ChartObjects.DrawText("InfoBuy", "\nB : " + "CRK " + Convert.ToString(CRK) + "% / CAP " + Convert.ToString(Cap) + "pip / PMax " + Convert.ToString(Math.Round(mise, 2)) + "€ / PipVal " + Convert.ToString(Math.Round(volumebuy * Symbol.PipValue, 2)) + "€ / Volume " + Convert.ToString(volumebuy) + " (" + Convert.ToString(pipBuy) + ")", StaticPosition.TopCenter, PosColor);
                ChartObjects.DrawText("InfoSell", "\n\nS : " + "CRK " + Convert.ToString(CRK) + "% / CAP " + Convert.ToString(Cap) + "pip / PMax " + Convert.ToString(Math.Round(mise, 2)) + "€ / PipVal " + Convert.ToString(Math.Round(volumesell * Symbol.PipValue, 2)) + "€ / Volume " + Convert.ToString(volumesell) + " (" + Convert.ToString(pipSell) + ")", StaticPosition.TopCenter, PosColor);
            }

            //--------------------------------------------------------Calcul Fibonacci

            var _MSx = MarketData.GetSeries(LTF);
            var max = Math.Max(_MSx.High.Last(1), _MSx.High.LastValue) - ((Math.Max(_MSx.High.Last(1), _MSx.High.LastValue) - Math.Min(_MSx.Low.Last(1), _MSx.Low.LastValue)) / 3);
            var min = Math.Min(_MSx.Low.Last(1), _MSx.Low.LastValue) + ((Math.Max(_MSx.High.Last(1), _MSx.High.LastValue) - Math.Min(_MSx.Low.Last(1), _MSx.Low.LastValue)) / 3);
            var fO = _MSx.Open.Last(1);
            var nbor = 0.61803398875;

            var Pv = fO;
            var S1 = fO - ((max - min) * nbor);
            var S2 = fO - ((max - min) * (nbor * 2));
            var S3 = fO - ((max - min) * (nbor * 3));
            var S4 = fO - ((max - min) * (nbor * 4));
            var R1 = fO + ((max - min) * nbor);
            var R2 = fO + ((max - min) * (nbor * 2));
            var R3 = fO + ((max - min) * (nbor * 3));
            var R4 = fO + ((max - min) * (nbor * 4));

            var dstmax = Math.Max(fO, max) - Math.Min(fO, max);
            var dstmin = Math.Max(fO, min) - Math.Min(fO, min);

            var lastix = MarketSeries.OpenTime.GetIndexByTime(_MSx.OpenTime.Last(1));

            ChartObjects.DrawLine("R1x", lastix, R1, i, R1, Cdg, 1, LineStyle.DotsVeryRare);
            ChartObjects.DrawLine("R2x", lastix, R2, i, R2, Cdg, 1, LineStyle.DotsVeryRare);
            ChartObjects.DrawLine("R3x", lastix, R3, i, R3, Cg, 1, LineStyle.DotsVeryRare);
            ChartObjects.DrawLine("R4x", lastix, R4, i, R4, Cg, 1, LineStyle.DotsVeryRare);

            ChartObjects.DrawLine("Pvx", lastix, Pv, i, Pv, Co, 1, LineStyle.DotsVeryRare);

            ChartObjects.DrawLine("S1x", lastix, S1, i, S1, Cdr, 1, LineStyle.DotsVeryRare);
            ChartObjects.DrawLine("S2x", lastix, S2, i, S2, Cdr, 1, LineStyle.DotsVeryRare);
            ChartObjects.DrawLine("S3x", lastix, S3, i, S3, Cr, 1, LineStyle.DotsVeryRare);
            ChartObjects.DrawLine("S4x", lastix, S4, i, S4, Cr, 1, LineStyle.DotsVeryRare);

            //--------------------------------------------------------Calcul Alerte (MODIFIER)

            //if (nbring == 0)
            //{
            //for (int rt = 0; rt <= 3; rt++)
            //{
            //Notifications.PlaySound("C:\\302.wav");
            //}
            //nbring = 1;
            //}
        }

        public int TFstr(string TFs)
        {
            switch (TFs)
            {
                case "Minute1":
                case "Minute2":
                case "Minute3":
                case "Minute4":
                    return 1;
                    break;
                case "Minute5":
                case "Minute6":
                case "Minute7":
                case "Minute8":
                case "Minute9":
                case "Minute10":
                    return 2;
                    break;
                case "Minute15":
                case "Minute20":
                    return 3;
                    break;
                case "Minute30":
                case "Minute45":
                    return 4;
                    break;
                case "Hour":
                    return 5;
                    break;
                case "Hour2":
                case "Hour3":
                    return 6;
                    break;
                case "Hour4":
                case "Hour6":
                case "Hour8":
                    return 7;
                    break;
                case "Hour12":
                    return 8;
                    break;
                case "Daily":
                case "Day2":
                case "Day3":
                    return 9;
                    break;
                case "Weekly":
                    return 10;
                    break;
                default:
                    return 1;
                    break;
            }
        }

        public TimeFrame TTF(int rz)
        {
            switch (rz)
            {
                case 1:
                    return TimeFrame.Minute5;
                    break;
                case 2:
                    return TimeFrame.Minute15;
                    break;
                case 3:
                    return TimeFrame.Minute30;
                    break;
                case 4:
                    return TimeFrame.Hour;
                    break;
                case 5:
                    return TimeFrame.Hour2;
                    break;
                case 6:
                    return TimeFrame.Hour4;
                    break;
                case 7:
                    return TimeFrame.Hour12;
                    break;
                case 8:
                    return TimeFrame.Daily;
                    break;
                case 9:
                    return TimeFrame.Weekly;
                    break;
                case 10:
                    return TimeFrame.Monthly;
                    break;
                default:
                    return TimeFrame.Minute;
                    break;
            }
        }

        public string TTS(int rz)
        {
            switch (rz)
            {
                case 1:
                    return "m5";
                    break;
                case 2:
                    return "m15";
                    break;
                case 3:
                    return "m30";
                    break;
                case 4:
                    return "h1";
                    break;
                case 5:
                    return "h2";
                    break;
                case 6:
                    return "h4";
                    break;
                case 7:
                    return "h12";
                    break;
                case 8:
                    return "D1";
                    break;
                case 9:
                    return "WE";
                    break;
                case 10:
                    return "MO";
                    break;
                default:
                    return "m1";
                    break;
            }
        }

        private int CalcCap(int posCount)
        {
            var Cappos2 = 2;
            var Cappos3 = Cappos2 + (Cappos2 * 2);
            var Cappos4 = Cappos3 + (Cappos2 * 3);
            var Cappos5 = Cappos4 + (Cappos2 * 4);
            var Cappos6 = Cappos5 + (Cappos2 * 5);
            var Cappos7 = Cappos6 + (Cappos2 * 6);
            var Cappos8 = Cappos7 + (Cappos2 * 7);
            var Cappos9 = Cappos8 + (Cappos2 * 8);
            var Cappos10 = Cappos9 + (Cappos2 * 9);
            var Cappos11 = Cappos10 + (Cappos2 * 10);

            switch (posCount)
            {
                case 1:
                    return Cappos2;
                    break;
                case 2:
                    return Cappos3;
                    break;
                case 3:
                    return Cappos4;
                    break;
                case 4:
                    return Cappos5;
                    break;
                case 5:
                    return Cappos6;
                    break;
                case 6:
                    return Cappos7;
                    break;
                case 7:
                    return Cappos8;
                    break;
                case 8:
                    return Cappos9;
                    break;
                case 9:
                    return Cappos10;
                    break;
                case 10:
                    return Cappos11;
                    break;
                default:
                    return Cappos11;
                    break;
            }
        }
    }
}
Comments

galafrin - August 12, 2016 @ 20:41

Merci pour le partage du code Ludohoebi.

ludohoebi - October 23, 2016 @ 12:13

"500 Internal Server Error". Indicator not updated :$ I wait few hour sry

ludohoebi - October 28, 2016 @ 20:01

I wait for resolve the problem. You can download the file here (v3.3!): https://mon-partage.fr/f/eF7vdjvM/

jumpsolid - November 08, 2016 @ 16:53

Il est vraiment genial ce Ludohoebi :)

 

Amazingly good :)

ludohoebi - November 12, 2016 @ 19:47

Merci, malheureusement, difficile de faire avec cette erreur 500. Les francophones peuvent toutefois se diriger ici:

https://www.forexagone.com/forum/strategies-trading/hoebi-et-mes-idees-19464#106232

Bien que se soit toujours la version 3.3 de disponible, vous pouvez avoir un aperçu sur les derniers changements. V4.2 pour le moment. Je la mettrai à la disposition d'ici quelques semaines je pense ;)

5