tef-animation 0.1.0

data/lib/tef/Animation/Coordinate.rb

@@ -0,0 +1,49 @@
+
+$coordinate_def ||= {
+	x: 0,
+	y: 1,
+}
+
+module TEF
+	module Animation
+		class Coordinate
+			$coordinate_def.each do |c, id|
+				define_method(c.to_s) do
+					@animatable_attributes[c]
+				end
+
+				define_method("#{c}=") do |arg|
+					if arg.is_a? Numeric
+						@animatable_attributes[c].add = arg
+					else
+						@animatable_attributes[c].from = arg
+					end
+				end
+			end
+
+			def initialize(start_offset)
+				@animatable_attributes = {}
+
+				$coordinate_def.each do |key, v|
+					@animatable_attributes[key] = Value.new(v + start_offset)
+				end
+			end
+
+			def animatable_attributes
+				@animatable_attributes.values
+			end
+
+			def configure(data)
+				raise ArgumentError, 'Coordinate config must be a hash!' unless data.is_a? Hash
+
+				data.each do |key, value|
+					coord = @animatable_attributes[key]
+
+					raise ArgumentError, "Coordinate #{key} does not exist!" unless coord
+
+					coord.configure value
+				end
+			end
+		end
+	end
+end

data/lib/tef/Animation/Eyes.rb

@@ -0,0 +1,21 @@
+
+require_relative 'Animatable.rb'
+
+module TEF
+	module Animation
+		class Eye < Animatable
+			animatable_color :outer_color, 0
+			animatable_color :inner_color, 1
+
+			animatable_attr :iris_x, 0x10
+			animatable_attr :iris_y, 0x11
+			animatable_attr :top, 0x12
+			animatable_attr :bottom, 0x13
+			animatable_attr :eye_closure, 0x14
+
+			def initialize()
+				super();
+			end
+		end
+	end
+end

data/lib/tef/Animation/Value.rb

@@ -0,0 +1,133 @@
+
+
+module TEF
+	module Animation
+		class Value
+			PARAM_TYPES = 	[:add, :multiply, :dampen, :delay, :from, :jump, :velocity];
+
+			attr_reader :ID
+
+			attr_reader :module_id
+
+			def initialize(value_num)
+				@ID = value_num;
+
+				@current = Hash.new(0);
+				@changes = {}
+
+				@is_animated = false;
+			end
+
+			def module_id=(new_id)
+				@module_id = new_id
+
+				PARAM_TYPES.each do |key|
+					@changes[:key] = true if @current[key] != 0
+				end
+			end
+
+			def total_id()
+				"#{@module_id}V#{@ID.to_s(16)}"
+			end
+
+			def generic_set(key, value)
+				raise ArgumentError, 'Key does not exist!' unless PARAM_TYPES.include? key
+				raise ArgumentError, "Input must be numeric!" unless value.is_a? Numeric
+
+				return if (value == @current[key] && ![:jump, :velocity].include?(key))
+
+				if [:multiply, :dampen, :delay].include? key
+					@is_animated = true
+				end
+
+				@current[key] = value
+				@changes[key] = true
+			end
+
+			[:jump, :velocity, :add, :multiply, :dampen, :delay].each do |key|
+				define_method(key.to_s) do
+					@current[key]
+				end
+
+				define_method("#{key}=") do |input|
+					generic_set key, input
+				end
+			end
+
+			def configure(data)
+				if data.is_a? Numeric
+					self.add = data
+				elsif data.is_a? Hash
+					data.each do |key, value|
+						generic_set key, value
+					end
+				else
+					self.from = data;
+				end
+			end
+
+			def from() return @current[:from] end
+
+			def from=(target)
+				if target.is_a? Value
+					target = target.total_id
+				end
+
+				if target.nil?
+					target = 'S0M0V0'
+				end
+
+				unless target =~ /^S[\d]{1,3}M[\da-f]{1,3}V\d+$/
+					raise ArgumentError, 'Target must be a valid Animation Value'
+				end
+
+				return if target == @current[:from]
+
+				@current[:from] = target
+				@changes[:from] = true
+				@is_animated = true
+			end
+
+			def has_changes?
+				return !@changes.empty?
+			end
+
+			private def rcut(value)
+				value.to_s.gsub(/(\.)0+$/, '')
+			end
+
+			def set_string()
+				return nil unless has_changes?
+
+				if !@is_animated
+					return nil unless @changes[:add]
+
+					out_str = "J#{rcut(@current[:add])};"
+
+					@changes = {}
+
+					return out_str
+				end
+
+				out_str = [];
+
+				out_str << "J#{rcut(@current[:jump])}" if @changes[:jump]
+				out_str << "V#{rcut(@current[:velocity])}" if @changes[:velocity]
+
+				out_str << @current[:from] if @changes[:from]
+
+				config_strs = [];
+				config_strs_out = [];
+				[:add, :multiply, :dampen, :delay].each do |k|
+					config_strs << rcut(@current[k])
+
+					config_strs_out = config_strs.dup if @changes[k]
+				end
+
+				@changes = {}
+
+				(out_str + config_strs_out).join(' ') + ';'
+			end
+		end
+	end
+end

data/lib/tef/ParameterStack/Override.rb

@@ -0,0 +1,66 @@
+
+require_relative 'Stack.rb'
+
+module TEF
+	module ParameterStack
+		class Override
+			include Comparable
+
+			attr_reader :level
+
+			def initialize(stack, init_level = 0)
+				raise ArgumentError, 'Handler must be CoreStack!' unless stack.is_a? Stack
+
+				@stack = stack
+
+				@level = init_level;
+				@overrides = {}
+
+				@valid_until = nil;
+
+				@stack.add_override self
+			end
+
+			def [](key)
+				@overrides[key]
+			end
+
+			def []=(key, new_value)
+				return if @overrides[key] == new_value
+
+				if new_value.nil?
+					delete(key)
+					return
+				end
+
+				@overrides[key] = new_value
+				@stack.override_claims self, key
+			end
+
+			def include?(key)
+				@overrides.include? key
+			end
+			def keys
+				@overrides.keys
+			end
+
+			def delete(key)
+				return unless @overrides.include? key
+				@overrides.delete key
+
+				return unless @stack.active_overrides[key] == self
+
+				@stack.recompute_single key
+			end
+
+			def destroy!
+				@stack.remove_override self
+			end
+
+			def <=>(other)
+				return @level <=> other.level if other.level != @level
+				return self.hash <=> other.hash
+			end
+		end
+	end
+end

data/lib/tef/ParameterStack/Stack.rb

@@ -0,0 +1,149 @@
+
+require_relative 'Override.rb'
+
+module TEF
+	module ParameterStack
+		class Stack
+			attr_reader :changes
+			attr_reader :active_overrides
+
+			def initialize()
+				@current_values   = {}
+				@active_overrides = {}
+
+				@changes = {}
+
+				@override_list_mutex = Mutex.new()
+				@override_list = []
+
+				@recompute_blocks    = []
+				@value_change_blocks = []
+
+				@default_override = Override.new(self, -1);
+			end
+
+			def [](key)
+				@current_values[key]
+			end
+			def []=(key, value)
+				@default_override[key] = value
+			end
+			def keys
+				@current_values.keys
+			end
+
+			def on_recompute(*keys, &block)
+				@recompute_blocks << {
+					block: block,
+					keys: keys
+				}
+			end
+
+			def on_change(*filters, &block)
+				filters = nil if filters.empty?
+
+				@value_change_blocks << {
+					block: block,
+					filters: filters
+				}
+			end
+
+			private def mark_key_change(key)
+				@changes[key] = true
+
+				@recompute_blocks.each do |block_cfg|
+					next unless block_cfg[:keys].include? key
+					block_cfg[:block].call(key, @current_values[key])
+				end
+			end
+
+			def override_claims(override, key)
+				return if !(@active_overrides[key].nil?) && (@active_overrides[key] > override)
+
+				@active_overrides[key] = override;
+				value = override[key];
+
+				return if @current_values[key] == value
+
+				@current_values[key] = value
+				mark_key_change key
+			end
+
+			def recompute_single(key)
+				old_value = @current_values[key]
+
+				found_override = false;
+
+				@override_list_mutex.synchronize do
+					@override_list.each do |override|
+						next unless override.include? key
+
+						@active_overrides[key] = override;
+						@current_values[key]   = override[key];
+
+						found_override = true;
+
+						break;
+					end
+				end
+
+				if !found_override
+					@current_values.delete key
+					@active_overrides.delete key
+				end
+
+				mark_key_change key if old_value != @current_values[key]
+			end
+
+			def recompute(keys)
+				keys.each do |key|
+					recompute_single key
+				end
+			end
+
+			private def keys_match_filters(keys, filters)
+				return true if filters.nil?
+
+				filters = [filters] unless filters.is_a? Array
+
+				filters.each do |filter|
+					keys.each do |key|
+						return true if filter.is_a?(Regexp) && key =~ filter
+						return true if filter.is_a?(String) && key == filter
+					end
+				end
+
+				return false
+			end
+
+			def process_changes()
+				change_list = @changes.keys
+
+				@value_change_blocks.each do |block_cfg|
+					next unless keys_match_filters change_list, block_cfg[:filters]
+
+					block_cfg[:block].call()
+				end
+
+				@changes = {}
+			end
+
+			def add_override(override)
+				@override_list_mutex.synchronize do
+					@override_list << override unless @override_list.include? override
+					@override_list.sort!
+				end
+			end
+
+			def remove_override(override)
+				return unless @override_list.include? override
+
+				@override_list_mutex.synchronize do
+					@override_list.delete override
+				end
+
+				recompute override.keys
+			end
+		end
+	end
+end

data/lib/tef/ProgramSelection/ProgramID.rb

@@ -0,0 +1,56 @@
+
+
+module TEF
+	module ProgramSelection
+		class ID
+			attr_reader :title
+			attr_reader :groups
+			attr_reader :variant
+
+			attr_reader :hash
+
+			def initialize(title, groups, variant)
+				@title = title;
+				@groups = groups.sort
+				@variant = variant
+
+				@hash = @title.hash ^ @groups.hash ^ @variant.hash
+			end
+
+			def ==(other)
+				if other.is_a? String
+					@title == other
+				elsif other.is_a? ID
+					return false if @title != other.title
+					return false if @variant != other.variant
+					return false if @groups != other.groups
+
+					true
+				end
+			end
+			alias eql? ==
+
+			def <=>(other)
+				tsort = (@title <=> other.title)
+				return tsort unless tsort.zero?
+
+				gsort = (@groups <=> other.groups)
+				return gsort unless gsort.zero?
+
+				@variant <=> other.variant
+			end
+
+			def get_scoring(group_weights)
+				score = 0;
+
+				@groups.each do |g|
+					if weight = group_weights[g]
+						score += weight
+					end
+				end
+
+				score
+			end
+		end
+	end
+end