Script Indicator (C#)

HTS's Script Indicator is a custom Indicator for the Trade Bot. This feature allows you to create and share your own indicators. 
Check out Pshai's scripts for a set of pre-made custom indicators for use with your custom bot.
Pshai Scripts (C#)
Developer Center
Supported license & Trade types
Supported License
Supported Trade Types
​
Spot trading
Simple license
Margin trading
Advanced license
Leverage trading
Settings
The Script Indicator has only one setting: the full path to the script.
Language
The scripts are C#-scripts, using the CS-Script CLR.
Interface
All indicator scripts must fully implement the IndicatorScript-interface:
1
    public interface IIndicatorScript
2
    {
3
        string Name { get; }
4
        int TicksBack { get; }
5
        void Init();
6
        IndicatorResult GetResult(IndicatorContext context);
7
        List<ChartRecord> GetChartLines();
8
        List<decimal> GetChartData();
9
        List<ScriptParameter> GetParameters();
10
        void SetParameters(Dictionary<string,object> parameters);
11
    }
Copied!
Name
This property returns the name of the indicator. Haasbot will use this name for the indicator, instead of the general "Script Indicator", so it is clear for the user which script is being used.
1
    string Name { get { return "My Indicator"; } }
Copied!
TicksBack
With this property you can configure how much price data (Bid, Ask, High, Low, Volume) must be kept in memory by the IndicatorContext. Make sure this is big enough to have enough data to do the necessary calculations in your script, while keeping it small enough to reduce memory usage and unnecessary CPU load when doing these calculations.
1
    using TicTacTec.TA.Library;
2
    // ...
3
    int TicksBack { get { return Core.SmaLookback(sma_length); } }
Copied!
Init
This method is executed after creating the script-object the first time. You can use this to do any necessary initialization. The created script-object will stay in memory and will be used until the script is recompiled. An indicator-script is recompiled when Haasbot starts and when the Script Indicator settings-window is closed.
GetResult
This method will be executed every time Haasbot checks the indicator. It should return an IndicatorResult (Stay, Buy or Sell). An IndicatorContext-object is passed, containing current price details and a reference to the IndicatorAPI, giving access to historical price data for all supported platforms and currency pairs. The default behavior of this method is to always return Stay.
GetChartLines
GetChartLines is a property defining the chart lines which will be shown on the indicator chart. This property has to return a list of ChartRecord-objects, which define the properties of one chart line. For each line in the chart, you have to define a name, on which chart it has to be shown (0 on main chart - 1,2 and 3 will create their own charts) and optionally a color. When no color is defined, Haasbot assigns a color automatically. For an example, see lines 65 to 76 in the example script. 
GetChartData
This method returns the data points which have to be shown in the chart(s). It should return a list of decimal's, in the same order as the ChartRecords returned by the GetChartLines-property. The length of the list returned by the GetChartLines-property should be the same length as the list returned by GetChartData. This method is called after calling GetResult(), so if any chart data is generated in the GetResult-method, you can store it in a class member, and return it in GetChartData to be shown on the indicator chart.GetParametersThis method returns the parameters the user can configure for this script. It should return a list ScriptParameter objects. These ScriptParameter objects define for each parameter the name, current value, type and optionally some info text shown to the user. The user will be able to configure these parameters in the Haasbot user interface. The current value has to be cast into string.
1
    List<ScriptParameter> GetParameters()
2
    {
3
        return new List<ScriptParameter>
4
            {
5
                new ScriptParameter("SMA Length", ScriptParameterType.Integer, sma_length.ToString()),
6
                new ScriptParameter("A Useless Decimal", ScriptParameterType.Decimal, (123.456M).ToString()),
7
                new ScriptParameter("Foo", ScriptParameterType.String, "Bar")
8
            }
9
    }
Copied!
SetParameters
This method is called when the script parameters are modified in the Haasbot user interface. The argument is a dictionary with the parameter names as dictionary-keys, and the parameter values as dictionary-values. The type of the values is object, so you need to cast them to the correct type (the same type as you defined in the ScriptParameter in GetParameters). When only specific values or range of values is valid for a certain parameter, you can do the checks here and revert to the previous value if an invalid value was set by the user.After SetParameters is called, the name of the script (the Name-property) is retrieved again. This way, when parameters are used in the name, the name is updated when the parameters are updated.
1
    void SetParameters(Dictionary<string, object> parameters)
2
    {
3
        sma_length = Convert.ToInt32( parameters["SMA Length"] );
4
    }
Copied!
TA-Lib
In an indicator script you have access to TA-Lib for calculating any technical analysis indicators. All functions are static members of the static class Core in the namespace TicTacTec.TA.Library. It is not necessary to include external references to use TA-Lib, but having them allows the of your IDEs intellisense.
​​
​​
The PriceInstrument property in the IndicatorContext contains multiple arrays of doubles (Asks, Bids, High, Low, Volume), which can directly be used as input for the TA-Lib-functions.
Creating classes
You can define your own classes and structs in a script. You only have to make sure the class implementing the IIndicatorScript-interface is the first class in the file.
Debugging
Writing to log-file
You can write debug-info to a log file, by calling Logger.LogToFile(message) on the IndicatorContext-object. The message will be written (together with a timestamp) to a log-file. The log-file has the name of the script and is located at the Haasbot execution path.
Step-by-step debugging
Coming soon
Example script
1
// The reference files (found in Haasbot installation folder):
2
//  - TradeServer.ScriptingDriver.dll
3
//  - TradeServer.Interfaces.dll
4
//  - TA-Lib-Core.dll
5
using TradeServer.ScriptingDriver.DataObjects;
6
using TradeServer.ScriptingDriver.Interfaces;
7
using TicTacTec.TA.Library;
8
using System.Collections.Generic;
9
using System.Text;
10
using System.Linq;
11
using System;
12
 
13
public class ExampleScript : IIndicatorScript
14
{
15
    //Data to be shown in the indicator-chart:
16
    private double buyPrice;
17
    private double emaShort;
18
    private double emaLong;
19
 
20
    //Parameters:
21
    private int emaShortLength = 7;
22
    private int emaLongLength = 30;
23
 
24
    public string Name
25
    {
26
        get{ return string.Format("Script: EMA {0}-{1}", emaShortLength, emaLongLength); }
27
    }
28
 
29
 
30
    public int TicksBack
31
    {
32
        get { return Core.EmaLookback(emaLongLength) + 1; }
33
    }
34
 
35
    public List<ScriptParameter> GetParameters()
36
    {
37
        return new List<ScriptParameter>(){
38
            new ScriptParameter(){Name = "EMA short length", 
39
                                  Type = ScriptParameterType.Integer, 
40
                                  Value = emaShortLength.ToString(),
41
                                  Info = "The length of the shorter/faster EMA."},
42
            new ScriptParameter(){Name = "EMA long length", Type = ScriptParameterType.Integer, Value = emaLongLength.ToString()}
43
        };
44
    }
45
 
46
    public void SetParameters(Dictionary<string, object> parameters)
47
    {
48
        emaShortLength = Convert.ToInt32(parameters["EMA short length"]);
49
        emaLongLength = Convert.ToInt32(parameters["EMA long length"]);
50
    }
51
 
52
 
53
 
54
    public IndicatorResult GetResult(IndicatorContext context)
55
    {
56
        PriceInstrument instrument = context.PriceInstrument;
57
        int dataCount = instrument.Close.Length;
58
 
59
        int beginIndexShort, outNBElementsShort;
60
        int beginIndexLong, outNBElementsLong;
61
        double[] emaShortValues = new double[dataCount];
62
        double[] emaLongValues = new double[dataCount];
63
 
64
        var emaShortReturnCode = Core.Ema(0, dataCount - 1, instrument.Close, emaShortLength, out beginIndexShort, out outNBElementsShort, emaShortValues);
65
        var emaLongReturnCode = Core.Ema(0, dataCount - 1, instrument.Close, emaLongLength, out beginIndexLong, out outNBElementsLong, emaLongValues);
66
 
67
        if (emaShortReturnCode == Core.RetCode.Success && emaLongReturnCode == Core.RetCode.Success){    
68
 
69
            buyPrice = instrument.Close[dataCount - 1]; //Take current (last) value
70
 
71
            if(outNBElementsShort == 0 || outNBElementsLong == 0){
72
                // Something went wrong
73
                emaShort = buyPrice;
74
                emaLong = buyPrice;
75
                return IndicatorResult.Stay;
76
            }else{
77
                emaShort = emaShortValues[outNBElementsShort - 1]; //Take current EMA (last one of the valid values)
78
                emaLong = emaLongValues[outNBElementsLong - 1]; //Take current EMA (last one of the valid values)
79
 
80
                context.Logger.LogToFile("EMA Short: " + emaShort + "\tEMA Long:" + emaLong); //Log to file
81
 
82
                //Determine indicator signal
83
                if(emaShort > emaLong)
84
                    return IndicatorResult.Buy;
85
                else if(emaLong > emaShort)
86
                    return IndicatorResult.Sell;
87
                else
88
                    return IndicatorResult.Stay;
89
            }
90
        }else{
91
            context.Logger.LogToFile("EMA calculation failed."); //Log to file
92
            return IndicatorResult.Stay;
93
        }
94
    }
95
 
96
    public List<ChartRecord> GetChartLines()
97
    {
98
        return new List<ChartRecord>()
99
        {
100
            new ChartRecord(ChartIndex = 1, Name = "Buy Price", HexLineColor = "#00FF00"),
101
            new DataSerie(Name = "EMA Short", ChartIndex = 1, HexLineColor = "#FF0000"),
102
            new DataSerie(Name = "EMA Long", ChartIndex = 1, HexLineColor = "#FFFF00")
103
        };
104
    }
105
 
106
    public List<double> GetChartData()
107
    {
108
            return new List<double>()
109
            {
110
                buyPrice,
111
                emaShort,
112
                emaLong
113
            };
114
    }
115
}
Copied!