lzrtag-base 1.0.0

data/lib/lzrtag/map/myMaps_parser.rb

@@ -0,0 +1,136 @@
+
+require 'xmlsimple'
+
+require_relative 'map_zone.rb'
+
+module LZRTag
+	module Map
+		class MyMapsParser
+			attr_accessor :styles
+			attr_accessor :polygons
+			attr_accessor :points
+
+			def initialize(filename)
+				@xmlStructure = XmlSimple.xml_in(filename)["Document"][0];
+
+				@styles = Hash.new();
+				_fetch_styles();
+
+				@polygons = Hash.new();
+				@polygons[""] = _fetch_polygons();
+
+				@points = Hash.new();
+				@points[""] = _fetch_marks();
+
+				if(folders = @xmlStructure["Folder"])
+					folders.each do |folder|
+						@polygons[folder["name"][0]] = _fetch_polygons(folder)
+						@points[folder["name"][0]] = _fetch_marks(folder);
+					end
+				end
+			end
+
+			def _fetch_styles()
+				@xmlStructure["Style"].each do |s|
+					id = s["id"];
+					if(id =~ /(.*)-normal$/)
+						id = $1;
+					else
+						next;
+					end
+
+					next unless(s.has_key?("PolyStyle") && s.has_key?("LineStyle"))
+
+					@styles["#" + id] = {
+						color: s["PolyStyle"][0]["color"][0],
+						borderColor: s["LineStyle"][0]["color"][0]
+					};
+				end
+			end
+			private :_fetch_styles
+
+			def _fetch_polygons(folder = nil)
+				folder ||= @xmlStructure;
+
+				outZones = Array.new();
+
+				return outZones unless(placemarks = folder["Placemark"])
+
+				placemarks.each do |zone|
+					next unless zone["Polygon"];
+
+					outZone = Hash.new();
+					outZone[:name]  = zone["name"][0];
+					outZone[:description] = (zone["description"] || [""])[0];
+
+					outZone[:arguments] = Hash.new();
+					outZone[:description].split("<br>").each do |tag|
+						if(tag =~ /([^:]*):([^:]*)/)
+							outZone[:arguments][$1] = $2;
+						end
+					end
+
+					outZone[:style] = @styles[zone["styleUrl"][0]];
+
+					rawPolyData = zone["Polygon"][0]["outerBoundaryIs"][0]["LinearRing"][0]["coordinates"][0];
+					rawPolyData.gsub!(" ", "");
+					rawPolyArray = rawPolyData.split("\n");
+
+					outZone[:polygon] = Array.new();
+					rawPolyArray.each do |point|
+						point = point.split(",");
+						next if point.empty?
+						outZone[:polygon] << [point[0].to_f, point[1].to_f];
+					end
+
+					outZones << outZone;
+				end
+
+				return outZones;
+			end
+			private :_fetch_polygons
+
+			def _fetch_marks(folder = nil)
+				folder ||= @xmlStructure;
+
+				outPoints = Array.new();
+				return outPoints unless(placemarks = folder["Placemark"])
+
+				placemarks.each do |pmark|
+					next unless pmark["Point"];
+
+					outPoint = Hash.new();
+					outPoint[:name] = pmark["name"][0];
+					outPoint[:description] = (pmark["description"] || [""])[0];
+
+					outPoint[:description].split("<br>").each do |tag|
+						if(tag =~ /([^:]*):([^:]*)/)
+							outPoint[:arguments][$1] = $2;
+						end
+					end
+
+					outPoint[:point] = pmark["Point"][0]["coordinates"][0].gsub(/\s/, "").split(",")[0..1];
+
+					outPoints << outPoint
+				end
+
+				return outPoints
+			end
+
+			def generate_zones(zoneSet = "")
+				if(zoneSet.is_a? String)
+					zoneSet = @polygons[zoneSet];
+				end
+
+				zoneSet = [zoneSet].flatten;
+
+				outZones = Array.new();
+				zoneSet.each do |rawZone|
+					outZones << Zone.from_raw_zone(rawZone);
+				end
+
+				return outZones;
+			end
+		end
+	end
+end

data/lib/lzrtag/player/base_player.rb

@@ -0,0 +1,104 @@
+
+require 'mqtt/sub_handler'
+
+module LZRTag
+	module Player
+		# The base player class.
+		# This class is not instantiated by the user, but instead on a on-demand basis
+		# by the LZRTag::Handler::Base when a new PlayerID needs to be registered. The player classes
+		# process and send MQTT data, handle events, and keep track of per-player infos like life,
+		# damage, ammo, team, etc. etc.
+		class Base
+			attr_reader :handler
+			# @return [String] The player's DeviceID, which is derived from the ESP's MAC
+			attr_reader :DeviceID
+
+			# @return [String] Name of the player, set externally
+			attr_reader :name
+
+			# @return [String] status-string of the player. Should be "OK"
+			attr_reader :status
+
+			# @return [Integer] 0..255, shot ID of the player
+			attr_reader   :id
+			# @return [Hash<Time>] Hash of the last few recorded shot times,
+			#  used for hit arbitration
+			attr_accessor :hitIDTimetable
+
+			def initialize(deviceID, handler)
+				@handler = handler;
+				@mqtt = handler.mqtt;
+
+				@DeviceID = deviceID;
+
+				@status = "";
+				@name   = "";
+
+				@hitIDTimetable = Hash.new(Time.new(0));
+			end
+
+			def _pub_to(key, data, retain: false)
+				@mqtt.publish_to("Lasertag/Players/#{@DeviceID}/#{key}", data, retain: retain);
+			end
+			private :_pub_to
+
+			# @private
+			def on_mqtt_data(data, topic)
+				case topic[1..topic.length].join("/")
+				when "Connection"
+					return if @status == data;
+					oldStatus = @status;
+					@status = data;
+					if(@status == "OK")
+						@handler.send_event(:playerConnected, self);
+					elsif(oldStatus == "OK")
+						@handler.send_event(:playerDisconnected, self);
+					end
+				when "CFG/Name"
+					@name = data;
+				end
+			end
+
+			# @return [Boolean] Whether this player is connected
+			def connected?()
+				return @status == "OK"
+			end
+
+			# Set the Shot ID of the player.
+			# @note Do not call this function yourself - the Handler must
+			#   assign unique IDs to ensure proper game functionality!
+			# @private
+			def id=(n)
+				return if @id == n;
+
+				if(!n.nil?)
+					raise ArgumentError, "ID must be integer or nil!" unless n.is_a? Integer;
+					raise ArgumentError, "ID out of range (0<ID<256)" unless n < 256 and n > 0;
+
+					@id = n;
+				else
+					@id = nil;
+				end
+
+				_pub_to("CFG/ID", @id, retain: true);
+			end
+
+			# Trigger a clear of all topics
+			# @note Do not call this function yourself, except when deregistering a player!
+			# @private
+			def clear_all_topics()
+				self.id = nil;
+			end
+
+			def inspect()
+				iString =  "#<Player:#{@deviceID}##{@id ? @id : "OFFLINE"}, Team=#{@team}";
+				iString += ", DEAD" if @dead
+				iString += ", Battery=#{@battery.round(2)}"
+				iString += ", Ping=#{@ping.ceil}ms>";
+
+				return iString;
+			end
+			alias to_s inspect
+		end
+	end
+end

data/lib/lzrtag/player/effects_player.rb

@@ -0,0 +1,96 @@
+
+require_relative 'hardware_player.rb'
+
+module LZRTag
+	module Player
+		# This class extends the pure hardware class, adding various hooks
+		# that can be used to send effects and other events to the weapon.
+		# These do not change the game itself, but instead just look and feel good!
+		class Effects < Hardware
+			# Heartbeat status of the player
+			# The "heartbeat" is a regular vibration pattern on the weapon,
+			# which can be used to indicate things like low life or other tense events.
+			# Set it to true/false.
+			attr_reader :heartbeat
+
+			# Mark a player in a given color
+			# This function can be used to "mark" a player, sending flashes of
+			# light across their LEDs in a given color. This can either be
+			# false, to turn the marking off, or 0..7 to set it to a team color.
+			# Alternatively, any RGB Number (0x?? ?? ??) can be used for arbitrary marking color
+			attr_reader :marked
+
+			def initialize(*data)
+				super(*data);
+
+				@marked = false;
+			end
+
+			# Vibrate the weapon for a number of seconds
+			# @param duration [Numeric] Number (in s) to vibrate for.
+			def vibrate(duration)
+				raise ArgumentError, "Vibration-duration out of range (between 0 and 65.536)" unless duration.is_a? Numeric and duration <= 65.536 and duration >= 0
+				_pub_to("CFG/Vibrate", duration);
+			end
+
+			def heartbeat=(data)
+				return if (@heartbeat == data);
+
+				@heartbeat = data;
+				_pub_to("CFG/Heartbeat", @heartbeat ? "1" : "0", retain: true);
+			end
+
+			def marked=(data)
+				return if (@marked == data);
+
+				@marked = data;
+				if data.is_a? Numeric
+					_pub_to("CFG/Marked", @marked.to_s, retain: true)
+				else
+					_pub_to("CFG/Marked", "0", retain: true)
+				end
+			end
+
+			# Make the weapon play a given note.
+			# This function can make the set play a note of given frequency, volume
+			# and duration.
+			# @param duration [Numeric] Length in seconds
+			# @param frequency [Numeric] Frequency of the note
+			# @param volume [Numeric] Volume (0..1) of the note
+			def noise(duration: 0.5, frequency: 440, volume: 0.5)
+				return false unless duration.is_a? Numeric and frequency.is_a? Integer
+				_pub_to("Sound/Note", [frequency, volume*20000, duration*1000].pack("L3"))
+			end
+
+			# Play a given sound file.
+			# Depending on the weapon, various sounds are available to be played,
+			# such as:
+			# - "GAME START"
+			# - "HIT"
+			# - "OWN DEATH"
+			# - "KILL SCORE"
+			# etc.
+			# This list may be expanded in the future
+			def sound(sName)
+				_pub_to("Sound/File", sName);
+			end
+
+			# Make the weapon display a hit.
+			# When a weapon is hit, it will flash bright white and vibrate
+			# for a short moment. The length can be specified.
+			# @param hitLength [Numeric,nil] Length (in s) of the hit.
+			def hit(hitLength = nil)
+				_pub_to("CFG/Hit", hitLength || 0.7)
+			end
+
+			# @private
+			def clear_all_topics()
+				super();
+
+				["CFG/Heartbeat", "CFG/Marked"].each do |t|
+					_pub_to(t, "", retain: true)
+				end
+			end
+		end
+	end
+end

data/lib/lzrtag/player/hardware_player.rb

@@ -0,0 +1,251 @@
+
+require 'mqtt/mqtt_hash.rb'
+
+require_relative 'base_player.rb'
+
+module LZRTag
+	module Player
+		# Hardware-handling player class.
+		# This class extends the base player, adding more hardware-related
+		# functionality and interfaces, such as:
+		# - Team setting
+		# - Brightness setting
+		# - Note playing
+		# - Gyro and button readout
+		# - Ping and Battery reading
+		# etc.
+		class Hardware < Base
+			# The team (0..7) of this player.
+			# Setting it to a number will publish to /DeviceID/CFG/Team,
+			# changing the color of the weapon. Interpret it as binary string,
+			# with 1 being red, 2 green and 4 blue.
+			#
+			# Changes trigger the :playerTeamChanged event, with [player, oldTeam] data
+			attr_reader :team
+			# Current brightness of the weapon.
+			# @return [Symbol] Symbol describing the current brightness.
+			# Possible brightnesses are:
+			# - :idle (low, slow brightness, white with slight team hue)
+			# - :teamSelect (team-colored with rainbow overlay)
+			# - :dead (low brightness, team colored with white overlay)
+			# - :active (bright, flickering and in team color)
+			#
+			# A change will trigger the :playerBrightnessChanged event, with data [player, oldBrightness]
+			attr_reader :brightness
+
+			# Whether or not the player is currently dead.
+			# Set this to kill the player. Will trigger a :playerKilled or :playerRevived event,
+			# although kill_by is preferred to also specify which player killed.
+			attr_reader :dead
+			# Last time the death status changed (killed/revivied).
+			# Especially useful to determine when to revive a player
+			attr_reader :deathChangeTime
+
+			# Current ammo of the weapon.
+			# TODO one day this should be settable. Right now, it's just reading
+			attr_reader :ammo
+			# Maximum ammo the weapon can have with the currently equipped gun.
+			attr_reader :maxAmmo
+			# Number of the current gun.
+			# The application can freely choose which gun profile the set is using,
+			# which influences shot speeds, sounds, reloading, etc.
+			attr_reader :gunNo
+
+			# Returns the gyro pose of the set.
+			# This is either:
+			# - :active
+			# - :laidDown
+			# - :pointsUp
+			# - :pointsDown
+			# Changes are triggered by the set itself, if it has a gyro.
+			# The :poseChanged event is sent on change with [player, newPose] data
+			attr_reader :gyroPose
+
+			attr_reader :battery, :ping, :heap
+
+			def self.getBrightnessKeys()
+				return [:idle, :teamSelect, :dead, :active]
+			end
+
+			def initialize(*data)
+				super(*data);
+
+				@team = 0;
+				@brightness = :idle;
+
+				@dead = false;
+				@deathChangeTime = Time.now();
+
+				@ammo = 0;
+				@maxAmmo = 0;
+				@gunNo = 0;
+
+				@gyroPose = :unknown;
+
+				@position = {x: 0, y: 0}
+				@zoneIDs  = Hash.new();
+
+				@battery = 0; @ping = 0; @heap = 0;
+
+				@BrightnessMap = self.class.getBrightnessKeys();
+
+				# These values are configured for a DPS ~1, equal to all weapons
+				# Including reload timings and other penalties
+				@GunDamageMultipliers = [
+					0.9138,
+					1.85,
+					0.6166,
+				];
+			end
+
+			# @private
+			# This function processes incoming MQTT data.
+			# The user must not call this, since it is handled by the
+			# LZRTag base handler
+			def on_mqtt_data(data, topic)
+				case topic[1..topic.length].join("/")
+				when "HW/Ping"
+					if(data.size == 3*4)
+						parsedData = data.unpack("L<*");
+
+						@battery = parsedData[0].to_f/1000;
+						@ping 	= parsedData[2].to_f;
+					end
+				when "CFG/Dead"
+					dead = (data == "1")
+					return if @dead == dead;
+					@dead = dead;
+
+					@deathChangeTime = Time.now();
+
+					@handler.send_event(@dead ? :playerKilled : :playerRevived, self);
+				when "Stats/Ammo"
+					return if(data.size != 8)
+
+					outData = data.unpack("L<*");
+					@ammo = outData[0];
+					@maxAmmo = outData[1];
+				when "Position"
+					begin
+						@position = JSON.parse(data, symbolize_names: true);
+					rescue
+					end
+				when "HW/NSwitch"
+					@handler.send_event(:navSwitchPressed, self, data.to_i)
+				when "HW/Gyro"
+					@gyroPose = data.to_sym
+					@handler.send_event(:poseChanged, self, @gyroPose);
+				when "ZoneUpdate"
+					begin
+						data = JSON.parse(data, symbolize_names: true);
+					rescue JSON::ParserError
+						return;
+					end
+
+					@zoneIDs = data[:data];
+					if(data[:entered])
+						@handler.send_event(:playerEnteredZone, self, data[:entered])
+					end
+					if(data[:exited])
+						@handler.send_event(:playerExitedZone, self, data[:exited])
+					end
+				else
+					super(data, topic);
+				end
+			end
+
+			def team=(n)
+				n = n.to_i;
+				raise ArgumentError, "Team out of range (must be between 0 and 7)" unless n <= 7 and n >= 0;
+
+				return if @team == n;
+				oldT = @team;
+				@team = n;
+
+				_pub_to "CFG/Team", @team, retain: true;
+				@handler.send_event :playerTeamChanged, self, oldT;
+
+				@team;
+			end
+			def brightness=(n)
+				raise ArgumentError, "Brightness must be a valid symbol!" unless @BrightnessMap.include? n;
+
+				return if @brightness == n;
+				oldB = @brightness;
+				@brightness = n;
+
+				n = @BrightnessMap.find_index(n)
+
+				_pub_to "CFG/Brightness", n, retain: true;
+				@handler.send_event :playerBrightnessChanged, self, oldB;
+
+				@brightness;
+			end
+
+			def _set_dead(d, player = nil)
+				dead = (d ? true : false);
+				return if @dead == dead;
+				@dead = dead;
+
+				@deathChangeTime = Time.now();
+
+				_pub_to "CFG/Dead", @dead ? "1" : "0", retain: true;
+				@handler.send_event(@dead ? :playerKilled : :playerRevived, self, player);
+			end
+			def dead=(d)
+				_set_dead(d);
+			end
+			def kill_by(player)
+				return if @dead;
+				_set_dead(true, player);
+			end
+			def revive_by(player)
+				return unless @dead
+				_set_dead(false, player)
+			end
+
+			def ammo=(n)
+				unless (n.is_a?(Integer) and (n >= 0))
+					raise ArgumentError, "Ammo amount needs to be a positive number!"
+				end
+
+				@ammo = n;
+
+				_pub_to("Stats/Ammo/Set", n);
+			end
+
+			def gunNo=(n)
+				unless (n.is_a?(Integer) and (n >= 0))
+					raise ArgumentError, "Gun ID needs to be a positive integer!"
+				end
+
+				return if(@gunNo == n)
+
+				oldGun = @gunNo;
+				@gunNo = n;
+				@handler.send_event(:playerGunChanged, self, n, oldGun);
+
+				_pub_to("CFG/GunNo", n, retain: true);
+			end
+
+			# Return the averaged damage the player's gun should do.
+			# This function is very useful to calculate the damage a player did
+			# per shot. The returned number tries to average damage to "1 DPS" for
+			# all weapons regardless of speed etc., which the application can
+			# multiply for a given total damage, creating a more balanced game.
+			def gunDamage(number = nil)
+				number ||= @gunNo
+
+				return @GunDamageMultipliers[number-1] || 1;
+			end
+
+			def clear_all_topics()
+				super();
+
+				[	"CFG/Dead", "CFG/GunNo", "CFG/Brightness", "CFG/Team"].each do |t|
+					_pub_to(t, "", retain: true);
+				end
+			end
+		end
+	end
+end