Camscaster.Com

Apps Home | Create an App
Tiers for Fierce
Author: lactose_intolerant
Description Source Code Launch App Current Users
There are 12 other versions of this script.
/**
* Tiers for Fierce 0.7
* Written by lactose_intolerant, 2014
*/
var util = new (function( ) {

	this.map = function( list, transform )
	{
		var result = [];
		for (var i = 0; i < list.length; ++i)
			result.push( transform( list[i] ) );
		return result;
	}

	var secondsInAMinute = 60;
	var secondsInAnHour = 60 * secondsInAMinute;

	var splitSeconds = function( seconds )
	{
		var hours = 0;
		var minutes = 0;
		if (seconds >= secondsInAnHour)
			hours = Math.floor( seconds / secondsInAnHour );
		seconds = seconds - hours * secondsInAnHour;
		if (seconds >= secondsInAMinute)
			minutes = Math.floor( seconds / secondsInAMinute );
		seconds = Math.floor( seconds - minutes * secondsInAMinute );
		return { 
			'seconds' : seconds,
			'minutes' : minutes,
			'hours' : hours 
			};	
	}

	this.createReadableDuration = function( seconds )
	{
		parts = splitSeconds( seconds );
		var components = [];
		if (parts.hours > 0)
			components.push( parts.hours + ":" );
		components.push( parts.minutes + ":" );
		components.push( parts.seconds );
		return components.join( "" );
	}

	this.createReadableDuration2 = function( seconds )
	{
		parts = splitSeconds( seconds );
		var components = [];
		if (parts.hours > 0)
			components.push( parts.hours + " hours" );
		if (parts.minutes > 0)
			components.push( parts.minutes + " minutes" );
		if (components.length == 0 || parts.seconds > 0)
			components.push( parts.seconds + " seconds" );
		return components.join( ", " );
	}

	this.parseDurationString = function( str )
	{
		var match = /(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?/.exec( str );
		if (match == null)
			return null;
		if (match[1] == null && match[2] == null && match[3] == null)
			return null;			
		var seconds = 0;
		if (match[1] != null)
			seconds += parseInt( match[1] ) * secondsInAnHour;
		if (match[2] != null)
			seconds += parseInt( match[2] ) * secondsInAMinute;
		if (match[3] != null)
			seconds += parseInt( match[3] );
		return seconds;
	}

	this.getTimeSinceEpochInSeconds = function( )
	{
		return (new Date( )).valueOf( ) / 1000.0;
	}

	this.mergeObjects = function( a, b )
	{
		var result = {};
		for (k in a)
			result[k] = a[k];
		for (k in b)
			result[k] = b[k];
		return result;
	}

	this.randomArrayItem = function( array )
	{
		var i = Math.floor( Math.random( ) * array.length );
		return array[i];
	}

})( );

var Events = function( names )
{
	var handlers = {};

	var init = function( )
	{
		for (var i = 0; i < names.length; ++i)
			handlers[names[i]] = [];
	}

	this.add = function( event, handler )
	{
		handlers[event].push( handler );
	}

	this.raise = function( event /*, *args */ )
	{
		var raiseArgs = Array.prototype.slice.call( arguments, 1 );
		var rval;
		for (var i = 0; i < handlers[event].length; ++i)
			rval = handlers[event][i].apply( null, raiseArgs );
		return rval;
	}

	init( );
};

var platform = new (function( ) {

	for (var k in cb)
		this[k] = cb[k];

	var _this = this;
	var events = new Events( ["onMessage", "onEnter", "onLeave", "onTip", "onDrawPanel"] );
	var isOnMockPlatform = !!cb.cbUsers;
	
	this.colors = { "fg" : "#000000", "bg" : "#FFFFFF" };
	this.users = {}; 

	var init = function( )
	{
		cb.onMessage( cbOnMessage );
		cb.onDrawPanel( cbOnDrawPanel );
		cb.onTip( cbOnTip );
		if (!isOnMockPlatform)
		{
			cb.onEnter( cbOnEnter );
			cb.onLeave( cbOnLeave );
		}
	}

	var addUser = function( cbUser )
	{
		_this.users[cbUser.user] = cbUser;
	}

	var removeUserByName = function( username )
	{
		delete _this.users[username];
	}

	this.isUserPresent = function( username )
	{
		return username in _this.users;
	}

	this.getUserByName = function( username )
	{
		return _this.users[username];
	}

	this.onMessage = function( handler )
	{
		events.add( "onMessage", handler );
	}

	this.onEnter = function( handler )
	{
		events.add( "onEnter", handler );
	}

	this.onLeave = function( handler )
	{
		events.add( "onLeave", handler );
	}

	this.onDrawPanel = function( handler )
	{
		events.add( "onDrawPanel", handler );
	}

	this.onTip = function( handler )
	{
		events.add( "onTip", handler );
	}

	this.fakeLeave = function( usernameOrObj )
	{
		var cbUser = usernameOrObj;
		if (typeof usernameOrObj == "string")
			cbUser = createFakeUserObj( usernameOrObj );
		cbOnLeave( cbUser );
	}

	this.fakeEnter = function( usernameOrObj )
	{
		var cbUser = usernameOrObj;
		if (typeof usernameOrObj == "string")
			cbUser = createFakeUserObj( usernameOrObj );
		cbOnEnter( cbUser );
	}

	this.setInterval = function( func, timeout )
	{
		cb.setTimeout( 
			function( )
			{
				cb.setTimeout( arguments.callee, timeout );
				try
				{
					func( );
				}
				catch (e)
				{
					handleException( "onTimeout",  e );
				}
			}, timeout );
	}

	var createFakeUserObj = function( name )
	{
		return {
			"user" : name,
			"in_fanclub" : false,
			"has_tokens" : 0,
			"is_mod" : false,
			"tipped_recently" : false,
			"gender" : "m"
		};
	}

	var cbOnMessage = function( cbMsg )
	{
		try
		{
			var cbUser = util.mergeObjects( cbMsg, {} );
			delete cbUser.c;
			delete cbUser.m;
			delete cbUser.f;
			updateUser( cbUser );
			events.raise( "onMessage", cbMsg );
		}
		catch (e)
		{
			handleException( "onMessage", e );
		}
		return cbMsg;
	}

	var cbOnEnter = function( cbUser )
	{
		try
		{
			addUser( cbUser );
			events.raise( "onEnter", cbUser );
		}
		catch (e)
		{
			handleException( "onEnter", e );
		}
	}

	var cbOnLeave = function( cbUser )
	{
		try
		{
			removeUserByName( cbUser.user );
			events.raise( "onLeave", cbUser );
		}
		catch (e)
		{
			handleException( "onLeave", e );
		}
	}

	var cbOnTip = function( cbTip )
	{
		try
		{
			var cbUser = {
					"user" : cbTip.from_user,
					"in_fanclub" : cbTip.from_user_in_fanclub,
					"has_tokens" : cbTip.from_user_has_tokens,
					"is_mod" : cbTip.from_user_is_mod,
					"tipped_recently" : cbTip.from_user_tipped_recently,
					"gender" : cbTip.from_user_gender
				};
			updateUser( cbUser );
			events.raise( "onTip", cbTip );
		}
		catch (e)
		{
			handleException( "onTip", e );
		}
	}

	var updateUser = function( cbUser )
	{
		if (!_this.isUserPresent( cbUser.user ))
			_this.fakeEnter( cbUser );
		else
			addUser( cbUser );
	}

	var cbOnDrawPanel = function( )
	{
		try
		{
			return events.raise( "onDrawPanel" );
		}
		catch (e)
		{
			handleException( "onDrawPanel", e );
		}
	}

	this.announce = function( msg )
	{
		_this.chatNotice( msg, '', _this.colors.bg, _this.colors.fg, 'bold' );
	}

	this.notify = function( username, msg )
	{
		_this.chatNotice( msg, username, _this.colors.bg, _this.colors.fg, 'bold' );
	}

	handleException = function( eventName, e )
	{
		var msg = "<EXCEPTION>: \"" ;
		if ('message' in e)
			msg += e.message;
		else
			msg += e;
		msg += "\"";
		msg += " <EVENT>: " + eventName;
		if ('trace' in e)
			msg += " <TRACE>: " + e.stack;
		cb.log( msg );
	}

	init( );

})( );

var CommandParser = function( )
{
	var commands = [];

	var init = function( )
	{
		platform.onMessage( cbOnMessage );
	}

	this.register = function( key, handler, optModelOnly )
	{
		commands.push( { 'key' : key, 'model' : !!optModelOnly, 'handler' : handler } );
	}

	var cbOnMessage = function( cbMsg )
	{
		var key = getKey( cbMsg.m );
		var cmd = findCommand( cbMsg.user, key );
		if (!!cmd)
		{
			cbMsg['X-Spam'] = true;
			cmd.handler.apply( null, [cbMsg.user].concat( getCommandArgs( cbMsg.m ) ) );
		}
		return cbMsg;
	}

	var getKey = function( msg )
	{
		var m = /^\/(\S+)/.exec( msg );
		if (!!m)
			return m[1];
	}

	var findCommand = function( username, key )
	{
		for (var i = 0; i < commands.length; ++i)
		{
			var cmd = commands[i];
			if (cmd.key == key && (!cmd.model || username == platform.room_slug))
				return cmd;
		}
		return null;
	}

	var getCommandArgs = function( msg )
	{
		var m = /^\/\S+\s+(.*)/.exec( msg );
		if (!m)
			return [];
		return m[1].split( /\s+/ );
	}

	init( );
}

var main = function( )
{
	var tierZeroDescription = 0;
	var tiers = [];
	var tipCounter = 0;
	var lastTick = util.getTimeSinceEpochInSeconds( );
	var activeTier = null;
	var timeLeft = 0;
	var commands = new CommandParser( );
	var paused = false;
	var inflation = 1;
	var inflationPerUser = 1.05;
	var maxInflation = 5;

	var init = function( )
	{
		tierZeroDescription = platform.settings.tier0 || "";
		parseConfigString( platform.settings.config );
		inflationPerUser = parseFloat( platform.settings.inflation ) / platform.settings.inflationPopulation;
		maxInflation = platform.settings.inflation;
		platform.setInterval( onTick, 1500 );
		platform.onTip( onTip );
		platform.onDrawPanel( onDrawPanel );
		platform.onEnter( onEnter );
		platform.colors.fg = "#FFFFFF";
		platform.colors.bg = "#009000";
		commands.register( "pause", onPause, true );
		commands.register( "next", onSkipToNext, true );
		commands.register( "prev", onSkipToPrev, true );
	}

	var parseConfigString = function( configString )
	{
		var fields = configString.split( ";" );
		if (fields.length == 0 || fields.length % 3 != 0)
			throw "Bad configuration string.";
		var tierStartAmount = 0;
		for (var i = 0; i < fields.length / 3; ++i)
		{
			var tier = {};
			tier.description = fields[i*3];
			tier.min = tierStartAmount;
			tier.max = tierStartAmount + parseInt( fields[i*3+1] );
			tier.duration = util.parseDurationString( fields[i*3+2] );
			tiers.push( tier );
			tierStartAmount = tier.max;
		}
	}

	var onTick = function( )
	{
		var dt = util.getTimeSinceEpochInSeconds( ) - lastTick;
		lastTick += dt;
		if (!paused)
			updateTier( dt );
		updateInflation( );
		platform.drawPanel( );
	}

	var updateTier = function( dt )
	{
		var oldTier = activeTier;
		if (activeTier)
		{
			var decayRate = (tipCounter - activeTier.min) / timeLeft;
			tipCounter = Math.max( activeTier.min, tipCounter - decayRate * dt );
			timeLeft -= dt;
			if (timeLeft <= 0)
			{
				activeTier = getPrevTier( );
				setTimeFromTips( );
			}
		}
		if (activeTier != oldTier)
			announceTierDropped( );
	}

	var getInflatedAmount = function( amount )
	{
		return amount * inflation;
	}

	var getDeflatedAmount = function( amount )
	{
		return amount / inflation;
	}

	var announceTierDropped = function( )
	{
		if (activeTier)
			platform.announce( "Tier dropped back to: " + activeTier.description );
		else
			platform.announce( "All tokens have run out!" );
		announceTipProgress( );
	}

	var getTierProgresss = function( )
	{
		if (!activeTier)
			return 0;
		var spread = activeTier.max - activeTier.min;
		return (tipCounter - activeTier.min) / spread;
	}

	var getPrevTier = function( )
	{
		var i = tiers.indexOf( activeTier );
		if (i == 0)
			return null;
		return tiers[i-1];
	}

	var updateInflation = function( )
	{
		var numUsersWithTokens = 0;
		for (var name in platform.users)
			if (platform.users[name].has_tokens)
				numUsersWithTokens++;
		inflation = Math.max( 1, 
			Math.min( maxInflation, numUsersWithTokens * inflationPerUser ) );
	}

	var onTip = function( cbTip )
	{
		var amount = getDeflatedAmount( parseInt( cbTip.amount ) );
		advanceTier( amount );
		announceTipProgress( );
	}

	var announceTipProgress = function( )
	{
		var next = getNextTier( );
		if (next)
		{
			var till = Math.ceil( next.max - tipCounter );
			//platform.announce( "" + till + " tokens left till: " + next.description + "." );
		}
	}

	var advanceTier = function( amount )
	{
		var oldTier = activeTier;
		var amountLeft = amount;
		var oldTime = timeLeft;
		while (amountLeft > 0)
			amountLeft = consumeTipsForTier( amountLeft );
		if (oldTier != activeTier)
			announceTierReached( );
		else if (activeTier)
		{
			var timeAdded = timeLeft - oldTime;
			announceTimeAdded( timeAdded );
		}
	}

	var announceTimeAdded = function( secondsAdded )
	{
		platform.announce( util.createReadableDuration2( secondsAdded )  
			+ " have been added to the timer." );
	}

	var announceTierReached = function( )
	{
		platform.announce( "Tier reached: " + activeTier.description );
		var prev = getPrevTier( );
		platform.announce( 
			"Tip to make requests or to add more time!" );
	}

	var consumeTipsForTier = function( amount )
	{
		var nextTier = getNextTier( );
		var tipsConsumed = 0;
		if (wouldTipNearlyAdvanceToNextTier( amount ))
		{
			tipsConsumed = nextTier.max - tipCounter;
			tipCounter = nextTier.max;
			timeLeft = nextTier.duration;
			activeTier = nextTier;
		}
		else
		{
			tipsConsumed = amount;
			tipCounter += amount;
			setTimeFromTips( );
		}
		return Math.max( 0, amount - tipsConsumed );
	}

	var setTimeFromTips = function( )
	{
		if (!activeTier)
			timeLeft = 0;
		else
		{
			var progress = getTierProgresss( );
			if (progress <= 1)
				timeLeft = progress * activeTier.duration;
			else
				timeLeft = (Math.log( progress ) / Math.log( 5 ) + 1) * activeTier.duration;
		}
	}

	var wouldTipNearlyAdvanceToNextTier = function( amount )
	{
		var nextTier = getNextTier( );
		if (!nextTier)
			return false;
		if (tipCounter + amount >= nextTier.max)
			return true;
		if (activeTier && !paused)
		{
			// TODO some fuzzy logic to make hitting the next tier eassier
			// while racing the token decay 
		}
		return false;
	}

	var getNextTier = function( )
	{
		if (!activeTier)
			return tiers[0];
		var i = tiers.indexOf( activeTier );
		if (i + 1 < tiers.length)
			return tiers[i+1];
		return null;
	}

	var onDrawPanel = function( )
	{
		return template = {
			'template' : "3_rows_11_21_31",
			'row1_value' : createPanelTipProgressString( ),
			'row2_value' : createPanelNowShowingString( ),
			'row3_value' : createPanelNextShowingString( )
		};
	}

	var createPanelNowShowingString = function( )
	{
		if (activeTier)
			return activeTier.description;
		return tierZeroDescription;
	}

	var createPanelTipProgressString = function( )
	{
		if (activeTier)
		{
			return "Time remaining: "  
				+ util.createReadableDuration( timeLeft );
		}
		return Math.floor( getInflatedAmount( tipCounter ) ) + " / " 
			+ Math.ceil( getInflatedAmount( getNextTier( ).max ) );
	}

	var createPanelNextShowingString = function( )
	{
		var next = getNextTier( );
		if (next)
		{
			var needed = Math.ceil( getInflatedAmount( next.max - tipCounter ) );
			return needed + " tokens needed for \"" + next.description + "\"";
		}
		return "Tip to add time!";
	}

	var onEnter = function( cbUser )
	{
		platform.notify( cbUser.user, "Tiers for Fierce running. "
			+ "Tip to make requests, extend the show, or move it forward!" );
		platform.log( "Inflation: " + inflation.toFixed( 2 ) );
	}

	var onPause = function( )
	{
		if (!paused)
		{
			paused = true;
			platform.announce( "Timer paused." );
		}
		else
		{
			paused = false;
			platform.announce( "Timer unpaused." );
		}
	}

	var onSkipToNext = function( )
	{
		var nextTier = getNextTier( );
		if (nextTier)
		{
			tipCounter = nextTier.max;
			activeTier = nextTier;
			setTimeFromTips( );
			announceTierReached( );
		}
	}

	var onSkipToPrev = function( )
	{
		if (!activeTier)
			return;
		var prevTier = getPrevTier( );
		if (prevTier)
		{
			tipCounter = prevTier.max;
			activeTier = prevTier;
		}
		else
		{
			tipCounter = 0;
			activeTier = null;
		}
		setTimeFromTips( );
		announceTierDropped( );
	}

	init( );
}

var initSettings = function( )
{
	cb.settings_choices = [
			{ 
				"name" : "config", 
				"label" : "Configuration string", 
				"type" : "str", 
				"required" : false, 
				"defaultValue" : "",
			},
			{
				"name" : "inflation",
				"label" : "Max Inflation",
				"type" : "str",
				"required" : true,
				"defaultValue" : "5.0"
			},
			{
				"name" : "inflationPopulation",
				"label" : "Max population",
				"type" : "int",
				"required" : true,
				"defaultValue" : "300"
			},
			{
				"name" : "tier0",
				"label" : "Tier 0 description",
				"type" : "str",
				"required" : false,
				"defaultValue" : ""
			}
		];
}

new (function( ) {
	if (Object.keys( cb.settings ).length > 0)
		main( );
	else
		initSettings( );
})( );