View difference between Paste ID: zJNUMNnJ and jE12AWvP

 #######################
 ### TRENDATRON 5000 ###
 #######################
 
 ### INTRO
 https://cryptotrader.org/strategies/peKY35zY2Z2G56rLi
 by aspiramedia (https://cryptotrader.org/aspiramedia)
 
 Please PM me with any updates, feedback, bugs, suggestions, criticism etc.
 Please leave this header intact, adding your own comments in EDITOR'S COMMENTS.
 Edited bots are NOT for submission into the CryptoTrader.org Strategies section.
 ###
 
 ### EDITOR'S COMMENTS
 Made any edits? Why not explain here.
 ###
 
 ### DONATIONS
 I am releasing this as a donation based bot. I am releasing this in hope of obtaining some donations from users here.
 Please donate BTC to: 1GGZU5mAUSLxVDegdxjakTLqZy7zizRH74
 ###
 
 ### DISCLAIMER
 As usual with all trading, only trade with what you are able to lose.
 Start small.
 I am NOT responsible for your losses if any occur.
 ###
 
 ### CREDITS
 The VIX and Swing indicators used here were originally by Chris Moody at TradingView.
 Trading logic is my own.
 Thanks to all at Cryptotrader.org that helped me along the way.
 ###
 
 ### ADVICE
 Rather than just trading with this, I strongly recommend making this bot your own.
 Use it as a learning tool.
 Edit it to trade as you like to match your strategy.
 View this as a template for a long term trend trader with added scalping.
 Backtesting is your friend. Backtest over long periods to identify strengths and weaknesses.
 ###
 
 
 ############
 ### CODE ###
 ############
 
 STOP_LOSS = askParam 'Use a Stop Loss?', false
 STOP_LOSS_PERCENTAGE = askParam 'If so, Stop Loss Percentage?', 5
 SCALP = askParam 'Use Scalping?', true
 SPLIT = askParam 'Split orders up?', false
 SPLIT_AMOUNT = askParam 'If so, split into how many?', 4
 PERIOD = askParam 'Trend reaction time (Max = 250 | Min = 50 | Default = 250 )', 250
 
 class VIX
     constructor: (@period) ->
         @close = []
         @wvf = []
         @trade = []
         @count = 0
 
         # INITIALIZE ARRAYS
         for [@close.length..22]
             @close.push 0
         for [@wvf.length..@period]
             @wvf.push 0
         for [@trade.length..10]
             @trade.push 0
 
     calculate: (instrument) ->
 
         close = instrument.close[instrument.close.length-1]
         high = instrument.high[instrument.high.length-1]
         low = instrument.low[instrument.low.length-1]
 
 
         # INCREASE DATA COUNT
         @count++
 
         # REMOVE OLD DATA
         @close.pop()
         @wvf.pop()
         @trade.pop()
 
         # ADD NEW DATA
         @close.unshift(0)
         @wvf.unshift(0)
         @trade.unshift(0)
 
         # CALCULATE
         @close[0] = close
 
         highest = (@close.reduce (a,b) -> Math.max a, b)
 
         @wvf[0] = ((highest - low) / (highest)) * 100
 
         sdev = talib.STDDEV
             inReal: @wvf
             startIdx: 0
             endIdx: @wvf.length-1
             optInTimePeriod: @period
             optInNbDev: 1
         sdev = sdev[sdev.length-1]
 
         midline = talib.SMA
             inReal: @wvf
             startIdx: 0
             endIdx: @wvf.length-1
             optInTimePeriod: @period
         midline = midline[midline.length-1]
 
         lowerband = midline - sdev
         upperband = midline + sdev
 
         rangehigh = (@wvf.reduce (a,b) -> Math.max a, b) * 0.85
         rangelow = (@wvf.reduce (a,b) -> Math.min a, b) * 1.01
 
         if @wvf[0] >= upperband or @wvf[0] >= rangehigh
             @trade[0] = 0
             plotMark
                 "wvf1": @wvf[0]
         else
             @trade[0] = 1
             plotMark
                 "wvf2": @wvf[0]
 
 
         # RETURN DATA
         result =
             wvf: @wvf[0]
             rangehigh: rangehigh
             rangelow: rangelow
             trade: @trade
 
         return result
 
 class GANNSWING
     constructor: (@period) ->
         @count = 0
         @buycount = 0
         @sellcount = 0
         @lowma = []
         @highma = []
 
         # INITIALIZE ARRAYS
         for [@lowma.length..5]
             @lowma.push 0
         for [@highma.length..5]
             @highma.push 0
 
     calculate: (instrument) ->
 
         close = instrument.close[instrument.close.length-1]
         high = instrument.high[instrument.high.length-1]
         low = instrument.low[instrument.low.length-1]
 
         # REMOVE OLD DATA
         @lowma.pop()
         @highma.pop()
 
         # ADD NEW DATA
         @lowma.unshift(0)
         @highma.unshift(0)
 
         # CALCULATE
         highma = talib.SMA
             inReal: instrument.high
             startIdx: 0
             endIdx: instrument.high.length-1
             optInTimePeriod: @period
         @highma[0] = highma[highma.length-1]
 
         lowma = talib.SMA
             inReal: instrument.low
             startIdx: 0
             endIdx: instrument.low.length-1
             optInTimePeriod: @period
         @lowma[0] = lowma[lowma.length-1]
 
         if close > @highma[1]
             hld = 1
         else if close < @lowma[1]
             hld = -1
         else
             hld = 0
 
         if hld != 0
             @count++
 
         if hld != 0 && @count == 1
             hlv = hld
             @count = 0
         else
             hlv = 0
 
         if hlv == -1
             hi = @highma[0]
             plotMark
                 "hi": hi * 1.01
             @sellcount++
             @buycount = 0
 
         if hlv == 1
             lo = @lowma[0]
             plotMark
                 "lo": lo / 1.01
             @buycount++
             @sellcount = 0
 
         if @buycount == 3
             tradebuy = true
             @buycount = 0
         else
             tradebuy = false
 
 
         if @sellcount == 3
             tradesell = true
             @sellcount = 0
         else
             tradesell = false
 
 
         # RETURN DATA
         result =
             tradesell: tradesell
             tradebuy: tradebuy
 
         return result
 
 class FUNCTIONS
 
     @ROUND_DOWN: (value, places) ->
         offset = Math.pow(10, places)
         return Math.floor(value*offset)/offset
 
 class TRADE
 
     @BUY: (instrument, amount, split, timeout) ->
         price = instrument.price * 1.01
 
         if split > 0
             amount = FUNCTIONS.ROUND_DOWN((portfolio.positions[instrument.curr()].amount/split)/price, 8)
             for [0..split]
                 buy(instrument, amount, price, timeout)
         else
             buy(instrument, null, price, timeout)
 
     @SELL: (instrument, amount, split, timeout) ->
         price = instrument.price * 0.99
 
         if split > 0
             amount = FUNCTIONS.ROUND_DOWN(portfolio.positions[instrument.asset()].amount/split, 8)
             for [0..split]
                 sell(instrument, amount, price, timeout)
         else
             sell(instrument, amount, price, timeout)
 
 init: (context)->
 
     context.vix = new VIX(20)               # Period of stddev and midline
     context.swing = new GANNSWING(PERIOD)   # Period of highma and lowma
 
     # FOR FINALISE STATS
     context.balance_curr = 0
     context.balance_btc = 0
     context.price = 0
 
     # TRADING
     if SPLIT
         context.trade_split = SPLIT_AMOUNT
     else
         context.trade_split = 0
     context.trade_timeout   = 3000
 
     # LOGGING
     context.TICK = 0
     context.balance_curr_start = 0
     context.balance_btc_start = 0
     context.price_start = 0
 
     # WELCOME
     info "###"
     info "Welcome to the Trendatron Bot."
     info "Thanks for choosing this free bot. As many hours have gone into its creation, please consider a donation to:"
     info "BTC: 1GGZU5mAUSLxVDegdxjakTLqZy7zizRH74"
     info "(The bot carries on regardless of donations - don't worry. And if you have donated then thank you.)"
     if STOP_LOSS == true
         info "You chose to use a Stop Loss, with a cutoff of " + STOP_LOSS_PERCENTAGE + " percent."
     if SCALP == true
         info "You chose to use scalping (default bot behaviour)"
     if SPLIT == true
         info "You chose to split orders up into " + SPLIT_AMOUNT + " orders."
 
     info "###"
 
 
 
 
 handle: (context, data, storage)->
 
     instrument = data.instruments[0]
     price = instrument.close[instrument.close.length - 1]
     storage.lastBuyPrice ?= 0
 
     # FOR FINALISE STATS
     context.price = instrument.close[instrument.close.length - 1]
     context.balance_curr = portfolio.positions[instrument.curr()].amount
     context.balance_btc = portfolio.positions[instrument.asset()].amount
 
     # CALLING INDICATORS
     vix = context.vix.calculate(instrument)
     wvf = vix.wvf
     rangehigh = vix.rangehigh
     rangelow = vix.rangelow
     trade = vix.trade
 
     swing = context.swing.calculate(instrument)
     tradesell = swing.tradesell
     tradebuy = swing.tradebuy
 
 
     # TRADING
     if context.balance_curr/price > 0.01
         if tradebuy == true
             if TRADE.BUY(instrument, null, context.trade_split, context.trade_timeout)
                 storage.lastBuyPrice = price
                 storage.stop = true
                 info "#########"
                 info "Trend Buy"
                 info "#########"
 
     if context.balance_curr/price > 0.01 && SCALP == true
         if trade[0] == 1 && trade[1] == 1 && trade[2] == 0 && trade[3] == 0 && trade[4] == 0 && trade[5] == 0 && wvf > 8.5
             if TRADE.BUY(instrument, null, context.trade_split, context.trade_timeout)
                 storage.lastBuyPrice = price
                 storage.stop = true
                 info "#########"
                 info "Scalp Buy"
                 info "#########"
 
     if context.balance_btc > 0.01
         if (tradesell == true && wvf < 2.85) or (tradebuy == true && wvf > 8.5 && trade[0] == 1 && trade[1] == 0)
             if TRADE.SELL(instrument, null, context.trade_split, context.trade_timeout)
                 storage.lastBuyPrice = 0
                 storage.lastSellPrice = price
                 storage.stop = false
                 warn "##########"
                 warn "Trend Sell"
                 warn "##########"
 
     # STOP LOSS
     if STOP_LOSS
         if storage.stop == true && price < storage.lastBuyPrice * (1 - (STOP_LOSS_PERCENTAGE / 100))
             if TRADE.SELL(instrument, null, context.trade_split, context.trade_timeout)
                 storage.lastBuyPrice = 0
                 storage.lastSellPrice = price
                 storage.stop = false
                 warn "##############"
                 warn "Stop Loss Sell"
                 warn "##############"
 
     # PLOTTING / DEBUG
     plot
         wvf: wvf
         rangehigh: rangehigh
         rangelow: rangelow
         normaliser: 25
     setPlotOptions
         wvf:
             secondary: true
         rangehigh:
             secondary: true
         rangelow:
             secondary: true
         wvf1:
             secondary: true
             color: 'blue'
         wvf2:
             secondary: true
             color: 'black'
         lo:
             color: 'green'
         hi:
             color: 'red'
         normaliser:
             secondary: true
             color: '#fffdf6'
 
     # LOGGING
 
     if context.TICK == 0
         context.balance_curr_start = portfolio.positions[instrument.curr()].amount
         context.balance_btc_start = portfolio.positions[instrument.asset()].amount
         context.price_start = price
 
     starting_btc_equiv = context.balance_btc_start + context.balance_curr_start / context.price_start
     current_btc_equiv = context.balance_btc + context.balance_curr / price
     efficiency = Math.round((current_btc_equiv / starting_btc_equiv) * 1000) / 1000
     efficiency_percent = Math.round((((current_btc_equiv / starting_btc_equiv) - 1) * 100) * 100) / 100
 
 
 
     context.TICK++
     if Math.round(context.TICK/24) == (context.TICK/24)
         warn "### Day " + context.TICK/24 + " Log"
         debug "Current Fiat: " + Math.round(context.balance_curr*100)/100 + " | Current BTC: " +  Math.round(context.balance_btc*100)/100
         debug "Starting Fiat: " + Math.round(context.balance_curr_start*100)/100 + " | Starting BTC: " +  Math.round(context.balance_btc_start*100)/100
         debug "Current Portfolio Worth: " + Math.round(((context.balance_btc * price) + context.balance_curr)*100)/100
         debug "Starting Portfolio Worth: " + Math.round(((context.balance_btc_start * context.price_start) + context.balance_curr_start)*100)/100
         debug "Efficiency Vs Buy and Hold: " + efficiency + " which equals " + efficiency_percent + "%"
         warn "###"
 
     if Math.round(context.TICK/744) == (context.TICK/744)
         info "###"
         info "Thanks for using this free bot for the last month. Please consider a donation to:"
         info "BTC: 1GGZU5mAUSLxVDegdxjakTLqZy7zizRH74"
         info "(The bot carries on regardless of donations - don't worry. And if you have donated then thank you.)"
         info "Or maybe fill in an anonymous survey?"
         info "https://docs.google.com/forms/d/1sWjADH4lPvcIy1LJ-N3lz9Bc3dGVefGBCHbzLRFJ7MQ/viewform"
         info "###"
 
 
 
 finalize: (contex, data)->
 
     # DISPLAY FINALISE STATS
     if context.balance_curr > 10
         info "Final BTC Equiv: " + Math.round(context.balance_curr/context.price*100)/100
     if context.balance_btc > 0.05
         info "Final BTC Value: " + Math.round(context.balance_btc*100)/100