combattracker.js

/* 
 * Version 1.1.10 Beta
 * Made By Robin Kuiper
 * Changes in Version 0.2.1 by The Aaron
 * Changes in Version 0.3.0 and greater by Victor B
 * Skype: RobinKuiper.eu
 * Discord: Atheos#1095
 * My Discord Server: https://discord.gg/AcC9VMEG
 * Roll20: https://app.roll20.net/users/1226016/robin
 * Roll20 Thread: https://app.roll20.net/forum/post/6349145/script-combattracker
 * Github: https://github.com/RobinKuiper/Roll20APIScripts
 * Reddit: https://www.reddit.com/user/robinkuiper/
 * Patreon: https://patreon.com/robinkuiper
 * Paypal.me: https://www.paypal.me/robinkuiper
*/
var CombatTracker = CombatTracker || (function() {
    'use strict';

    let round = 1,
	    version = '1.1.10 Beta',
        timerObj,
        intervalHandle,
        debug = true,
        rotationInterval,
        paused = false,
        observers = {
            tokenChange: []
        },
		whisper, handled = [],	
        extensions = {
            StatusInfo: true // This will be set to true automatically if you have StatusInfo
        },
        startImage = '4',
		pauseImage = '5',
        stopImage = '6',
        tagImage = '3',
        noTagImage = 'd',
        deleteImage = 'D',
        shuffleImage = ';',
        randomSingleImage = '`',
        randomLoopImage = '?',
        togetherImage = 'J',
        loopImage = 'r',
        sortImage = '1',
        lockImage = ')',
        unlockImage = '(',
        backImage = 'y',
        nextImage = ']',
        prevImage = '[',
        decreaseImage = '<',
        increaseImage = '>',
        timerImage = 't',
        favoriteImage = 'S',
        allConditionsImage = 'G',
        addImage = '&',		
        doneImage = '3',
        showImage = 'v',
        delayImage = '}';

    //Styling for the chat responses.
    const styles = {
        reset: 'padding: 0; margin: 0;',
        menu:  'background-color: #fff; border: 1px solid #000; padding: 5px; border-radius: 5px;',
 		title: 'font-size:14px;font-weight:bold',
 		version:'font-size:10px;',
 		header: 'margin-top:10px;margin-bottom:5px;font-weight:bold;font-style:italic;display:inline-block;',
        button: 'background-color: #000; border: 1px solid #292929; border-radius: 3px; padding: 5px; color: #fff; text-align: center;width:100%',
        textButton: 'background-color:#fff; color: #000; text-align: center; float: right;',
 		linkButton: 'background-color:#fff; color: #000; text-align: center;vertical-align:middle',
 		textLabel: 'float:left;text-align:center;margin-top:8px',
        list: 'list-style: none;',
        float: {
            right: 'float: right;',
            left: 'float: left;'
        },
        overflow: 'overflow: hidden;',
        fullWidth: 'width: 100%;',
        underline: 'text-decoration: underline;',
        strikethrough: 'text-decoration: strikethrough'
    },
    // Styling for the chat responses.
    style = "overflow: hidden; background-color: #fff; border: 1px solid #000; padding: 5px; border-radius: 5px;",
    buttonStyle = "background-color: #000; border: 1px solid #292929; border-radius: 3px; padding: 5px; color: #fff; text-align: center; float: right;",
    conditionStyle = "background-color: #fff; border: 1px solid #000; padding: 5px; border-radius: 5px;",
    conditionButtonStyle = "text-decoration: underline; background-color: #fff; color: #000; padding: 0",
    listStyle = 'list-style: none; padding: 0; margin: 0;',

    icon_image_positions = {red:"#C91010",blue:"#1076C9",green:"#2FC910",brown:"#C97310",purple:"#9510C9",pink:"#EB75E1",yellow:"#E5EB75",dead:"X",skull:0,sleepy:34,"half-heart":68,"half-haze":102,interdiction:136,snail:170,"lightning-helix":204,spanner:238,"chained-heart":272,"chemical-bolt":306,"death-zone":340,"drink-me":374,"edge-crack":408,"ninja-mask":442,stopwatch:476,"fishing-net":510,overdrive:544,strong:578,fist:612,padlock:646,"three-leaves":680,"fluffy-wing":714,pummeled:748,tread:782,arrowed:816,aura:850,"back-pain":884,"black-flag":918,"bleeding-eye":952,"bolt-shield":986,"broken-heart":1020,cobweb:1054,"broken-shield":1088,"flying-flag":1122,radioactive:1156,trophy:1190,"broken-skull":1224,"frozen-orb":1258,"rolling-bomb":1292,"white-tower":1326,grab:1360,screaming:1394,grenade:1428,"sentry-gun":1462,"all-for-one":1496,"angel-outfit":1530,"archery-target":1564},
    markers = ['blue', 'brown', 'green', 'pink', 'purple', 'red', 'yellow', '-', 'all-for-one', 'angel-outfit', 'archery-target', 'arrowed', 'aura', 'back-pain', 'black-flag', 'bleeding-eye', 'bolt-shield', 'broken-heart', 'broken-shield', 'broken-skull', 'chained-heart', 'chemical-bolt', 'cobweb', 'dead', 'death-zone', 'drink-me', 'edge-crack', 'fishing-net', 'fist', 'fluffy-wing', 'flying-flag', 'frozen-orb', 'grab', 'grenade', 'half-haze', 'half-heart', 'interdiction', 'lightning-helix', 'ninja-mask', 'overdrive', 'padlock', 'pummeled', 'radioactive', 'rolling-bomb', 'screaming', 'sentry-gun', 'skull', 'sleepy', 'snail', 'spanner',   'stopwatch','strong', 'three-leaves', 'tread', 'trophy', 'white-tower'],
    shaped_conditions = ['blinded', 'charmed', 'deafened', 'frightened', 'grappled', 'incapacitated', 'invisible', 'paralyzed', 'petrified', 'poisoned', 'prone', 'restrained', 'stunned', 'unconscious'],
	
    script_name = 'CombatTracker',
    combatState = 'COMBATTRACKER',
    statusState = 'STATUSINFO',
    handleInput = (msg) => {

        if (msg.content.indexOf('!ct')!==0 && msg.content.indexOf('!condition')!==0) {
            return;
        }
        
        if (debug) {
            log('handleInput')
            log('Msg:'+msg.content)
        }	
        
        let args        = msg.content.split(' '),
            command     = args.shift().substring(1),
            action      = args.shift(),
            condition   = args.shift(),
            changes     = args.shift(),
			senderId	= msg.who,			 
            key, value, duration, direction
            
        if (debug) {
            log('handleInput')
            log('Command:'+command)
            log('Action:'+action)
            log('Condition:'+condition)
        }   
        
        if (typeof changes != 'undefined') {    
            if (changes.includes('|')) {   
                changes     = changes.split('|')
             	key         = changes.shift()
    		    value       = (changes[0] === 'true') ? true : (changes[0] === 'false') ? false : changes[0]
    		    if (key == 'description') {
    		        value   = value + ' ' + args.join(' ')
    		    }      
            
                if (debug) {
                    log('Changes:'+changes)
                    log('Key:'+key)
                    log('Value:'+value)
                }       		    
            } else {
                duration    = changes
                direction   = args.shift()
            
                if (debug) {
                    log('Duration:' + duration)
                    log('Direction:' + direction)
                }                   
            }
        }    

        if (command === state[combatState].config.command) {
			if (action === 'next') {
				if (!getTurnorder().length) return;
				
				NextTurn();
				return;
			}
			if (action === 'delay') {
				if (!getTurnorder().length) return;

				delayTurn();
				return
			}
			
// 			// Below commands are only for GM's
			if (playerIsGM(msg.playerid)){

				switch (action) {
					case 'reset':
							state[combatState] = {};
							state[statusState] = {};
							setDefaults(true);
							sendConfigMenu();
					break;
					case 'config':
						editCombatState(condition,key,value)              
					break;
					case 'tracker':
						sendConfigMenu();
					break;				
					case 'sort':
						sortTurnorder();
					break;
					case 'prev':
						PrevTurn();
					break;
					case 'start':
						startCombat(msg.selected);
					break;
					case 'stop':
						stopCombat();
						sendTrackerMenu();
					break;
					case 'st':
						stopTimer();
						sendTrackerMenu();
					break;
					case 'pt':
						pauseTimer();
						sendTrackerMenu();
					break;
				}
			}
			switch(action) {	
				case 'all':
					editFavoriteState('All');
					sendTrackerMenu(senderId);
				break;	
				case 'fav':
					editFavoriteState('Favorites');
					sendTrackerMenu(senderId);
				break;						
				case 'add':
				    addCommand(msg.selected, condition, duration, direction)
				break;    
				case 'remove': {
					removeCommand(msg.selected, condition)
				}
				break;
                case 'show': {
                    showConditions(msg.selected, senderId);
    			}
                break;				
				default:
					sendTrackerMenu();
				break;
			}
			
		}	
		
        if (command === state[statusState].config.command) {
            switch(action) {
                case 'import':
                    importConditions(msg)
                break;
                case 'export':
                    exportConditions()
                break;                
                case 'status':
                    sendStatusMenu(key, value)
                break;
                case 'list':
                    sendConditionsMenu()
                break;      
                case 'config':
                    editStatusState(key, value)
                break;  
                case 'condition':
                    sendConditionMenu(condition)
                break;    
                case 'update':
                    editCondition(condition, key, value)
                break;
                case 'add':
                    createCondition(condition)
                break;                
                case 'remove':
                    deleteCondition(condition, duration)
                break;
                case 'favorite':
                    editFavoriteConditon(condition, key, value)
                break;   
            }
        }		
    },

    importConditions = (msg) => {
        let json;
        let conditions = msg.content.substring(('!condition import ').length);

        try{
            json = JSON.parse(conditions);
        } catch(e) {
            makeAndSendMenu('This is not a valid JSON string.');
            return;
        }
        
        state[statusState] = json;
    },
    
    exportConditions = () => {
        makeAndSendMenu('<pre>'+HE(JSON.stringify(state[statusState]))+'</pre><p>Copy the entire content above and save it on your pc.</p>');
    },
    
    //this
    addCommand = (tokens, condition, duration, direction) => {

        if (debug) {
            log('Add Command')
            log('Condition:' + condition)
            log('Duration:' + duration)
            log('Direction:' + direction)
        }
        //loop through selected tokens
        if (tokens) {
        	tokens.forEach(token => {
                if (debug) {
                    log('ID:' + token._id)
                    log('Type:' + token._type)
                } 
        	    //call add condition passint ing token, name and other parameters
        	    if (token._type == 'graphic') {
    			    addCondition(getObj(token._type, token._id), condition, duration, direction)    
        	    }
        	        
        	});	 	
        } else {
            makeAndSendMenu('No tokens were selected.', '', 'gm');
        }   
    },
  
     removeCommand = (tokens, condition) => {

        if (debug) {
            log('Remove Command')
            log('Condition:' + condition)
        }
        
        //loop through selected tokens
        if (tokens) {
        	tokens.forEach(token => {
                if (debug) {
                    log('ID:' + token._id)
                    log('Type:' + token._type)
                } 
        	    //call add condition passint ing token, name and other parameters
        	    if (token._type == 'graphic') {
    			    removeCondition(getObj(token._type, token._id), condition)    
        	    }    
        	});	 	
        }	
    },
       
    addCondition = (token, name, duration, direction) => {
	    let	defaultCondition, combatCondition, newCondition = {}

        if (debug) {
            log('Add Condition')
            log('Token:' + token.get("_id"))
            log('Name:'+name)
            log('Duration:'+duration)
            log('Direction:'+direction)
        } 
	        
	    //verify incomming command     
        if (verifyCondition(token.get("_id"), name)) {
            
            removeCondition(token, name);   
           
            defaultCondition    = getConditionByKey(name)
            newCondition.id     = token.get("_id")
            newCondition.name   = defaultCondition.name.toLowerCase()
            newCondition.icon   = defaultCondition.icon
            
            if (!defaultCondition.override) {
                newCondition.duration = parseInt(defaultCondition.duration)
            } else {
                if (!duration) {
                    newCondition.duration = parseInt(defaultCondition.duration)
                } else {
                    newCondition.duration = parseInt(duration)
                }    
            }
            if (!defaultCondition.override) {
                newCondition.direction = parseInt(defaultCondition.direction)
            } else {
                if (!direction) {
                    newCondition.direction = parseInt(defaultCondition.direction)
                } else {    
                    newCondition.direction = parseInt(direction)
                }    
            }   
            
            if (debug) {
                log('Duration:' + newCondition.duration)
                log('Direction:' + newCondition.direction)
            }    
           
            state[combatState].conditions.push(newCondition)

            if (newCondition.name == 'dead' || newCondition.duration <= 1) {
                token.set('status_'+newCondition.icon, true);
            } else {   
                if (newCondition.duration >= 10) {
                    token.set('status_'+newCondition.icon, true);
                } else {
                    token.set('status_'+newCondition.icon,newCondition.duration);
                }
            }  
            
            if (state[statusState].config.showConditions) {
                sendConditionToChat(defaultCondition)
            }    
            if (debug) {
                log('Combat Conditions')
                state[combatState].conditions.forEach(condition => {
                    log(condition)
                })
            } 
        }    
    },

    removeCondition = (token, name) => {
        let i, condition
        
        if (debug) {
            log('Remove Condition')
            log('Name:'+name)
        } 

        if (state[combatState].conditions.length > 0) {
            state[combatState].conditions.forEach((condition, i) => {
                if (condition.name.toLowerCase() == name &&  condition.id == token.get("_id")) {
                    state[combatState].conditions.splice(i, 1);
                    token.set('status_'+condition.icon, false);   
                }
            })
        }  
        
        if (debug) {
            log('Combat Conditions')
            state[combatState].conditions.forEach(condition => {
                log(condition)
            })
        }         
    },
    
    verifyCondition  = (tokenID, name)  => {
        let condition

        condition    = getConditionByKey(name)
        
        if (typeof condition.direction == 'undefined' || typeof condition.duration == 'undefined') {
			makeAndSendMenu('The condition you are trying to use has not be setup yet', '', 'gm');
			return false;            
        }
        
		if (!name) {
			makeAndSendMenu('No condition name was given.', '', 'gm');
			return false;
		}
		//must have a token		
		if (!tokenID || !tokenID.length) {		
			makeAndSendMenu('No tokens were selected.', '', 'gm');
			return false;
        }	

        if (tokenID == getOrCreateMarker().get('id')) {
            return false;
        }
          if (tokenID == getOrCreateMarker(true).get('id')) {
            return false;
        }      
        return true;
    },

    strip = (str) => {
        return str.replace(/[^a-zA-Z0-9]+/g, '_');
    },

    startCombat = (selectedTokens) => {
        let verified=false, statusmarkers
        
        if (debug) {
            log('Start Combat')
            log('Selected Tokens' + selectedTokens)
        }
        
        verified = verifySetup(selectedTokens)
        
        if (!verified) {
            return;
        }
        
        paused = false;
        resetMarker();
        
        Campaign().set('initiativepage', Campaign().get('playerpageid'));

        if(state[combatState].config.turnorder.throw_initiative){
            rollInitiative(selectedTokens);
        }

        setTimeout(function(){
            doTurnorderChange();
            sendTrackerMenu();
        },1)    
    },
    
    stopCombat = () => {
        let token, statusmarkers
        if (debug) {
            log('Stop Combat')
        }
        
        if(timerObj) timerObj.remove();

        if (state[statusState].config.clearConditions) {
            state[combatState].conditions.forEach((condition,i) => {
                if (condition.id != getOrCreateMarker().get('id')) {
                    token           = getObj('graphic', condition.id)
                    token.set('status_'+condition.icon, false); 
                    
                }  
            }) 
        }    
        state[combatState].conditions = [];
        removeMarkers();
        stopTimer();
        paused = false;
        Campaign().set({
            initiativepage: false,
            turnorder: ''
        });
        state[combatState].turnorder = {};
        round = 0;
   
    },
    
    verifySetup = (selectedTokens) => {
        let initAttributes, turnorder, attribute, whisper, character, verified=true, i, tokenObj
 
        if (!selectedTokens || selectedTokens.length == 0) {
            makeAndSendMenu('No tokens selected.  Combat not started',' ', whisper);   
            verified=false             
            return
        }
        
        if(!state[combatState].config.turnorder.throw_initiative){
            turnorder = getTurnorder()
            log('Turnorder:' + turnorder)
            if (turnorder.length == 0) {
                makeAndSendMenu('Auto Roll Initiative has been set to false and your turn order is currently empty',' ', whisper);
                verified=false
                return
            }
        }
        
        selectedTokens.forEach(token => {
            if (token._type == 'graphic') {
                tokenObj        = getObj('graphic', token._id)
                whisper         = (tokenObj.get('layer') === 'gmlayer') ? 'gm ' : ''
                character       = getObj('character', tokenObj.get('represents'))
                initAttributes  = state[combatState].config.initiative_attribute_name.split(',')

                if (typeof character == 'undefined') {
                    makeAndSendMenu('A token was found not assigned to a character sheet',' ', whisper);   
                }
    
                for (i=0;i<initAttributes.length;i++) {
                    if (typeof character != 'undefined') {
                        attribute    = getAttrByName(character.id,initAttributes[i],'current') 
                        if (typeof attribute == 'undefined') {
                            makeAndSendMenu('Initiative Attribute ' + initAttributes[i] + ' not found on character sheet',' ', whisper);  
                            verified=false
                        }    
                    }    
                } 
            }    
        })    
        
        return verified
    },

    resetMarker = (next=false) => {
        let marker = getOrCreateMarker(next);
        
        if (debug) {
            log('Reset Marker')
        }
        marker.set({
            name: (next) ? 'NextMarker' : 'Round ' + round,
            imgsrc: (next) ? state[combatState].config.next_marker_img : state[combatState].config.marker_img,
            pageid: Campaign().get('playerpageid'),
            layer: 'gmlayer',
            left: 35, top: 35,
            width: 70, height: 70
        });

        return marker;
    },

    getOrCreateMarker = (next=false, pageid=Campaign().get('playerpageid')) => {
        let marker, markers,
            imgsrc = (next) ? state[combatState].config.next_marker_img : state[combatState].config.marker_img

        // if (debug) {
        //     log('Get or Create Marker')
        // }
        
        if (next) {
            markers = findObjs({
                pageid,
                imgsrc,
                name: 'NextMarker'
            });

        } else {
            markers = findObjs({
                pageid,
                imgsrc
            });
        }
        
        markers.forEach((marker, i) => {
            if(i > 0 && !next && marker.get('name') !== 'NextMarker') marker.remove();
        });

        marker = markers.shift();
        
        // if (debug) {
        //     log('Marker:' + marker)
        // }
        
        if(!marker) {
            marker = createObj('graphic', {
                name: (next) ? 'NextMarker' : 'Round 0',
                imgsrc,
                pageid,
                layer: 'gmlayer',
                showplayers_name: true,
                left: 35, top: 35,
                width: 70, height: 70
            });
        }
        
        if(!next) checkMarkerturn(marker);
        
        toBack(marker);

        return marker;
    },
    
    inFight = () => {
        return (Campaign().get('initiativepage') !== false);
    },

    rollInitiative = (selectedTokens) => {
        let tokenObj, whisper, initiativeTemp, initiativeRoll, characterObj, initAttributes, initiativeMod, i, advantageAttrib, initiativeAdv1, initiativeAdv2
        
        //loop through selected tokens
        selectedTokens.forEach(token => {
            if (token._type == 'graphic') {
                // get token and character objects
                tokenObj        = getObj('graphic', token._id)
                characterObj    = getObj('character', tokenObj.get('represents'))
                // roll initiative only for tokens assigned to character sheets
                if (typeof characterObj != 'undefined') {
                    whisper         = (tokenObj.get('layer') === 'gmlayer') ? 'gm ' : ''
                    initiativeRoll  = (state[combatState].config.turnorder.ini_die) ? randomInteger(state[combatState].config.turnorder.ini_die) : 0;
                    initAttributes  = state[combatState].config.initiative_attribute_name.split(',')
                    initiativeMod   = 0
                    // loop through commma delimited list of attributes (usually only one) to determine the initiative modifier
                    for (i=0;i<initAttributes.length;i++) {
                        initiativeTemp  = getAttrByName(characterObj.id,initAttributes[i],'current') 
                        initiativeMod  += parseFloat(initiativeTemp)
                    }
                    //check for advantage initiative rolling (OGL)
                    advantageAttrib   = getAttrByName(characterObj.id, 'initiative_style', 'current');  
                    if (typeof advantageAttrib != 'undefined') {
                        // roll advantage for initiative
                        initiativeAdv1 = (state[combatState].config.turnorder.ini_die) ? randomInteger(state[combatState].config.turnorder.ini_die) : 0; 
                        initiativeAdv2 = (state[combatState].config.turnorder.ini_die) ? randomInteger(state[combatState].config.turnorder.ini_die) : 0;
                        // this is the value if in OGL if rolling advantage
                        if (advantageAttrib == '{@{d20},@{d20}}kh1') {
                            //determine which value is higher
                            if (initiativeAdv1 >= initiativeAdv2) {
                                initiativeRoll = initiativeAdv1
                            } else {
                                initiativeRoll = initiativeAdv2
                            }
                            //pass in both values and modifier for display
                            if (state[combatState].config.turnorder.show_initiative_roll) {
                                sendInitiativeChat(tokenObj.get('name'),initiativeAdv1,initiativeMod,initiativeAdv2,whisper)                            
                            }
                        } else if (state[combatState].config.turnorder.show_initiative_roll) { 
                            // if not rolling advantage, use first roll
                            initiativeRoll = initiativeAdv1
                            sendInitiativeChat(tokenObj.get('name'),initiativeRoll,initiativeMod,null,whisper)                              
                        }    
                    }  else if (state[combatState].config.turnorder.show_initiative_roll) { 
                        // if everything else then pass in for display
                         sendInitiativeChat(tokenObj.get('name'),initiativeRoll,initiativeMod,null,whisper)   
                    }  
                    //add to turnorder 
                    if (debug) {
                        log("Token Id:" + tokenObj.id)
                        log("Token Page:" + tokenObj.get("pageid"))
                    }  
                    if (Number.isInteger(initiativeMod+initiativeRoll)) {
                        addToTurnorder({id:tokenObj.id,pr:(initiativeMod+initiativeRoll),custom:'',pageid:tokenObj.get("pageid")});
                    } else {
                        addToTurnorder({id:tokenObj.id,pr:(initiativeMod+initiativeRoll).toFixed(2),custom:'',pageid:tokenObj.get("pageid")});
                    }    
                }   
            }    
        });
        // sort turnorder if set
        if(state[combatState].config.turnorder.auto_sort){
            sortTurnorder();
        }
    },

    sendInitiativeChat = (name,rollInit,bonus,rollInit1,whisper) => { 
        let contents = ''
        
        if (rollInit1) {
            contents = '<table style="width: 50%; text-align: left; float: left;"> \
                            <tr> \
                                <th>Modifier</th> \
                                <td>'+bonus+'</td> \
                            </tr> \
                        </table> \
                        <div style="text-align: center"> \
                            <b style="font-size: 14pt;"> \
                                <span style="border: 1px solid green; padding-bottom: 2px; padding-top: 4px;">[['+rollInit+'+'+bonus+']]</span><br><br> \
                            </b> \
                        </div> \
                        <div style="text-align: center"> \
                            <b style="font-size: 10pt;"> \
                                <span style="border: 1px solid red; padding-bottom: 2px; padding-top: 4px;">[['+rollInit1+'+'+bonus+']]</span><br><br> \
                            </b> \
                        </div>'   
        } else {
             contents = '<table style="width: 50%; text-align: left; float: left;"> \
                            <tr> \
                                <th>Modifier</th> \
                                <td>'+bonus+'</td> \
                            </tr> \
                        </table> \
                        <div style="text-align: center"> \
                            <b style="font-size: 14pt;"> \
                                <span style="border: 1px solid green; padding-bottom: 2px; padding-top: 4px;">[['+rollInit+'+'+bonus+']]</span><br><br> \
                            </b> \
                        </div>'
           
        }  
        
        makeAndSendMenu(contents, name + ' Initiative', whisper);    
    },

    clearTurnorder = () => {
        Campaign().set({ turnorder: '' });
        state[combatState].turnorder = {};
    },

    removeMarkers = () => {
        stopRotate();
        getOrCreateMarker().remove();
        getOrCreateMarker(true).remove();
    },

    doTurnorderChange = (prev=false, delay=false) => {
        //if(!Campaign().get('initiativepage') || getTurnorder().length <= 1) return;

        let turn = getCurrentTurn();
        
        if(debug) {
            log('Turn Order Change')
            log('ID:' + turn.id)
        }
        if (turn.id === '-1') { 
            if (turn.formula) {
                updatePR(turn, parseInt(turn.formula));
            }
            if (!state[combatState].config.turnorder.skip_custom) {
                resetMarker();
            } else {
                NextTurn();
            }    
           return;
        }

        if (turn.id === getOrCreateMarker().get('id')) {
            if (prev) {
                PrevRound();
            } else { 
                NextRound();
            }    
            return;
        }

        let token = getObj('graphic', turn.id);

		if (token) {
            toFront(token);

            if (state[combatState].config.timer.use_timer) {
                startTimer(token);
            }

            changeMarker(token || false);

            if (state[combatState].config.macro.run_macro) {
                let ability = findObjs({ _characterid: token.get('represents'), _type: 'ability', name: state[combatState].config.macro.macro_name })
                if(ability && ability.length){
                    sendChat(token.get('name'), ability[0].get('action'), null, {noarchive:true} );
                }
            }

            if (state[combatState].config.announcements.announce_turn) {
                announcePlayer(token, (token.get('layer') === 'objects') ? '' : 'gm', prev, delay);
                //announcePlayer(token || turn.custom, (token.get('layer') === 'objects') ? '' : 'gm');
            }
            
            Pull(token);
            doFX(token);
        } else {
            resetMarker();
        }

        if (state[combatState].config.next_marker) {
            let nextTurn = getNextTurn();
            let nextToken = getObj('graphic', nextTurn.id);

            if (nextToken) {
                toFront(nextToken);
                changeMarker(nextToken || false, true);
            } else {
                resetMarker(true);
            }
        }
    },

    updatePR = (turn, modifier) => {
        let turnorder = getTurnorder();

        turnorder.forEach((t, i) => {
            if(turn.id === t.id && turn.custom === t.custom){
                turnorder[i].pr = parseInt(t.pr) + modifier;
            }
        });

        setTurnorder(turnorder);
    },

    doFX = (token) => {
        if(!state[combatState].config.announcements.use_fx || token.get('layer') === 'gmlayer') return;

        let pos = {x: token.get('left'), y: token.get('top')};
        spawnFxBetweenPoints(pos, pos, state[combatState].config.announcements.fx_type, token.get('pageid'));
    },

    Pull = (token) => {
        if(!state[combatState].config.pull) return;

        sendPing(token.get('left'), token.get('top'), token.get('pageid'), null, true);
    },

    startTimer = (token) => {
        paused = false;
        clearInterval(intervalHandle);
        if(timerObj) timerObj.remove();

        let config_time = parseInt(state[combatState].config.timer.time); 
        let time = config_time;

        if(token && state[combatState].config.timer.token_timer){
            timerObj = createObj('text', {
                text: 'Timer: ' + time,
                font_size: state[combatState].config.timer.token_font_size,
                font_family: state[combatState].config.timer.token_font,
                color: state[combatState].config.timer.token_font_color,
                pageid: token.get('pageid'),
                layer: 'gmlayer'
            });
        }

        intervalHandle = setInterval(() => {
            if(paused) return;

            if(timerObj) timerObj.set({
                top: token.get('top')+token.get('width')/2+40,
                left: token.get('left'),
                text: 'Timer: ' + time,
                layer: token.get('layer')
            });

            if(state[combatState].config.timer.chat_timer && (time === config_time || config_time/2 === time || config_time/4 === time || time === 10 || time === 5)){
                makeAndSendMenu('', 'Time Remaining: ' + time);
            }

            if(time <= 0){
                if(timerObj) timerObj.remove();
                clearInterval(intervalHandle);
                if(state[combatState].config.timer.auto_skip) NextTurn();
                else if(token.get('layer') !== 'gmlayer') makeAndSendMenu(token.get('name') + "'s time ran out!", '');
            }

            time--;
        }, 1000);
    },

    stopTimer = () => {
        clearInterval(intervalHandle);
        if(timerObj) timerObj.remove();
    },

    pauseTimer = () => {
        paused = !paused;
    },

    announcePlayer = (token, target, prev, delay=false, show) => {
        let name, imgurl, conditions, image, doneButton, delayButton, contents;

        target      = (state[combatState].config.announcements.whisper_turn_gm) ? 'gm' : target;
        name        = token.get('name');
        imgurl      = token.get('imgsrc');
        conditions  = getAnnounceConditions(token, prev, delay, show);
        image       = (imgurl) ? '<img src="'+imgurl+'" width="50px" height="50px"  />' : ''
        name        = (state[combatState].config.announcements.handleLongName) ? handleLongString(name) : name
        
        if (!show) {
            doneButton  = makeImageButton('!ct next',doneImage,'Done with Round','transparent',18)
            delayButton = makeImageButton('!ct delay',delayImage,'Delay your Turn','transparent',18);
        }    

        contents    = '<div style="display:inline-block;vertical-aligh:middle">'+image+'</div>'
        if (!show) {
            contents   += '<div style="display:inline-block;vertical-aligh:middle">'+name+'\'s Turn</div>'
        } else {
            contents   += '<div style="display:inline-block;vertical-aligh:middle">'+name+'</div>'
        }
        
        if (!show) {
            contents   += '<div style="display:inline-block;float:right;vertical-aligh:middle">'+doneButton+'</div>'
            contents   += '<div style="display:inline-block;float:right;vertical-aligh:middle">'+delayButton+'</div>'
        }
        
        if (state[combatState].config.announcements.announce_turn) {
            contents   += conditions
        }
        //send announcement
        makeAndSendMenu(contents, '', target);
    },

    getAnnounceConditions = (token, prev, delay, show) => {
        let output = ' ', removeButton
        
        if (debug) {
            log('Announce Condition') 
            log('Token ID:' + token.get("_id"))
        }

        removeButton  = makeImageButton('!ct remove',deleteImage,'Remove Condition','transparent',18)
        
        if (state[combatState].conditions) {
            [... state[combatState].conditions].forEach(condition => {
                
                if (condition.id ==  token.get("_id")) {
                    output  +=  '<div>'
                    
                    if (debug) {
                        log('Condition:' +condition.name)
                        log('Duration:' +condition.duration)
                        log('Direction:' +condition.direction)
                    }            
                    
                    if (!delay && !show) {
                        if (!prev) {
                            condition.duration = condition.duration + condition.direction
                        } else {
                            condition.duration = condition.duration - condition.direction
                        }
                    }    
                    
                    if (condition.duration == 0 && condition.direction != 0) {
                        output += '<strong>'+condition.name+'</strong> removed.';
                        if (!delay && !show) {
                            removeCondition(token, condition.name);  
                        }    
                    } else if (condition.duration > 0 && condition.direction != 0) {
                        if (show) {
                            output += '<strong>'+makeButton(condition.name, '!ct remove '+condition.name)+'</strong>:'+condition.duration+' Rounds Left'
                        } else {
                            output += '<strong>'+condition.name+'</strong>: '+condition.duration+' Rounds Left';
                        }
                        
                        if (!delay && !show) {
                            if (condition.duration >= 10) {                
                                token.set('status_'+condition.icon, true);
                            } else {
                                token.set('status_'+condition.icon, condition.duration);
                            }   
                        }    
                    } else if (condition.direction == 0) {
                        if (show) {
                            output += '<strong>'+makeButton(condition.name, '!ct remove '+condition.name)+'</strong>:'+condition.duration+' Permanent (until removed)'
                        } else {
                            output += '<strong>'+condition.name+'</strong>: '+condition.duration+' Permanent';
                        } 
                    }
    
                    output += '</div>'
                }    
            })
        }    

      return output;
    },

    handleLongString = (str, max=8) => {
        str = str.split(' ')[0];
        return (str.length > max) ? str.slice(0, max) + '...' : str;
    },

    delayTurn = () => {
        let turnorder, currentTurn, nextTurn, dummy

        turnorder   = getTurnorder()
        currentTurn = turnorder.shift();
        
        if (getVeryNextTurn().id === getOrCreateMarker().get('id')) { 
            setTurnorder(turnorder)
            NextRound()
            turnorder   = getTurnorder()
            nextTurn = currentTurn
            currentTurn = turnorder.shift();
            turnorder.unshift(nextTurn)  
            turnorder.unshift(currentTurn)
            setTurnorder(turnorder);
            
            return;
        }
        
        nextTurn    = turnorder.shift();
        
        if (debug) {
            log('Delay Turn')
            log('Current:' + currentTurn)
            log('Next:'+nextTurn)
        }
        
        turnorder.unshift(currentTurn)
        turnorder.unshift(nextTurn)
        
        setTurnorder(turnorder);
        doTurnorderChange(false,true);
    },
    
    NextTurn = () => {
        let turnorder, currentTurn
      
        if (debug) {
            log('Next Turn')
        }
        
        turnorder = getTurnorder(),
        currentTurn = turnorder.shift();

        turnorder.push(currentTurn);

        setTurnorder(turnorder);
        doTurnorderChange();
    },

    PrevTurn = () => {
        let turnorder = getTurnorder(),
            last_turn = turnorder.pop();        
        turnorder.unshift(last_turn);

        setTurnorder(turnorder);
        doTurnorderChange(true);
    },

    NextRound = () => {
        let marker = getOrCreateMarker();
        round++;
        marker.set({ name: 'Round ' + round});
        
        if (debug) {
            log('Next Round')
        }

        if(state[combatState].config.announcements.announce_round){
            let text = '<span style="font-size: 12pt; font-weight: bold;">'+marker.get('name')+'</span>';
            makeAndSendMenu(text, ' ');
        }

        if(state[combatState].config.turnorder.reroll_ini_round){
            let turnorder = getTurnorder();
            clearTurnorder();
            checkMarkerturn(marker)
 //           log(turnorder.map(turnorder.map(t => { return (t.id !== -1 && t.id !== marker.get('id')) ? { _type: 'graphic', _id: t.id } : false })))
            rollInitiative(turnorder.map(t => { return (t.id) ? { _type: 'graphic', _id: t.id } : false }));
//           sortTurnorder();
            doTurnorderChange()
        }else{
            NextTurn();
            if(state[combatState].config.turnorder.auto_sort){
                sortTurnorder();
            }
        }
    },

    PrevRound = () => {
        let marker = getOrCreateMarker();
        round--;
        marker.set({ name: 'Round ' + round});

        if(state[combatState].config.announcements.announce_round){
            let text = '<span style="font-size: 16pt; font-weight: bold;">'+marker.get('name')+'</span>';
            makeAndSendMenu(text);
        }

        PrevTurn();
    },

    changeMarker = (token, next=false) => {
        let marker = getOrCreateMarker(next);

        // if (debug) {
        //     log('Change Marker')
        //     log('Marker:' + marker)
        // }
        if(!token){
            resetMarker(next);
            return;
        }

        let position = {
            top: token.get('top'),
            left: token.get('left'),
            width: token.get('width')+(token.get('width')*0.35),
            height: token.get('height')+(token.get('height')*0.35),
        };

        if(token.get('layer') !== marker.get('layer')){
            if(marker.get('layer') === 'gmlayer'){ // Go from gmlayer to tokenlayer
                marker.set(position);

                setTimeout(() => {
                    marker.set({ layer: 'objects' });
                }, 500);
            }else{ // Go from tokenlayer to gmlayer
                marker.set({ layer: 'gmlayer' });

                setTimeout(() => {
                    marker.set(position);
                }, 500);
            }
        }else{
            marker.set(position);
        }

        toBack(marker);
    },

    stopRotate = () => {
        clearInterval(rotationInterval);
    },

    checkMarkerturn = (marker) => {
        let turnorder = getTurnorder(),
            hasTurn = false;
        
        // if (debug) {
        //     log ('Check Marker Turn')
        // }    
        
        turnorder.forEach(turn => {
            if(turn.id === marker.get('id')) hasTurn = true;
        });

        if(!hasTurn){
            turnorder.push({ id: marker.get('id'), pr: -1, custom: '', pageid: marker.get('pageid') });
            Campaign().set('turnorder', JSON.stringify(turnorder));
        }
    },

    sortTurnorder = (order='DESC') => {
        let turnorder = getTurnorder();

        turnorder.sort((a,b) => { 
            return (order === 'ASC') ? a.pr - b.pr : b.pr - a.pr;
        });

        setTurnorder(turnorder);
 //       doTurnorderChange();
    },

    getTurnorder = () => {
        return (Campaign().get('turnorder') === '') ? [] : Array.from(JSON.parse(Campaign().get('turnorder')));
    },

    getCurrentTurn = () => {
        return getTurnorder().shift();
    },

    getNextTurn = () => {
        let returnturn;
        getTurnorder().every((turn, i) => {
            if(i > 0 && turn.id !== '-1' && turn.id !== getOrCreateMarker().get('id')){
                returnturn = turn;
                return false;
            }else return true
        });
        return returnturn;
    },
    
    getVeryNextTurn = () => {
        let turnorder, turn;
        turnorder = getTurnorder();
        turn = turnorder.shift()
        turn = turnorder.shift()
        return turn;
    },    

    addToTurnorder = (turn) => {
        let turnorder = getTurnorder(),
            justDoIt = true;

        if (debug) {
            log('Add to Turnorder')
        }
        
        turnorder.push(turn);
        setTurnorder(turnorder);
    },

    setTurnorder = (turnorder) => {
        Campaign().set('turnorder', JSON.stringify(turnorder));
    },

    randomBetween = (min, max) => {
        return Math.floor(Math.random()*(max-min+1)+min);
    },
	
	editCombatState = (type,key,value) => {
			
		if(type === 'combat'){
			state[combatState].config[key] = value;
		}
		
		if(type === 'timer'){
			state[combatState].config.timer[key] = value;
		}
		
		if (type === 'turnorder'){
			if(key === 'ini_die') {
				value = parseInt(value);
			}
			state[combatState].config.turnorder[key] = value;
		}	
		
		if (type === 'announcements'){
			state[combatState].config.announcements[key] = value;
		}
		
		if (type === 'macro'){
			state[combatState].config.macro[key] = value;
		}


		if(type === 'combat'){
			sendCombatMenu();
		} else if(type === 'timer'){
			sendTimerMenu();
		} else if (type === 'turnorder'){
			sendTurnorderMenu();
		} else if (type === 'announcements'){
			sendAnnounceMenu();
		} else if (type === 'macro'){
			sendMacroMenu();
		} else {
			sendConfigMenu();
		}		
	},

	editFavoriteState = (value) => {
		state[statusState].config.showConditions = value;
	},
	
	editFavoriteConditon = (condition, key, value) => {
 
        if (debug) {
            log ('Edit Favorite Condition')
            log('Key:'+key)
            log('Value:'+value)
        }
        
        state[statusState].conditions[condition][key] = value;
        
        sendTrackerMenu()    
	},
	
	editStatusState = (key, value) => {

        if (debug) {
            log ('Edit Status State')
            log('Key:'+key)
            log('Value:'+value)
        }

        state[statusState].config[key] = value;

        whisper = (state[statusState].config.sendOnlyToGM) ? '/w gm ' : '';
        
        sendStatusMenu();	    
	},
	
	createCondition = (name) => {
        if (debug) {
            log ('Create Condition')
            log('Name:'+name)
        }	
        
		if(!name){
			sendConditionsMenu('You didn\'t give a condition name, eg. <i>!condition add Prone</i>.');
		} else if (state[statusState].conditions[name.toLowerCase()]) {
			sendConditionsMenu('The condition `'+name+'` already exists.');
		} else {
			state[statusState].conditions[name.toLowerCase()] = {
				name: name,
				icon: 'red',
				description: ' ',
				duration: 1,
				direction: 0
			}	
			sendConditionMenu(name.toLowerCase());		
		}		
	},
	
	deleteCondition = (name, confirm) => {	

        if (debug) {
            log ('Delete Condition')
            log('Condition:'+name)
            log('Confirm:'+confirm)
        }	

		if (confirm === 'yes') {
			if(!name){
				sendConditionsMenu('You didn\'t give a condition name, eg. <i>!condition remove Prone</i>.');
			} else if( !state[statusState].conditions[name.toLowerCase()]){
				sendConditionsMenu('The condition `'+name+'` does\'t exist.');
			} else {
				delete state[statusState].conditions[name.toLowerCase()];
				sendConditionsMenu('The condition `'+name+'` is removed.');
			}
		}	
	},
	
	editCondition = (condition, key, value) => {
	    if (debug) {
            log('Edit Condition')
            log('Condition:'+condition)
		    log('Key:' + key)
		    log('Value:' + value)            
	    }

		if (key === 'name' && value !== state[statusState].conditions[condition].name) { 
  			state[statusState].conditions[value.toLowerCase()] = state[statusState].conditions[condition];
  			delete state[statusState].conditions[condition];
 			condition = value.toLowerCase();
	    }

        // if (key === 'description') {
        //     value = value + ' ' + args.join(' ') 
        // }
  		state[statusState].conditions[condition][key] = value;

		sendConditionMenu(condition);	
	},
	
    getConditions = () => {
        return state[statusState].conditions;
    },
	
    sendConfigMenu = () => {

		let configCombatButton          = makeBigButton('Combat', '!ct config combat'),
	     	configTurnorderButton       = makeBigButton('Turnorder', '!ct config turnorder'),
			configTimerButton           = makeBigButton('Timer', '!ct config timer'),
			configAnnouncementsButton   = makeBigButton('Announcement', '!ct config announcements'),
			configMacroButton           = makeBigButton('Macro', '!ct config macro'),
			configStatusButton          = makeBigButton('Status', '!condition status'),
			configConditionButton       = makeBigButton('Conditions', '!condition list'),
			exportButton                = makeBigButton('Export', '!condition export'),
			importButton                = makeBigButton('Import', '!condition import ?{Config}'),	
			resetButton                 = makeBigButton('Reset', '!ct reset'),
			backToTrackerButton         = makeBigButton('Back To Tracker', '!ct'),
			titleText                   = 'CombatTracker Setup<span style="' + styles.version + '"> (' + version + ')</span>',
			combatHeaderText            = '<div style="'+styles.header+'">Combat Setup</div>',
			statusHeadersText           = '<div style="'+styles.header+'">Status Setup</div>',
			resetHeaderText             = '<div style="'+styles.header+'">Reset CombatTracker</div>',	
			backToTrackerText           = '<div style="'+styles.header+'">Return to Tracker</div>',	
			
		 	contents  = combatHeaderText
			contents += configCombatButton
			contents += configTurnorderButton			
			contents += configTimerButton
			contents += configAnnouncementsButton
			contents += configMacroButton	
			contents += statusHeadersText 
			contents += configStatusButton
			contents += configConditionButton
			contents += exportButton
			contents += importButton
			contents += resetHeaderText
			contents += resetButton;
			
			if (state[combatState].config.returnToTracker) {
			    contents += backToTrackerText
			    contents += backToTrackerButton
			}
			
        makeAndSendMenu(contents, titleText, 'gm');
    },

    sendCombatMenu = () => {
        let backButton = makeBigButton('Back', '!ct config'),			
			listItems = [
				makeTextButton('Initiative Attr', state[combatState].config.initiative_attribute_name, '!ct config combat initiative_attribute_name|?{Attribute|'+state[combatState].config.initiative_attribute_name+'}'),
				makeTextButton('Marker', '<img src="'+state[combatState].config.marker_img+'" width="15px" height="15px" />', '!ct config combat marker_img|?{Image Url}'),
				makeTextButton('Use Next Marker',state[combatState].config.next_marker, '!ct config combat next_marker|'+!state[combatState].config.next_marker),
				makeTextButton('Next Marker', '<img src="'+state[combatState].config.next_marker_img+'" width="15px" height="15px" />', '!ct config combat next_marker_img|?{Image Url}'),
				makeTextButton('Stop on Close', state[combatState].config.close_stop, '!ct config combat close_stop|'+!state[combatState].config.close_stop),
				makeTextButton('Auto Pull Map', state[combatState].config.pull, '!ct config combat pull|'+!state[combatState].config.pull),
				makeTextButton('Display Duration', state[combatState].config.duration, '!ct config combat duration|'+!state[combatState].config.duration),      
			],		
			contents = makeList(listItems, backButton);	
			
        makeAndSendMenu(contents, 'Combat Setup', 'gm');
    },

	sendTurnorderMenu = () => {
        let backButton = makeBigButton('Back', '!ct config'),
			listItems = [
				makeTextButton('Auto Roll Initiative', state[combatState].config.turnorder.throw_initiative, '!ct config turnorder throw_initiative|'+!state[combatState].config.turnorder.throw_initiative),
				makeTextButton('Initiative Die', 'd' + state[combatState].config.turnorder.ini_die, '!ct config turnorder ini_die|?{Die (without the d)|'+state[combatState].config.turnorder.ini_die+'}'),
				makeTextButton('Roll Ini Each Round', state[combatState].config.turnorder.reroll_ini_round, '!ct config turnorder reroll_ini_round|'+!state[combatState].config.turnorder.reroll_ini_round),
				makeTextButton('Show Initiative', state[combatState].config.turnorder.show_initiative_roll, '!ct config turnorder show_initiative_roll|'+!state[combatState].config.turnorder.show_initiative_roll),
				makeTextButton('Auto Sort Turnorder', state[combatState].config.turnorder.auto_sort, '!ct config turnorder auto_sort|'+!state[combatState].config.turnorder.auto_sort),
				makeTextButton('Skip Custom Item', state[combatState].config.turnorder.skip_custom, '!ct config turnorder skip_custom|'+!state[combatState].config.turnorder.skip_custom),
			],
			contents = makeList(listItems, backButton);	
			
        makeAndSendMenu(contents, 'Turnorder Setup', 'gm');
    },
	
    sendTimerMenu = () => {
        let backButton = makeBigButton('Back', '!ct config'),
            listItems = [
                 makeTextButton('Turn Timer', state[combatState].config.timer.use_timer, '!ct config timer use_timer|'+!state[combatState].config.timer.use_timer),
                 makeTextButton('Time', state[combatState].config.timer.time, '!ct config timer time|?{Time|'+state[combatState].config.timer.time+'}'),
                 makeTextButton('Auto Skip', state[combatState].config.timer.auto_skip, '!ct config timer auto_skip|'+!state[combatState].config.timer.auto_skip),
                 makeTextButton('Chat Timer', state[combatState].config.timer.chat_timer, '!ct config timer chat_timer|'+!state[combatState].config.timer.chat_timer),
                 makeTextButton('Show on Token', state[combatState].config.timer.token_timer, '!ct config timer token_timer|'+!state[combatState].config.timer.token_timer),
                 makeTextButton('Token Font', state[combatState].config.timer.token_font, '!ct config timer token_font|?{Font|Arial|Patrick Hand|Contrail|Light|Candal}'),
                 makeTextButton('Token Font Size',state[combatState].config.timer.token_font_size, '!ct config timer token_font_size|?{Font Size|'+state[combatState].config.timer.token_font_size+'}'),
            ],
            contents = makeList(listItems, backButton);	
        
		makeAndSendMenu(contents, 'Timer Setup', 'gm');
    },	
	
    sendAnnounceMenu = () =>{
        let backButton = makeBigButton('Back', '!ct config'),
			listItems = [
				makeTextButton('Announce Rounds', state[combatState].config.announcements.announce_round, '!ct config announcements announce_round|'+!state[combatState].config.announcements.announce_round),
				makeTextButton('Announce Turns', state[combatState].config.announcements.announce_turn, '!ct config announcements announce_turn|'+!state[combatState].config.announcements.announce_turn),
				makeTextButton('Whisper GM Only', state[combatState].config.announcements.whisper_turn_gm, '!ct config announcements whisper_turn_gm|'+!state[combatState].config.announcements.whisper_turn_gm),
				makeTextButton('Shorten Long Names', state[combatState].config.announcements.handleLongName, '!ct config announcements handleLongName|'+!state[combatState].config.announcements.handleLongName),
				makeTextButton('Use FX', state[combatState].config.announcements.use_fx, '!ct config announcements use_fx|'+!state[combatState].config.announcements.use_fx),
				makeTextButton('FX Type', state[combatState].config.announcements.fx_type, '!ct config announcements fx_type|?{Type|'+state[combatState].config.announcements.fx_type+'}'),
			],
			contents = makeList(listItems, backButton);	
			
        makeAndSendMenu(contents, 'Announcements Setup', 'gm');
    },

    sendMacroMenu = () => {
        let backButton = makeBigButton('Back', '!ct config'),
			listItems = [
				makeTextButton('Run Macro', state[combatState].config.macro.run_macro, '!ct config macro run_macro|'+!state[combatState].config.macro.run_macro),
				makeTextButton('Macro Name', state[combatState].config.macro.macro_name, '!ct config macro macro_name|?{Macro Name|'+state[combatState].config.macro.macro_name+'}'),
			],
            contents = makeList(listItems, backButton) + '<p>A macro with the right name should be in the characters ability list.</p>';	
			
        makeAndSendMenu(contents, 'Macro Setup', 'gm');
    },
	
	//Start Status Menus
	sendStatusMenu = () => {
        let backButton = makeBigButton('Back', '!ct config'),
            listItems = [
				makeTextButton('Only to GM', state[statusState].config.sendOnlyToGM, '!condition config status sendOnlyToGM|'+!state[statusState].config.sendOnlyToGM),
				makeTextButton('Player Show', state[statusState].config.userAllowed, '!condition config status userAllowed|'+!state[statusState].config.userAllowed),
				makeTextButton('Player Toggle', state[statusState].config.userToggle, '!condition config status userToggle|'+!state[statusState].config.userToggle),
				makeTextButton('Show Status Change', state[statusState].config.showDescOnStatusChange, '!condition config status showDescOnStatusChange|'+!state[statusState].config.showDescOnStatusChange),
				makeTextButton('Display Icon in Chat', state[statusState].config.showIconInDescription, '!condition config status showIconInDescription|'+!state[statusState].config.showIconInDescription),
				makeTextButton('Show Conditions', state[statusState].config.showConditions, '!condition config status showConditions|?{Show|All|Favorites}'),	
				makeTextButton('Clear Conditions on Close', state[statusState].config.clearConditions, '!condition config status clearConditions|'+!state[statusState].config.clearConditions),
			],			
			contents = makeList(listItems, backButton);	

        makeAndSendMenu(contents, 'Status Setup', 'gm')		
	},
	
    sendConditionsMenu = (message) => {
        let key, duration, direction, override,	condition, conditionButton, favorite, icon,	output,
            backButton = makeBigButton('Back', '!ct' + ' config'),
			addButton = makeBigButton('Add Condition', '!condition add ?{Name}'),
			listItems = [],
            icons = [],
            check = true,
			contents = '<div>Icon Name <span style="float:right">(Dir,Dur,Ovr,Fav)</span></div>'
			
        for (key in state[statusState].conditions) {
            condition       = state[statusState].conditions[key]
            conditionButton = makeButton(state[statusState].conditions[key].name, '!condition condition ' + key)
			icon            = getIcon(state[statusState].conditions[key].icon,'display:inline-block;',24,24)
			
			if (!condition.duration) {
				duration = 'N'
			} else {
				duration = condition.duration
			}	
			if (!condition.direction) {
				direction = 'N'
			} else {
				direction = condition.direction
			}	
			if (!condition.override) {
				override = 'N'
			} else {
				override = 'Y'
			}		
			if (condition.favorite) {
			    favorite = 'Y'
			} else {
			    favorite = 'N'
			}

            listItems.push(icon+'<span>'+conditionButton+'</span><span style="float:right">('+duration+','+direction+','+override+','+favorite+')</span>');

            if(check && icons.includes(state[statusState].conditions[key].icon)){
                message = message || '' + '<br>Multiple conditions use the same icon';
                check = false;
            }
        }

        message = (message) ? '<p style="color: red">'+message+'</p>' : '';
        contents += message + makeList(listItems, backButton, addButton);
        makeAndSendMenu(contents, 'Conditions');
    },

    sendConditionMenu = (key) => {
        let condition           = state[statusState].conditions[key]
        
        if (debug) {
            log('Send Condition Menu')
            log('Key:'+key)
            log('Condition:'+condition)
        }
        
        if (typeof condition.description == 'undefined') {
            condition.description = ' '
        }
        
		let	removeButton        = makeBigButton('Delete Condition', '!condition remove '+key+' ?{Are you sure?|Yes,yes|No,no}'),
			descriptionButton   = makeBigButton('Edit Description', '!condition update '+key+' description|?{Description|'+condition.description+'}'),
			backButton
	    
	    if (state[combatState].config.returnToTracker) {
	        backButton          = makeBigButton('Back', '!ct', buttonStyle + ' width: 100%')
	    } else {
	        backButton          = makeBigButton('Back', '!condition config list', buttonStyle + ' width: 100%')
	    }
	    
		let	markerDropdown = '?{Marker';		
        markers.forEach((marker) => {
            markerDropdown += '|'+ucFirst(marker).replace(/-/g, ' ')+','+marker
        })
        markerDropdown += '}';

		let	listItems = [
				makeTextButton('Name', condition.name, '!condition update '+key+' name|?{Name}'),
				makeTextButton('Marker', getIcon(condition.icon) || condition.icon, '!condition update '+key+' icon|'+markerDropdown),				
				makeTextButton('Duration', condition.duration, '!condition update '+key+' duration|?{Duration|1}'),
				makeTextButton('Direction', condition.direction, '!condition update '+key+' direction|?{Direction|0}'),
				makeTextButton('Override', condition.override, '!condition update '+key+' override|'+!condition.override),
				makeTextButton('Favorites', condition.favorite, '!condition update '+key+' favorite|'+!condition.favorite)
			];

		let contents = makeList(listItems)+'<hr>'+descriptionButton+'<b>Description:</b>'+condition.description+removeButton+'<hr>'+backButton 	
        makeAndSendMenu(contents, 'Condition Setup');
    },

    sendTrackerMenu = (senderId) => {
		if (typeof senderId === 'undefined') {
			senderId = 'gm'
		}								
        let nextButton          = makeImageButton('!ct next b',nextImage,'Next Turn','transparent',18),
            prevButton          = makeImageButton('!ct prev b',prevImage,'Previous Turn','transparent',18),
            stopButton          = makeImageButton('!ct stop b',stopImage,'Stop Combat','transparent',18),
            startButton         = makeImageButton('!ct start b',startImage,'Start Combat','transparent',18),
            pauseTimerButton    = makeImageButton('!ct pt b',pauseImage,'Pause Timer','transparent',18),
            stopTimerButton     = makeImageButton('!ct st b',timerImage,'Stop Timer','transparent',18),
            allConditionsButton = makeImageButton('!ct all b',allConditionsImage,'Show All Conditions','transparent',18),
            favoritesButton     = makeImageButton('!ct fav b',favoriteImage,'Show Favorites','transparent',18),
            configButton        = makeImageButton('!ct tracker b',backImage,'Show Setup','transparent',18),
            showButton          = makeImageButton('!ct show b',showImage,'Show Conditions','transparent',18),
            sortButton          = makeImageButton('!ct sort b',sortImage,'Sort Turnorder','transparent',18),
            listItems           = [],
            titleText           = 'CombatTracker Menu<span style="' + styles.version + '"> (' + version + ')</span>',
            contents, key, condition, conditionButton, addButton, removeButton,favoriteButton,listContents;

        state[combatState].config.returnToTracker = true
        
        if (inFight() ) {
            contents = '<div style="background-color:green;width:100%;padding:2px;vertical-align:middle">'+stopButton + prevButton + nextButton + pauseTimerButton + stopTimerButton + showButton + sortButton
            if (state[statusState].config.showConditions == 'Favorites'){
                contents += allConditionsButton
            } else {
                contents += favoritesButton
            } 
        } else {
            contents = '<div style="background-color:red">'+startButton 
        }     

        contents += configButton
        contents += '</div>'
        
        for(key in state[statusState].conditions){
            condition       = state[statusState].conditions[key]
            conditionButton = makeImageButton('!condition condition '  + key,backImage,'Edit Condition','transparent',12)
            removeButton    = makeImageButton('!ct remove '  + key,deleteImage,'Remove Condition','transparent',12)
            
            if (condition.override) {
                addButton = makeImageButton('!ct add '+key +' ?{Duration|'+condition.duration+'} ?{Direction|'+condition.direction + '}' ,addImage,'Add Condition','transparent',12)
            } else {
                addButton = makeImageButton('!ct add '+key+' '+condition.duration+' '+condition.direction,addImage,'Add Condition','transparent',12)
            }
            
            if (condition.favorite) {
                favoriteButton = makeImageButton('!condition favorite '+key+' favorite|'+!condition.favorite,favoriteImage,'Remove from Favorites','transparent',12)
            } else {
                favoriteButton = makeImageButton('!condition favorite '+key+' favorite|'+!condition.favorite,allConditionsImage,'Add to Favorites','transparent',12)
            }

            listContents = '<div>'
            listContents += getIcon(state[statusState].conditions[key].icon,'display:inline-block;margin-right:3px')
            listContents += '<span style="vertical-align:middle">'+condition.name+'</span>'
            listContents += '<span style="float:right;vertical-align:middle">'+addButton+removeButton+favoriteButton+conditionButton+'</span>'
            listContents += '</div>'
            
            if (state[statusState].config.showConditions == 'Favorites') {
                if (state[statusState].conditions[key].favorite) {
                    listItems.push(listContents);
                }    
            } else {
                listItems.push(listContents);
            }
        }
        makeAndSendMenu(contents+makeList(listItems),titleText,senderId);
    },
    
    showConditions = (tokens, senderId) => {
        let tokenObj
        
        if (tokens) {
            tokens.forEach(token => {
                if (token._type == 'graphic') {
                    tokenObj = getObj('graphic', token._id);
                    announcePlayer(tokenObj, senderId, false, false, true);
                }
            })    
        }    
    },
    
    makeAndSendMenu = (contents, title, whisper) => {
        whisper = (whisper && whisper !== '') ? '/w ' + whisper + ' ' : '';
		title = makeTitle(title)
        sendChat(script_name, whisper + '<div style="'+styles.menu+styles.overflow+'">'+title+contents+'</div>', null, {noarchive:true});
    },

	makeTitle = (title) => {
		return '<div style="'+styles.title+'">'+title+'</div>'+'<div style="font-weight: bold; border-bottom: 1px solid black;font-size: 100%;style="float:left;"></div>'
	},
	
    makeBigButton = (title, href) => {
        return '<div style="width:100%"><a style="'+styles.button+'" href="'+href+'">'+title+'</a></div>';
    },

	makeButton = (title, href, style) => {
        return '<a style="'+styles.linkButton+'" href="'+href+'">'+title+'</a>';
    },

	makeTextButton = (label, value, href) => {
        return '<span style="'+styles.textLabel+'">'+label+'</span><a style="'+styles.textButton+'" href="'+href+'">'+value+'</a>';
    },

    makeImageButton = function(command, image, toolTip, backgroundColor,size){
        return '<div style="display:inline-block;margin-top:5px;margin-bottom:5px;margin-right:3px;padding:1px;vertical-align:middle;"><a href="'+command+'" title= "'+toolTip+'" style="margin:0px;padding:0px;border:0px solid;background-color:'+backgroundColor+'"><span style="color:black;padding:0px;font-size:'+size+'px;font-family: \'Pictos\'">'+image+'</span></a></div>'
    },
	
    makeList = (items, backButton, extraButton) => {
        let list;
        
        list  = '<ul style="'+styles.reset + styles.list + styles.overflow+'">'
		items.forEach((item) => {
            list += '<li style="'+styles.overflow+'">'+item+'</li>';
        });
		list += '</ul>'
		
		if (extraButton) {
			list += extraButton
		}
		if(backButton) {
			list += '<hr>'+backButton;
		}
        return list;
    },

    sendConditionToChat = (condition) => {
        let icon = (state[statusState].config.showIconInDescription) ? getIcon(condition.icon, 'margin-right: 5px; margin-top: 5px; display: inline-block;') || '' : '';

        if (debug) {
            log('Send Condition To Chat')
        }
        makeAndSendMenu(condition.description, icon+condition.name,(state[statusState].config.sendOnlyToGM) ? 'gm' : '');
    },
    
    getCombatConditionByName = (tokenID, name) => {
        state[combatState].conditions[tokenID].forEach((condition) => {
            if (condition.name == name) {
                return true
            }
        })
        return false;
    },

    getConditionByMarker = (marker) => {
        return getObjects(state[statusState].conditions, 'icon', marker).shift() || false;
    },

    getConditionByKey = (key) => {
        return state[statusState].conditions[key];
    },

    getIcon = (icon, style='', height, width) => {
        let X = '';
        let iconStyle = ''
        let iconSize = ''

        if(typeof icon_image_positions[icon] === 'undefined') return false;

        if (width) {
            iconStyle += 'width: '+width+'px;height: '+height+'px;';
        } else {
            iconStyle += 'width: 24px; height: 24px;';
        }      
        
        if(Number.isInteger(icon_image_positions[icon])){
            iconStyle += 'background-image: url(https://roll20.net/images/statussheet.png);'
            iconStyle += 'background-repeat: no-repeat;'
            iconStyle += 'background-position: -'+icon_image_positions[icon]+'px 0;'
        }else if(icon_image_positions[icon] === 'X'){
            iconStyle += 'color: red; margin-right: 0px;';
            X = 'X';
        }else{
            iconStyle += 'background-color: ' + icon_image_positions[icon] + ';';
            iconStyle += 'border: 1px solid white; border-radius: 50%;'
        }

        iconStyle += style;

        return '<div style="vertical-align:middle;'+iconStyle+'">'+X+'</div>';
    },
    
    checkInstall = () => {
        if(!_.has(state, combatState)){
            state[combatState] = state[combatState] || {};
            state[statusState] = state[statusState] || {};
        }
        setDefaults();
        log(script_name + ' Ready! Command: !'+state[combatState].config.command);
    },

    handeIniativePageChange = (obj,prev) => {
        if(state[combatState].config.close_stop && (obj.get('initiativepage') !== prev.initiativepage && !obj.get('initiativepage'))){
            stopCombat();
        }
    },

    observeTokenChange = function(handler){
        if(handler && _.isFunction(handler)){
            observers.tokenChange.push(handler);
        }
    },

    notifyObservers = function(event,obj,prev){
        _.each(observers[event],function(handler){
            handler(obj,prev);
        });
    },
    
    handleTurnorderChange = (obj, prev) => {
        if (debug) {
            log("Handle Turnorder Change")
        }
        
        if(obj.get('turnorder') === prev.turnorder) return;

        let turnorder = (obj.get('turnorder') === "") ? [] : JSON.parse(obj.get('turnorder'));
        let prevTurnorder = (prev.turnorder === "") ? [] : JSON.parse(prev.turnorder);

        if(obj.get('turnorder') === "[]"){
            resetMarker();
            stopTimer();
            return;
        }

        if(turnorder.length && prevTurnorder.length && turnorder[0].id !== prevTurnorder[0].id){
            doTurnorderChange();
        }
    },

    handleGraphicMovement = (obj /*, prev */) => {
        let turnID, objID
        if (debug) {
            log ('Handle Graphic Movement')
        } 
 
        if(!inFight()) return;

        if (obj.hasOwnProperty("id")) {
            if (getCurrentTurn().id && obj.get('id')) {
                if(getCurrentTurn().id === obj.get('id')){
                    changeMarker(obj);
                }
            }   
        }    
    },

    handleShapedSheet = (characterid, condition, add) => {
        if (debug) {
            log ('Handle Shaped Sheet Change')
        } 
        let character = getObj('character', characterid);
        if(character){
            let sheet = getAttrByName(character.get('id'), 'character_sheet', 'current');
            if(!sheet || !sheet.toLowerCase().includes('shaped')) return;
            if(!shaped_conditions.includes(condition)) return;

            let attributes = {};
            attributes[condition] = (add) ? '1': '0';
            setAttrs(character.get('id'), attributes);
        }
    },
    
    handleStatusMarkerChange = (obj, prev) => {
        if (debug) {
            log ('Handle Status Marker Change')
        } 

        prev.statusmarkers = (typeof prev.get === 'function') ? prev.get('statusmarkers') : prev.statusmarkers;

        if(state[statusState].config.showDescOnStatusChange && typeof prev.statusmarkers === 'string'){
            if(obj.get('statusmarkers') !== prev.statusmarkers){

                var prevstatusmarkers = prev.statusmarkers.split(",");
                var statusmarkers = obj.get('statusmarkers').split(",");
                
                if (debug) {
                    log('New Statuses:'+statusmarkers)
                    log('Old Statuses:'+prevstatusmarkers)
                }

                prevstatusmarkers.forEach((marker) => {
                    let condition = getConditionByMarker(marker);
                    if(!condition) return;
                    
                    if(marker !== '' && !statusmarkers.includes(marker)){
                        removeCondition(obj, condition.name.toLowerCase());
                    }
                })
                
                statusmarkers.forEach(function(marker){
                    let condition = getConditionByMarker(marker);
                    if(!condition) return;

                    if(marker !== "" && !prevstatusmarkers.includes(marker)){
                        addCondition(obj, condition.name.toLowerCase(),condition.duration,condition.direction);
                    }
                });

            }
        }
    },

    // handleAttributeChange = (obj, prev) => {
    //     if(!shaped_conditions.includes(obj.get('name'))) return;

    //     let tokens = findObjs({ represents: obj.get('characterid') });

    //     handleConditions([obj.get('name')], tokens, (obj.get('current') === '1') ? 'add' : 'remove')
    // },

    //return an array of objects according to key, value, or key and value matching
    getObjects = (obj, key, val) => {
        var objects = [];
        for (var i in obj) {
            if (!obj.hasOwnProperty(i)) continue;
            if (typeof obj[i] == 'object') {
                objects = objects.concat(getObjects(obj[i], key, val));    
            } else 
            //if key matches and value matches or if key matches and value is not passed (eliminating the case where key matches but passed value does not)
            if (i == key && obj[i] == val || i == key && val == '') { //
                objects.push(obj);
            } else if (obj[i] == val && key == ''){
                //only add if the object is not already in the array
                if (objects.lastIndexOf(obj) == -1){
                    objects.push(obj);
                }
            }
        }
        return objects;
    },

    
    esRE = function (s) {
        var escapeForRegexp = /(\\|\/|\[|\]|\(|\)|\{|\}|\?|\+|\*|\||\.|\^|\$)/g;
        return s.replace(escapeForRegexp,"\\$1");
    },

    HE = (function(){
        var entities={
                //' ' : '&'+'nbsp'+';',
                '<' : '&'+'lt'+';',
                '>' : '&'+'gt'+';',
                "'" : '&'+'#39'+';',
                '@' : '&'+'#64'+';',
                '{' : '&'+'#123'+';',
                '|' : '&'+'#124'+';',
                '}' : '&'+'#125'+';',
                '[' : '&'+'#91'+';',
                ']' : '&'+'#93'+';',
                '"' : '&'+'quot'+';'
            },
            re=new RegExp('('+_.map(_.keys(entities),esRE).join('|')+')','g');
        return function(s){
            return s.replace(re, function(c){ return entities[c] || c; });
        };
    }()),


    ucFirst = (string) => {
        return string.charAt(0).toUpperCase() + string.slice(1);
    },

    
    registerEventHandlers = () => {
        on('chat:message', handleInput);
        on('change:campaign:turnorder', handleTurnorderChange);
        on('change:graphic:statusmarkers', handleStatusMarkerChange);
//        on('change:attribute', handleAttributeChange);		
        on('change:campaign:initiativepage', handeIniativePageChange);
        on('change:graphic:top', handleGraphicMovement);
        on('change:graphic:left', handleGraphicMovement);
        on('change:graphic:layer', handleGraphicMovement);

        if('undefined' !== typeof TokenMod && TokenMod.ObserveTokenChange){
            TokenMod.ObserveTokenChange(function(obj,prev){
                handleStatusMarkerChange(obj,prev);
            });
        }

        if('undefined' !== typeof DeathTracker && DeathTracker.ObserveTokenChange){
            DeathTracker.ObserveTokenChange((obj,prev) => {
                handleStatusMarkerChange(obj,prev);
            });
        }

        if('undefined' !== typeof InspirationTracker && InspirationTracker.ObserveTokenChange){
            InspirationTracker.ObserveTokenChange((obj,prev) => {
                handleStatusMarkerChange(obj,prev);
            });
        }
    },
	
    setDefaults = (reset) => {
	
		log('Defaults')
		
        const combatDefaults = {
            config: {
                command: 'ct',
			    marker_img: 'https://s3.amazonaws.com/files.d20.io/images/52550079/U-3U950B3wk_KRtspSPyuw/thumb.png?1524507826',
				next_marker: false,
				next_marker_img: 'https://s3.amazonaws.com/files.d20.io/images/66352183/90UOrT-_Odg2WvvLbKOthw/thumb.png?1541422636',
				initiative_attribute_name: 'initiative_bonus',
				close_stop: true,
				pull: true,			
				duration: false,
				favorite: false,
				returnToTracker: false,
                turnorder: {
                    throw_initiative: true,
                    ini_die: 20,
                    show_initiative_roll: false,
                    auto_sort: true,
                    reroll_ini_round: false,
                    skip_custom: true,
                },
                timer: {
                    use_timer: true,
                    time: 120,
                    auto_skip: true,
                    chat_timer: true,
                    token_timer: true,
                    token_font: 'Candal',
                    token_font_size: 16,
                    token_font_color: 'rgb(255, 0, 0)'
                },
                announcements: {
                    announce_conditions: false,
                    announce_turn: true,
                    whisper_turn_gm: false,
                    announce_round: true,
                    handleLongName: true,
                    use_fx: false,
                    fx_type: 'nova-holy'
                },
                macro: {
                    run_macro: true,
                    macro_name: 'CT_TURN'
                }
            },
            conditions: []
        };

        if(!state[combatState].config || typeof state[combatState].config == 'undefined' || reset) {
            state[combatState].config = combatDefaults.config;
        }else{
            if(!state[combatState].config.hasOwnProperty('command')){
                state[combatState].config.command = combatDefaults.config.command;
            }		
			if(!state[combatState].config.hasOwnProperty('marker_img')){
				state[combatState].config.marker_img = combatDefaults.config.marker_img;
			}
			if(!state[combatState].config.hasOwnProperty('next_marker')){
				state[combatState].config.next_marker = combatDefaults.config.next_marker;
			}
			if(!state[combatState].config.hasOwnProperty('next_marker_img')){
				state[combatState].config.next_marker_img = combatDefaults.config.next_marker_img;
			}
			if(!state[combatState].config.hasOwnProperty('initiative_attribute_name')){
				state[combatState].config.initiative_attribute_name = combatDefaults.config.initiative_attribute_name;
			}
			if(!state[combatState].config.hasOwnProperty('close_stop')){
				state[combatState].config.close_stop = combatDefaults.config.close_stop;
			}
			if(!state[combatState].config.hasOwnProperty('pull')){
				state[combatState].config.pull = combatDefaults.config.pull;
			}
			if(!state[combatState].config.hasOwnProperty('favorite')){
				state[combatState].config.favorite = combatDefaults.config.favorite;
			}  		
			if(!state[combatState].config.hasOwnProperty('returnToTracker')){
				state[combatState].config.returnToTracker = combatDefaults.config.returnToTracker;
			}  		
			
						
            if(!state[combatState].config.hasOwnProperty('turnorder')){
                state[combatState].config.turnorder = combatDefaults.config.turnorder;
            }else{
                if(!state[combatState].config.turnorder.hasOwnProperty('skip_custom')){
                    state[combatState].config.turnorder.skip_custom = combatDefaults.config.turnorder.skip_custom;
                }
                if(!state[combatState].config.turnorder.hasOwnProperty('throw_initiative')){
                    state[combatState].config.turnorder.throw_initiative = combatDefaults.config.turnorder.throw_initiative;
                }
                if(!state[combatState].config.turnorder.hasOwnProperty('ini_die')){
                    state[combatState].config.turnorder.ini_die = combatDefaults.config.turnorder.ini_die;
                }
                if(!state[combatState].config.turnorder.hasOwnProperty('auto_sort')){
                    state[combatState].config.turnorder.auto_sort = combatDefaults.config.turnorder.auto_sort;
                }
                if(!state[combatState].config.turnorder.hasOwnProperty('reroll_ini_round')){
                    state[combatState].config.turnorder.reroll_ini_round = combatDefaults.config.turnorder.reroll_ini_round;
                }
            }
			
            if(!state[combatState].config.hasOwnProperty('timer')){
                state[combatState].config.timer = combatDefaults.config.timer;
            }else{
                if(!state[combatState].config.timer.hasOwnProperty('use_timer')){
                    state[combatState].config.timer.use_timer = combatDefaults.config.timer.use_timer;
                }
                if(!state[combatState].config.timer.hasOwnProperty('time')){
                    state[combatState].config.timer.time = combatDefaults.config.timer.time;
                }
                if(!state[combatState].config.timer.hasOwnProperty('auto_skip')){
                    state[combatState].config.timer.auto_skip = combatDefaults.config.timer.auto_skip;
                }
                if(!state[combatState].config.timer.hasOwnProperty('chat_timer')){
                    state[combatState].config.timer.chat_timer = combatDefaults.config.timer.chat_timer;
                }
                if(!state[combatState].config.timer.hasOwnProperty('token_timer')){
                    state[combatState].config.timer.token_timer = combatDefaults.config.timer.token_timer;
                }
                if(!state[combatState].config.timer.hasOwnProperty('token_font')){
                    state[combatState].config.timer.token_font = combatDefaults.config.timer.token_font;
                }
                if(!state[combatState].config.timer.hasOwnProperty('token_font_size')){
                    state[combatState].config.timer.token_font_size = combatDefaults.config.timer.token_font_size;
                }
                if(!state[combatState].config.timer.hasOwnProperty('token_font_color')){
                    state[combatState].config.timer.token_font_color = combatDefaults.config.timer.token_font_color;
                }
            }
			
            if(!state[combatState].config.hasOwnProperty('announcements')){
                state[combatState].config.announcements = combatDefaults.config.announcements;
            }else{
                if(!state[combatState].config.announcements.hasOwnProperty('announce_turn')){
                    state[combatState].config.announcements.announce_turn = combatDefaults.config.announcements.announce_turn;
                }
                if(!state[combatState].config.announcements.hasOwnProperty('whisper_turn_gm')){
                    state[combatState].config.announcements.whisper_turn_gm = combatDefaults.config.announcements.whisper_turn_gm;
                }
                if(!state[combatState].config.announcements.hasOwnProperty('announce_round')){
                    state[combatState].config.announcements.announce_round = combatDefaults.config.announcements.announce_round;
                }
                if(!state[combatState].config.announcements.hasOwnProperty('announce_conditions')){
                    state[combatState].config.announcements.announce_conditions = combatDefaults.config.announcements.announce_conditions;
                }
                if(!state[combatState].config.announcements.hasOwnProperty('handleLongName')){
                    state[combatState].config.announcements.handleLongName = combatDefaults.config.announcements.handleLongName;
                }
                if(!state[combatState].config.announcements.hasOwnProperty('use_fx')){
                    state[combatState].config.announcements.use_fx = combatDefaults.config.announcements.use_fx;
                }
                if(!state[combatState].config.announcements.hasOwnProperty('fx_type')){
                    state[combatState].config.announcements.fx_type = combatDefaults.config.announcements.fx_type;
                }
            }
			
            if(!state[combatState].config.hasOwnProperty('macro')){
                state[combatState].config.macro = combatDefaults.config.macro;
            }else{
                if(!state[combatState].config.macro.hasOwnProperty('run_macro')){
                    state[combatState].config.macro.run_macro = combatDefaults.config.macro.run_macro;
                }
                if(!state[combatState].config.macro.hasOwnProperty('macro_name')){
                    state[combatState].config.macro.macro_name = combatDefaults.config.macro.macro_name;
                }
            }
        }
        
        if(!state[combatState].hasOwnProperty('conditions')){
            state[combatState].conditions = combatDefaults.conditions;
        } else if (state[combatState].conditions != null && typeof state[combatState].conditions == 'object') {
            state[combatState].conditions = combatDefaults.conditions;
        }


        const statusDefaults = {
            config: {
                command: 'condition',
                userAllowed: false,
                userToggle: false,
                sendOnlyToGM: false,
                showDescOnStatusChange: true,
                showIconInDescription: true,
                showConditions: 'All',
                clearConditions: false
            },
            conditions: {
                blinded: {
                    name: 'Blinded',
                    description: '<p>A blinded creature can’t see and automatically fails any ability check that requires sight.</p> <p>Attack rolls against the creature have advantage, and the creature’s Attack rolls have disadvantage.</p>',
                    icon: 'bleeding-eye',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                charmed: {
                    name: 'Charmed',
                    description: '<p>A charmed creature can’t Attack the charmer or target the charmer with harmful Abilities or magical effects.</p> <p>The charmer has advantage on any ability check to interact socially with the creature.</p>',
                    icon: 'broken-heart',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                deafened: {
                    name: 'Deafened',
                    description: '<p>A deafened creature can’t hear and automatically fails any ability check that requires hearing.</p>',
                    icon: 'edge-crack',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                frightened: {
                    name: 'Frightened',
                    description: '<p>A frightened creature has disadvantage on Ability Checks and Attack rolls while the source of its fear is within line of sight.</p> <p>The creature can’t willingly move closer to the source of its fear.</p>',
                    icon: 'screaming',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                grappled: {
                    name: 'Grappled',
                    description: '<p>A grappled creature’s speed becomes 0, and it can’t benefit from any bonus to its speed.</p> <p>The condition ends if the Grappler is <i>incapacitated</i>.</p> <p>The condition also ends if an effect removes the grappled creature from the reach of the Grappler or Grappling effect, such as when a creature is hurled away by the Thunderwave spell.</p>',
                    icon: 'grab',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                incapacitated: {
                    name: 'Incapacitated',
                    description: '<p>An incapacitated creature can’t take actions or reactions.</p>',
                    icon: 'interdiction',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                inspiration: {
                    name: 'Inspiration',
                    description: '<p>If you have inspiration, you can expend it when you make an Attack roll, saving throw, or ability check. Spending your inspiration gives you advantage on that roll.</p> <p>Additionally, if you have inspiration, you can reward another player for good roleplaying, clever thinking, or simply doing something exciting in the game. When another player character does something that really contributes to the story in a fun and interesting way, you can give up your inspiration to give that character inspiration.</p>',
                    icon: 'black-flag',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                invisibility: {
                    name: 'Invisibility',
                    description: '<p>An invisible creature is impossible to see without the aid of magic or a Special sense. For the purpose of Hiding, the creature is heavily obscured. The creature’s location can be detected by any noise it makes or any tracks it leaves.</p> <p>Attack rolls against the creature have disadvantage, and the creature’s Attack rolls have advantage.</p>',
                    icon: 'ninja-mask',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                paralyzed: {
                    name: 'Paralyzed',
                    description: '<p>A paralyzed creature is <i>incapacitated</i> and can’t move or speak.</p> <p>The creature automatically fails Strength and Dexterity saving throws.</p> <p>Attack rolls against the creature have advantage.</p> <p>Any Attack that hits the creature is a critical hit if the attacker is within 5 feet of the creature.</p>',
                    icon: 'pummeled',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                petrified: {
                    name: 'Petrified',
                    description: '<p>A petrified creature is transformed, along with any nonmagical object it is wearing or carrying, into a solid inanimate substance (usually stone). Its weight increases by a factor of ten, and it ceases aging.</p> <p>The creature is <i>incapacitated</i>, can’t move or speak, and is unaware of its surroundings.</p> <p>Attack rolls against the creature have advantage.</p> <p>The creature automatically fails Strength and Dexterity saving throws.</p> <p>The creature has Resistance to all damage.</p> <p>The creature is immune to poison and disease, although a poison or disease already in its system is suspended, not neutralized.</p>',
                    icon: 'frozen-orb',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                poisoned: {
                    name: 'Poisoned',
                    description: '<p>A poisoned creature has disadvantage on Attack rolls and Ability Checks.</p>',
                    icon: 'chemical-bolt',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                prone: {
                    name: 'Prone',
                    description: '<p>A prone creature’s only Movement option is to crawl, unless it stands up and thereby ends the condition.</p> <p>The creature has disadvantage on Attack rolls.</p> <p>An Attack roll against the creature has advantage if the attacker is within 5 feet of the creature. Otherwise, the Attack roll has disadvantage.</p>',
                    icon: 'back-pain',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                restrained: {
                    name: 'Restrained',
                    description: '<p>A restrained creature’s speed becomes 0, and it can’t benefit from any bonus to its speed.</p> <p>Attack rolls against the creature have advantage, and the creature’s Attack rolls have disadvantage.</p> <p>The creature has disadvantage on Dexterity saving throws.</p>',
                    icon: 'fishing-net',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                stunned: {
                    name: 'Stunned',
                    description: '<p>A stunned creature is <i>incapacitated</i>, can’t move, and can speak only falteringly.</p> <p>The creature automatically fails Strength and Dexterity saving throws.</p> <p>Attack rolls against the creature have advantage.</p>',
                    icon: 'fist',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
                unconscious: {
                    name: 'Unconscious',
                    description: '<p>An unconscious creature is <i>incapacitated</i>, can’t move or speak, and is unaware of its surroundings.</p> <p>The creature drops whatever it’s holding and falls prone.</p> <p>The creature automatically fails Strength and Dexterity saving throws.</p> <p>Attack rolls against the creature have advantage.</p> <p>Any Attack that hits the creature is a critical hit if the attacker is within 5 feet of the creature.</p>',
                    icon: 'sleepy',
                    duration: 1,
					direction: -1,
					override: true,
					favorite: false
                },
            },
        };

        if(!state[statusState].config || typeof state[statusState].config == 'undefined' || reset){
            state[statusState].config = statusDefaults.config;
        }else{
            if(!state[statusState].config.hasOwnProperty('command')){
                state[statusState].config.command = statusDefaults.config.command;
            }
            if(!state[statusState].config.hasOwnProperty('userAllowed')){
                state[statusState].config.userAllowed = statusDefaults.config.userAllowed;
            }
            if(!state[statusState].config.hasOwnProperty('userToggle')){
                state[statusState].config.userToggle = statusDefaults.config.userToggle;
            }
            if(!state[statusState].config.hasOwnProperty('sendOnlyToGM')){
                state[statusState].config.sendOnlyToGM = statusDefaults.config.sendOnlyToGM;
            }
            if(!state[statusState].config.hasOwnProperty('showDescOnStatusChange')){
                state[statusState].config.showDescOnStatusChange = statusDefaults.config.showDescOnStatusChange;
            }
            if(!state[statusState].config.hasOwnProperty('showIconInDescription')){
                state[statusState].config.showIconInDescription = statusDefaults.config.showIconInDescription;
            }
            if(!state[statusState].config.hasOwnProperty('showConditions')){
                state[statusState].config.showConditions = statusDefaults.config.showConditions;
            }           
            if(!state[statusState].config.hasOwnProperty('clearConditions')){
                state[statusState].config.clearConditions = statusDefaults.config.clearConditions;
            }                
        }

        if(!state[statusState].hasOwnProperty('conditions')){
            state[statusState].conditions = statusDefaults.conditions;
        }
    };

    return {
        CheckInstall: checkInstall,
        RegisterEventHandlers: registerEventHandlers,
        ObserveTokenChange: observeTokenChange,
        getConditions,
        getConditionByKey,
        // handleConditions,
        sendConditionToChat,
        getIcon	
    };
})();

on('ready',function() {
    'use strict';

    CombatTracker.CheckInstall();
    CombatTracker.RegisterEventHandlers();
});