Chaos Project

#============================================================================================
# ** ATB
#============================================================================================
module ATB

	#========================================================================================
	# * Group
	#----------------------------------------------------------------------------------------
	#		Group is a simple subclass of Array, meant to be used to hold clients and
	#	update them easily. Can also be overwritten to alter methods such as modifier,
	#	which allows for much more flexible control.
	#========================================================================================
	class Group < Array
		#------------------------------------------------------------------------------------
		# modifier
		#------------------------------------------------------------------------------------
		def modifier
			return 1.0
		end
		
		#------------------------------------------------------------------------------------
		# update
		#------------------------------------------------------------------------------------
		def update(mod = 1.0)
			self.each do |c|
				c.update self.modifier * mod
			end
		end
	end
	
	#========================================================================================
	# * Client
	#----------------------------------------------------------------------------------------
	#		This is a custom-written class that can be used both on its own and as a 
	#	a superclass for more specialized client classes. It holds data on ATB state
	#	and the callback that should be called when the client's ATB bar has filled.
	#========================================================================================
	class Client
		attr_accessor :rate, :progress, :callback
		#------------------------------------------------------------------------------------
		# initialize(rate)
		#------------------------------------------------------------------------------------
		def initialize rate
			@rate = rate
			@progress = 0
			@callback = Proc.new
		end
		
		#------------------------------------------------------------------------------------
		# modifier
		#	-	This method is called by Client#update to dynamically generate
		#		the rate modifier for the client.
		#	-	This can be overwritten by subclasses to allow for interesting effects,
		#		i.e. lowering the speed of a character when their HP/MP is low, etc
		#	-	Defaults to simply returning 1.0.
		#------------------------------------------------------------------------------------
		def modifier
			return 1.0
		end
		
		#------------------------------------------------------------------------------------
		# variance
		#	-	This method is called by Client#upate to dynamically generate the
		#		amount of variance for the ATB update.
		#	-	This can be overwritten by subclasses to allow for interesting effects,
		#		i.e. significantly boosting the maximum variance for actors with high luck
		#	-	Defaults to adding or subtracting up to 1 TP from the client.
		#------------------------------------------------------------------------------------
		def variance
			return (rand(21) - 10) / 10
		end
		
		#------------------------------------------------------------------------------------
		# update
		#------------------------------------------------------------------------------------
		def update mod = 1.0
			@progress += @rate * self.modifier * mod
			@progress += self.variance
			
			if @progress >= 100
				@callback.call self
				@progress = 0
			end
		end
	end
	
end

client = ATB::Client.new(1.0) do |client|
  client.rate = 0 # Client stops doing things when it does the first thing
end

class ATB

	class Group
		
		attr_accessor :modifier
		
		def initialize
			@clients = []
			@modifier = 1.0
		end
		
		def add_client client
			@clients.push client
		end
		
		def empty
			@clients = []
		end
		
		def update(mod = 1.0)
			@clients.each do |c|
				c.update(@modifier * mod)
			end
		end
		
	end
		
	class Client
		
		attr_accessor :modifier, :callback, :rate
		
		def initialize(rate, mod = 1.0)
			@rate = rate
			@modifier = mod
			@callback = Proc.new
			@count = 0
		end
		
		def update(mod = 1.0)
			@count += rate * @modifier * mod
			if @count >= 100
				@callback.call(self)
				@count = 0
			end
		end
	
	end
		
	def initialize
		@groups = []
	end
	
	def add_group g
		@groups.push g
	end
	
	def empty
		@groups = 0
	end
	
	def update
		@groups.each do |g|
			g.upate
		end
	end

end