tef-animation 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3bc7c194c8425278ad0369c293684b65008f293f
+  data.tar.gz: b59ce88b52067a8c5b2b8c2070e7abf408d073e5
+SHA512:
+  metadata.gz: 9e1c4ed9339a1054e69a5b2074e6f1741da37c3490e7cac055c1f696ad3e6365ecc2b2dda615265df8d3ebd072f1a9b9665d3ca9ef9e31bb9a8fd42c53a5c02a
+  data.tar.gz: 13d28689ecdd5bba1fbb8028076b39ba3623b62b0f7b8f7e38cafdf108941395907790509bef2d340939eb4b1e817561f12d5a01185e95466d20fb2b5e417b74

data/README.md

@@ -0,0 +1,6 @@
+
+# TheElectricFursuit Animation and Sequencing
+
+This... Is a stub for now. Stay tuned for documentation!
+OR!
+Head to github.com/Xasin/system-synth-suit/Ruby/VoiceControl and see how this works.

data/lib/tef/Animation/Animatable.rb

@@ -0,0 +1,213 @@
+
+require_relative 'Value.rb'
+require_relative 'Color.rb'
+require_relative 'Coordinate.rb'
+
+module TEF
+	module Animation
+		class Animatable
+			attr_reader :module_id
+			attr_reader :death_time
+
+			attr_reader :death_delay
+
+			def self.get_attr_list
+				@class_attribute_list ||= {}
+			end
+			def self.get_color_list
+				@class_color_list ||= {}
+			end
+			def self.get_coordinate_list
+				@class_coordinate_list ||= {}
+			end
+
+			def self.animatable_attr(name, id)
+				get_attr_list()[name] = id
+
+				define_method(name.to_s) do
+					@animatable_attributes[name]
+				end
+
+				define_method("#{name}=") do |arg|
+					if arg.is_a? Numeric
+						@animatable_attributes[name].add = arg
+					else
+						@animatable_attributes[name].from = arg
+					end
+				end
+			end
+
+			def self.animatable_color(name, id)
+				get_color_list()[name] = id
+
+				define_method(name.to_s) do
+					@animatable_colors[name]
+				end
+
+				define_method("#{name}=") do |arg|
+					@animatable_colors[name].target = arg
+				end
+			end
+
+			def self.animatable_coordinate(name, start)
+				get_coordinate_list()[name] = start
+
+				define_method(name.to_s) do
+					@animatable_coordinates[name]
+				end
+			end
+
+			def initialize()
+				@animatable_attributes = {}
+				@animatable_colors = {}
+				@animatable_coordinates = {}
+
+				self.class.get_attr_list.each do |key, val|
+					@animatable_attributes[key] = Value.new(val)
+				end
+
+				self.class.get_color_list.each do |key, val|
+					@animatable_colors[key] = Color.new(val)
+				end
+
+				self.class.get_coordinate_list.each do |key, offset|
+					@animatable_coordinates[key] = Coordinate.new(offset)
+				end
+			end
+
+			def death_time=(n_time)
+				raise ArgumentError, 'Must be a Time!' unless n_time.is_a? Time || n_time.nil?
+
+				return if n_time == @death_time
+
+				@death_time = n_time
+				@death_time_changed = true
+			end
+
+			def die_in(t)
+				if t.nil?
+					self.death_time = nil
+					@death_delay = nil
+
+					return
+				end
+
+				raise ArgumentError, "Time must be num!" unless t.is_a? Numeric
+
+				self.death_time = Time.now() + t
+				@death_delay = t
+			end
+
+			def die!
+				self.death_time = Time.at(0)
+			end
+
+			def configure(h = nil, **opts)
+				h ||= opts;
+
+				raise ArgumentError, 'Config must be a hash!' unless h.is_a? Hash
+
+				h.each do |key, data|
+					value = 	@animatable_attributes[key] ||
+								@animatable_colors[key] ||
+								@animatable_coordinates[key]
+
+					raise ArgumentError, "Parameter #{key} does not exist!" unless value
+
+					value.configure(data);
+				end
+			end
+
+			def creation_string
+				""
+			end
+
+			def all_animatable_attributes
+				out =  @animatable_attributes.values
+				out += @animatable_coordinates.values.map(&:animatable_attributes)
+
+				out.flatten
+			end
+
+			def module_id=(new_str)
+				unless new_str =~ /^S[\d]{1,3}M[\d]{1,3}$/ || new_str.nil?
+					raise ArgumentError, 'Target must be a valid Animation Value'
+				end
+
+				all_animatable_attributes.each do |value|
+					value.module_id = new_str
+				end
+
+				die_in @death_delay if @death_delay
+
+				@module_id = new_str
+			end
+
+			def death_time_string
+				return nil unless @death_time_changed
+
+				@death_time_changed = false
+
+				return "#{@module_id} N;" if @death_time.nil?
+
+				remaining_time = (@death_time - Time.now()).round(2)
+
+				"#{@module_id} #{remaining_time};"
+			end
+
+			def get_set_strings()
+				return [] unless @module_id
+
+				out_elements = []
+
+				all_animatable_attributes.each do |val|
+					o_str = val.set_string
+					next if o_str.nil?
+
+					out_elements << { module: @module_id, value: val.ID, str: o_str };
+				end
+
+				out_elements
+			end
+
+			def get_setc_strings()
+				return [] unless @module_id
+
+				out_elements = []
+
+				@animatable_colors.values.each do |val|
+					o_str = val.set_string
+					next if o_str.nil?
+
+					out_elements << "#{@module_id}#{o_str}"
+				end
+
+				out_elements
+			end
+		end
+
+		class Box < Animatable
+			animatable_color :color, 0
+
+			animatable_attr :rotation, 0
+			animatable_attr :up, 1
+			animatable_attr :down, 2
+			animatable_attr :left, 3
+			animatable_attr :right, 4
+
+			animatable_coordinate :x_dir, 0xC000
+			animatable_coordinate :y_dir, 0xC100
+			animatable_coordinate :center, 0xC200
+
+			def initialize(layer_no = 0)
+				super();
+
+				@layer = layer_no;
+			end
+
+			def creation_string
+				"BOX #{@module_id} #{@layer}"
+			end
+		end
+	end
+end

data/lib/tef/Animation/Animation_Handler.rb

@@ -0,0 +1,180 @@
+
+require 'xasin_logger'
+
+require_relative 'Animatable.rb'
+
+module TEF
+	module Animation
+		class Handler
+			include XasLogger::Mix
+
+			def initialize(furcoms_bus)
+				@furcoms = furcoms_bus
+
+				@animation_mutex = Mutex.new
+				@active_animations = {}
+
+				@pending_deletions = {}
+				@pending_creations = {}
+
+				init_x_log('Animation Handler')
+			end
+
+			def clean_key(key)
+				key = 'S%<S>dM%<M>d' % key if key.is_a? Hash
+
+				unless key =~ /^S[\d]{1,3}M[\d]{1,3}$/
+					raise ArgumentError, 'Target must be a valid Animation Value'
+				end
+
+				key
+			end
+
+			def [](key)
+				@active_animations[clean_key key]
+			end
+
+			def []=(key, new_obj)
+				@animation_mutex.synchronize {
+					key = clean_key key
+
+					@active_animations[key]&.module_id = nil;
+
+					if new_obj.nil?
+						@pending_deletions[key] = true
+
+					elsif new_obj.is_a? Animatable
+						new_obj.module_id = key
+
+						@active_animations[key] = new_obj
+						@pending_creations[key] = new_obj.creation_string
+					else
+						raise ArgumentError, 'New animation object is of invalid type'
+					end
+				}
+			end
+
+			private def join_and_send(topic, data)
+				return if data.empty?
+
+				out_str = '';
+				data.each do |str|
+					if(out_str.length + str.length > 200)
+						@furcoms.send_message topic, out_str
+						out_str = ''
+					end
+
+					out_str += str
+				end
+
+				@furcoms.send_message topic, out_str
+			end
+
+			# TODO Replace this with a time-synched system
+			# using the main synch time
+			private def update_deaths
+				death_reconfigs = [];
+
+				@animation_mutex.synchronize {
+					@active_animations.each do |key, animation|
+						if (!animation.death_time.nil?) && animation.death_time < Time.now()
+							@pending_deletions[key] = :silent
+						end
+
+						new_death = animation.death_time_string
+						next if new_death.nil?
+
+						death_reconfigs << new_death
+					end
+				}
+
+				deletions = []
+				@pending_deletions.each do |key, val|
+					deletions << "#{key};" unless val == :silent
+					@active_animations.delete key
+				end
+				@pending_deletions = {}
+
+				join_and_send('DTIME', death_reconfigs)
+				join_and_send('DELETE', deletions)
+			end
+
+			private def update_creations
+				@pending_creations.each do |key, val|
+					@furcoms.send_message('NEW', val)
+				end
+
+				@pending_creations = {}
+			end
+
+			private def optimize_and_send(messages)
+				last_change = {}
+				out_str = '';
+				can_optimize = false
+
+				messages.each do |change|
+					opt_string = change[:str]
+
+					can_optimize = false if last_change[:module] != change[:module]
+					can_optimize = false if last_change[:value]  != (change[:value] - 1)
+					can_optimize = false if (out_str.length + opt_string.length) > 200
+					can_optimize = false if opt_string[0] == 'S'
+
+					opt_string = "#{change[:module]}V#{change[:value].to_s(16)} #{opt_string}" unless can_optimize
+
+					if opt_string.length + out_str.length > 200
+						@furcoms.send_message 'SET', out_str
+						out_str = ''
+					end
+
+					out_str += opt_string
+
+
+					can_optimize = true
+					last_change = change
+				end
+
+				@furcoms.send_message 'SET', out_str
+			end
+
+			private def update_values()
+				pending_changes = []
+
+				@animation_mutex.synchronize {
+					@active_animations.each do |key, anim|
+						pending_changes += anim.get_set_strings
+					end
+				}
+
+				return if pending_changes.empty?
+				x_logd "Pending changes are #{pending_changes}"
+
+				optimize_and_send pending_changes
+			end
+
+			private def update_colors
+				pending_changes = []
+
+				@animation_mutex.synchronize {
+					@active_animations.each do |key, anim|
+						pending_changes += anim.get_setc_strings
+					end
+				}
+
+				return if pending_changes.empty?
+				x_logd "Pending changes are #{pending_changes}"
+
+				join_and_send 'CSET', pending_changes
+			end
+
+			def update_tick()
+				update_creations
+
+				update_deaths
+
+				update_values
+				update_colors
+			end
+		end
+	end
+end

data/lib/tef/Animation/Color.rb

@@ -0,0 +1,112 @@
+
+module TEF
+	module Animation
+		class Color
+			PARAM_TYPES = [:jump, :velocity, :target, :delay_a, :delay_b];
+
+			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}"
+			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 ![:jump, :velocity].include?(key) && value == @current[key]
+
+				if [:delay_a, :delay_b].include? key
+					@is_animated = true
+				end
+
+				@current[key] = value
+				@changes[key] = true
+			end
+
+			PARAM_TYPES.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.target = data
+				elsif data.is_a? Hash
+					data.each do |key, value|
+						generic_set key, value
+					end
+				else
+					raise ArgumentError, 'Config data must be Hash or Numeric'
+				end
+			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[:target]
+
+					out_str = "V#{@ID} J#{@current[:target].to_s(16)};"
+
+					@changes = {}
+
+					return out_str
+				end
+
+				out_str = ["V#{@ID}"];
+
+				out_str << "J#{@current[:jump].to_s(16)}" if @changes[:jump]
+				out_str << "V#{@current[:velocity].to_s(16)}" if @changes[:velocity]
+
+				config_strs = [];
+				config_strs_out = [];
+				[:target, :delay_a, :delay_b].each do |k|
+					if k == :target
+						config_strs << @current[k].to_s(16)
+					else
+						config_strs << rcut(@current[k])
+					end
+
+					config_strs_out = config_strs.dup if @changes[k]
+				end
+
+				@changes = {}
+
+				(out_str + config_strs_out).join(' ') + ';'
+			end
+		end
+	end
+end