lzrtag-base 1.0.0

data/lib/lzrtag/handler/hitArb_handler.rb

@@ -0,0 +1,80 @@
+
+require 'json'
+require_relative 'base_handler.rb'
+
+module LZRTag
+	module Handler
+		# Hit arbitration handling class.
+		# This class extends the Handler::Base class, adding important features
+		# to ensure that each player shot is only counted once.
+		# Additionally, hooks can manipulate this behavior and prevent friendly-fire,
+		# or enable multiple hits in the case of a shotgun!
+		#
+		# Shot arbitration is performed by listening to "Lasertag/Game/Events",
+		# waiting for a 'type: "hit"'
+		# If such a JSON payload is found, hit and source players will be
+		# determined, and every available hook's "process_raw_hit" function
+		# is called. If this function returns false, the hit will be "vetoed" and
+		# does not count at all. However, a hook can raise {LZRTag::Handler::NoArbitration},
+		# preventing this shot from being logged and thusly enabling multiple hits
+		# @see Base
+		class HitArb < Base
+			def initialize(*data, **options)
+				super(*data, **options);
+
+				@mqtt.subscribe_to "Lasertag/Game/Events" do |data|
+					begin
+						data = JSON.parse(data, symbolize_names: true);
+
+						if(data[:type] == "hit")
+							_handle_hitArb(data);
+						end
+					rescue JSON::ParserError
+					end
+				end
+			end
+
+			def process_raw_hit(*)
+				return true;
+			end
+
+			def _handle_hitArb(data)
+				unless  (hitPlayer = get_player(data[:target])) and
+						  (sourcePlayer = get_player(data[:shooterID])) and
+						  (arbCode = data[:arbCode])
+					return
+				end
+
+				return if (sourcePlayer.hitIDTimetable[arbCode] + 1) > Time.now();
+
+				veto = false;
+				arbitrateShot = true;
+
+				hookList = Array.new();
+				hookList << @hooks;
+				if(@currentGame)
+					hookList << @currentGame.hookList
+				end
+				hookList.flatten
+
+				hookList.each do |h|
+					begin
+						veto |= !(h.process_raw_hit(hitPlayer, sourcePlayer));
+					rescue NoArbitration
+						arbitrateShot = false;
+					end
+				end
+				return if veto;
+
+				if arbitrateShot
+					sourcePlayer.hitIDTimetable[arbCode] = Time.now();
+				end
+
+				send_event(:playerHit, hitPlayer, sourcePlayer);
+			end
+		end
+
+		class NoArbitration < Exception
+		end
+	end
+end

data/lib/lzrtag/hooks/base_hook.rb

@@ -0,0 +1,143 @@
+
+module LZRTag
+	module Hook
+=begin
+	Base class for all game hooks, implements DSL.
+	This class shall be used as a base class for any DIY game hooks.
+	The purpose of any hook is to implement a specific element of a game,
+	such as damaging players, regenerating them, handing out teams, etc.
+
+	This hook base class implements a DSL that makes it very easy for the application
+	to implement their own behavior in a modular fashion.
+
+	@example
+		class MyHook < LZRTag::Base::Hook
+			# Hooks can register which parameters are configurable, and how
+			# This will be used to reconfigure them on the fly, but it is not mandatory
+			# to register options.
+			describe_option :myValue, "A description of my Value";
+
+			def initialize(handler, **options)
+				super(handler);
+
+				@myValue = options[:myValue] || "default";
+			end
+
+			# The "on" DSL makes it easy to perform tasks on
+			# any arbitrary event
+			on :playerKilled do |player|
+				puts "Player #{player.name} was killed :C";
+			end
+		end
+
+		class MyGame < LZRTag::Game::Base
+			# A game can register that it wants to use this hook, and
+			# even which options to use for it.
+			hook :aHook, MyHook, {myValue: "Not a default!"};
+		end
+
+		# Alternatively, the hook can be added to the game directly
+		handler.add_hook(MyHook);
+=end
+		class Base
+			def self.getCBs()
+				@globalCBList ||= Hash.new();
+				return @globalCBList;
+			end
+			def self.getOptionDescriptions()
+				@globalOptionDescriptions ||= Hash.new();
+				return @globalOptionDescriptions
+			end
+
+			def initialize(handler)
+				@localCBList = Hash.new();
+
+				@handler = handler
+			end
+
+			# DSL function to describe an option of this hook.
+			# The application can use this DSL to describe a given option,
+			# identified by optionSymbol. The extraDetails hash is optional,
+			# but in the future will allow this hook to be reconfigured remotely
+			# via MQTT!
+			# @param optionSymbol [Symbol] The Symbol used for this option
+			# @param descString [String] String description of this option.
+			# @param extraDetails [Hash] Optional hash to provide further details
+			#    of this option, such as "min", "max", "type", etc.
+			def self.describe_option(optionSymbol, descString, extraDetails = {})
+				raise ArgumentError, "Option shall be a symbol!" unless optionSymbol.is_a? Symbol
+				raise ArgumentError, "Description should be a string!" unless descString.is_a? String
+				getOptionDescriptions()[optionSymbol] = extraDetails;
+				getOptionDescriptions()[optionSymbol][:desc] = descString;
+			end
+
+			# DSL function to add a block on an event.
+			# The application can provide a block to this function that will be executed
+			# for every "evtName" game event
+			# @param evtName [Symbol] Event name to trigger this block on
+			def self.on(evtName, &block)
+				raise ArgumentError, "Block needs to be given!" unless block_given?
+
+				evtName = [evtName].flatten
+				evtName.each do |evt|
+					unless (evt.is_a? Symbol)
+						raise ArgumentError, "Event needs to be a symbol or array of symbols!"
+					end
+					getCBs()[evt] ||= Array.new();
+					getCBs()[evt] << block;
+				end
+			end
+
+			# Function to add hooks to the already instantiated hook.
+			# This function works exactly like {self.on}, except that it
+			# acts on an instance of hook, and allows the app to extend a standard
+			# hook by extending it afterwards.
+			def on(evtName, &block)
+				raise ArgumentError, "Block needs to be given!" unless block_given?
+
+				evtName = [evtName].flatten
+				evtName.each do |evt|
+					unless (evt.is_a? Symbol)
+						raise ArgumentError, "Event needs to be a symbol or array of symbols!"
+					end
+					@localCBList[evt] ||= Array.new();
+					@localCBList[evt] << block;
+				end
+			end
+
+			# @private
+			def consume_event(evtName, data)
+				if(cbList = self.class.getCBs()[evtName])
+					cbList.each do |cb|
+						begin
+							instance_exec(*data, &cb);
+						rescue StandardError => e
+							puts e.message
+							puts e.backtrace.inspect
+						end
+					end
+				end
+				if(cbList = @localCBList[evtName]) then
+					cbList.each do |cb|
+						begin
+							cb.call(*data);
+						rescue StandardError => e
+							puts e.message
+							puts e.backtrace.inspect
+						end
+					end
+				end
+			end
+
+			def on_hookin(handler)
+				@handler = handler;
+			end
+			def on_hookout()
+			end
+
+			def process_raw_hit(*)
+				return true;
+			end
+		end
+	end
+end

data/lib/lzrtag/hooks/standard_hooks.rb

@@ -0,0 +1,174 @@
+
+require_relative 'base_hook.rb'
+
+module LZRTag
+	module Hook
+		class Debug < Base
+			attr_accessor :eventWhitelist
+			attr_accessor :eventBlacklist
+
+			def initialize()
+				super();
+
+				@eventWhitelist = Array.new();
+				@eventBlacklist = Array.new();
+			end
+
+			def consume_event(evtName, data)
+				super(evtName, data);
+
+				return if @eventBlacklist.include? evtName
+				unless(@eventWhitelist.empty?)
+					return unless @eventWhitelist.include? evtName
+				end
+
+				puts "Caught event: #{evtName} with data: #{data}";
+			end
+		end
+
+		class TeamSelector < Base
+			describe_option :possibleTeams, "List of teams that can be selected", {
+				type: Array
+			}
+
+			def initialize(handler, possibleTeams: [1, 2, 3, 4])
+				super(handler);
+
+				@possibleTeams = possibleTeams;
+			end
+
+			on :gamePhaseEnds do |oldPhase, nextPhase|
+				if((oldPhase == :teamSelect) && (nextPhase != :idle))
+					puts "Selecting active players!"
+
+					@handler.gamePlayers = Array.new();
+					@handler.each do |pl|
+						if(pl.brightness == :active)
+							@handler.gamePlayers << pl;
+						end
+					end
+
+					puts "Game players are: #{@handler.gamePlayers}"
+				end
+			end
+
+			on :gamePhaseStarts do |nextPhase, oldPhase|
+				case(nextPhase)
+				when :teamSelect
+					@handler.each do |pl|
+						pl.brightness = :idle;
+
+						if(!@possibleTeams.include?(pl.team))
+							pl.team = @possibleTeams.sample();
+						end
+					end
+				when :idle
+					@handler.each do |pl|
+						pl.brightness = :idle;
+					end
+				end
+			end
+
+			on :poseChanged do |pl, nPose|
+				next if(@handler.gamePhase != :teamSelect)
+				next if(pl.brightness == :active)
+
+				pl.brightness = (pl.gyroPose == :laidDown) ? :idle : :teamSelect;
+			end
+
+			on :navSwitchPressed do |player, dir|
+				next if(@handler.gamePhase != :teamSelect)
+				next unless [:teamSelect, :idle].include? player.brightness
+
+				newTeam = @possibleTeams.find_index(player.team) || 0;
+
+				newTeam += 1 if(dir == 2)
+				newTeam -= 1 if(dir == 3)
+
+				player.team = @possibleTeams[newTeam % @possibleTeams.length]
+				if(dir == 1)
+					player.brightness = :active
+				else
+					player.brightness = :teamSelect
+				end
+			end
+		end
+
+		class Regenerator < Base
+
+			describe_option :regRate, "Regeneraton rate, HP per second"
+			describe_option :regDelay, "Healing delay, in s, after a player was hit"
+			describe_option :healDead, "Whether or not to heal dead players"
+
+			describe_option :autoReviveThreshold, "The HP a player needs before he is revived"
+
+			describe_option :teamFilter, "Which teams this regenerator belongs to"
+			describe_option :phaseFilter, "During which phases this hook should be active"
+
+			def initialize(handler, **options)
+				super(handler);
+
+				@regRate = options[:regRate] || 1;
+				@regDelay = options[:regDelay] || 10;
+
+				@healDead = options[:healDead] || false;
+				@autoReviveThreshold = options[:autoReviveThreshold] || 30;
+
+				@teamFilter = options[:teamFilter] || (0..7).to_a
+				@phaseFilter = options[:phaseFilter] || [:running]
+			end
+
+			on :gameTick do |dT|
+				next unless @phaseFilter.include? @handler.gamePhase
+
+				@handler.each_participating do |pl|
+					next unless @teamFilter.include? pl.team
+
+					if((Time.now() - pl.lastDamageTime) >= @regDelay)
+						pl.regenerate(dT * @regRate);
+					end
+
+					if(pl.dead and pl.life >= @autoReviveThreshold)
+						pl.dead = false;
+					end
+				end
+			end
+		end
+
+		class Damager < Base
+			describe_option :dmgPerShot, "Base damage per shot"
+			describe_option :useDamageMultiplier, "Shall shots be adjusted per-gun?"
+			describe_option :friendlyFire, "Shall friendly-fire be enabled"
+			describe_option :hitThreshold, "Limit below dead players will not be hit"
+
+			def initialize(handler, **options)
+				super(handler);
+
+				@dmgPerShot = options[:dmgPerShot] || 40;
+				@useDamageMultiplier = options[:useDamageMultiplier] || true;
+				@friendlyFire = options[:friendlyFire] || false;
+				@hitThreshold = options[:hitThreshold] || 10;
+			end
+
+			def process_raw_hit(hitPlayer, sourcePlayer)
+				unless(@friendlyFire)
+					return false if hitPlayer.team == sourcePlayer.team
+				end
+				return false if(hitPlayer.dead && (hitPlayer.life < @hitThreshold));
+
+				return true;
+			end
+
+			on :playerHit do |hitPlayer, sourcePlayer|
+				shotMultiplier = 1;
+
+				if((@useDamageMultiplier) && (!sourcePlayer.nil?))
+					shotMultiplier = sourcePlayer.gunDamage();
+				end
+
+				hitPlayer.damage_by(@dmgPerShot * shotMultiplier, sourcePlayer);
+				hitPlayer.hit();
+			end
+		end
+	end
+end

data/lib/lzrtag/map/map_set.rb

@@ -0,0 +1,48 @@
+
+require_relative 'map_zone.rb'
+require_relative 'myMaps_parser.rb'
+
+module LZRTag
+	module Map
+		class Set
+			attr_reader :zones
+
+			attr_accessor :centerpoint
+
+			def initialize(mqtt, zones = Array.new())
+				@mqtt = mqtt;
+				@zones = zones;
+
+				@centerpoint = Array.new();
+			end
+
+			def to_h()
+				outData = Hash.new();
+
+				if(@centerpoint.length != 3)
+					raise ArgumentError, "Center point needs to be set!"
+				end
+
+				outData[:centerpoint] = @centerpoint
+
+				outData[:zones] = Array.new();
+				@zones.each do |z|
+					outData[:zones] << z.to_h;
+				end
+
+				return outData;
+			end
+
+			def to_json()
+				return self.to_h().to_json();
+			end
+
+			def publish()
+				@mqtt.publish_to "Lasertag/Zones", self.to_json, qos: 1, retain: true;
+			end
+			def clear()
+				@mqtt.publish_to "Lasertag/Game/Zones", "", retain: true;
+			end
+		end
+	end
+end

data/lib/lzrtag/map/map_zone.rb

@@ -0,0 +1,95 @@
+
+module LZRTag
+	module Map
+		class Zone
+			attr_accessor :tag
+
+			attr_accessor :centerPoint, :radius
+			attr_accessor :polygon
+			attr_accessor :coordinatesAsGPS
+
+			attr_accessor :teamMask
+
+			attr_accessor :data
+
+			attr_accessor :style
+
+			def initialize()
+				@centerPoint = [0, 0];
+				@radius = 0;
+				@polygon = Array.new();
+				@coordinatesAsGPS = false;
+
+				@teamMask = 255;
+
+				@style = {
+					color: 		 "transparent",
+					borderColor: "black"
+				}
+
+				@data = Hash.new();
+			end
+
+			def affects_teams(teamList)
+				@teamMask = 0;
+				[teamList].flatten.each do |t|
+					@teamMask += (2<<t);
+				end
+			end
+			def ignores_teams(teamList)
+				@teamMask = 255;
+				[teamList].flatten.each do |t|
+					@teamMask -= (2<<t);
+				end
+			end
+
+			def self.from_raw_zone(rawZone)
+				outZone = Zone.new();
+
+				outZone.tag = rawZone[:arguments]["tag"] || rawZone[:name];
+
+				outZone.polygon = rawZone[:polygon];
+				outZone.coordinatesAsGPS = true;
+
+				if(rawZone[:style])
+					outZone.style = rawZone[:style];
+				end
+
+				if(tMask = rawZone[:arguments]["teamMask"])
+					outZone.teamMask = tMask.to_i;
+					rawZone[:arguments].delete "teamMask"
+				end
+
+				outZone.data = rawZone[:arguments];
+
+				return outZone
+			end
+
+			def to_h()
+				outHash = Hash.new();
+
+				raise ArgumentError, "Tag needs to be set!" if(@tag.nil?);
+				outHash[:tag] = @tag;
+				outHash[:teamMask] = @teamMask;
+
+				if(@radius > 0.1)
+					outHash[:centerPoint] = @centerPoint;
+					outHash[:radius] = @radius;
+				else
+					outHash[:polygon] = @polygon;
+				end
+				outHash[:coordinatesAsGPS] = @coordinatesAsGPS
+
+				outHash[:style] = @style;
+
+				outHash[:data] = @data;
+
+				return outHash;
+			end
+
+			def inspect()
+				return "#<Zone: #{to_h}>";
+			end
+		end
+	end
+end