Add files via upload

Author: Kiplacon

README.md

@@ -3,3 +3,6 @@
 Quite possibly the jankest Factorio mod ever made
 
 but at least the memes are good
+
+
+  Features include Thrower Inserters that YEET items through the air, and Bounce Pads that can make those items fly further through chained bounces. The Player Launcher lets you do the same with your character.

changelog.txt

@@ -1,4 +1,14 @@
 ---------------------------------------------------------------------------------------------------
+Version: 0.8.1
+Date: 5/29/2021
+  Bugfixes:
+    - Fixed crash from saves that had the old overflow prevention transitioning to the new one
+---------------------------------------------------------------------------------------------------
+Version: 0.8.0
+Date: 5/29/2021
+  Changes:
+    - Updated overflow prevention code. Throwers will now freeze if it detects that the item won't fit in to the destination inventory taking into account items in the air and items bouncing through bounce pads. Of note, throwing onto a curved belt is still a bit off, but throwing onto straight belts work quite well.
+---------------------------------------------------------------------------------------------------
 Version: 0.7.7
 Date: 5/3/2021
   Bugfixes:

control.lua

@@ -1,3 +1,4 @@
+if script.active_mods["gvv"] then require("__gvv__.gvv")() end
 -- Setup tables and stuff for new/existing saves ----
 script.on_init(
 	require("script.event.init")
@@ -112,13 +113,59 @@ function(event)
 
 			if (catapult.valid and catapult.held_stack.valid_for_read) then
 				if (settings.global["RTOverflowComp"].value == true) then
-					if (properties.target and properties.target.valid and properties.target ~= "nothing" and properties.target.type == "transport-belt" and (properties.target.get_transport_line(1).can_insert_at_back() == false and properties.target.get_transport_line(2).can_insert_at_back() == false)) then
-						catapult.active = false
-					elseif (properties.target and properties.target.valid and properties.target ~= "nothing" and properties.target.can_insert(catapult.held_stack) == false) then
-						catapult.active = false
-					else
+					if (properties.target ~= "nothing" and properties.target.valid and global.ThrowerTargets[properties.target.unit_number]) then						
+						if (properties.target.type ~= "transport-belt") then
+							local InAir = {}
+							for name, count in pairs(global.ThrowerTargets[properties.target.unit_number].OnTheWay) do
+								local total = count
+								if (name == catapult.held_stack.name) then
+									total = count + catapult.held_stack.count
+								end
+								local inserted = nil
+								if (total > 0) then
+									inserted = properties.target.insert({name=name, count=total})
+									InAir[name] = inserted
+								end
+								if (total > 0 and inserted < total) then
+									for namee, countt in pairs(InAir) do
+										if (countt > 0) then
+											properties.target.remove_item({name=namee, count=countt})
+										end
+									end
+									catapult.active = false
+									InAir = {}
+									break
+								elseif (InAir == {}) then
+									catapult.active = true
+								else
+									catapult.active = true
+								end
+							end
+							for namee, countt in pairs(InAir) do
+								properties.target.remove_item({name=namee, count=countt})
+							end
+							
+						elseif (properties.target.type == "transport-belt" 
+						and (properties.target.get_transport_line(1).can_insert_at_back() == true 
+							 or properties.target.get_transport_line(2).can_insert_at_back() == true)
+						) then
+							local InAir = 0
+							for name, count in pairs(global.ThrowerTargets[properties.target.unit_number].OnTheWay) do
+								InAir = InAir + count
+							end
+							local total = InAir + properties.target.get_transport_line(1).get_item_count() + properties.target.get_transport_line(2).get_item_count()
+							if (total <= 6) then
+								catapult.active = true
+							else
+								catapult.active = false
+							end
+						end
+						
+					elseif (properties.target == "nothing") then
 						catapult.active = true
 					end
+				else
+					catapult.active = true
 				end
 
 				if (catapult.active == true) then
@@ -135,12 +182,31 @@ function(event)
 								source_position = catapult.held_stack_position, --launch from
 								target_position = catapult.drop_position --launch to
 								}) 
-								end) --end of pcall function
+								end)
 							) then
 								catapult.active = false
 						        for ii, player in pairs(game.players) do
 									player.print("Invalid throwable item "..catapult.held_stack.name.." at "..catapult.held_stack_position.x..","..catapult.held_stack_position.x..". Thrower halted. Please report the item to the mod portal form.")
 								end
+								
+							elseif (settings.global["RTOverflowComp"].value == true and properties.target ~= "nothing" and properties.target.valid) then
+								local unused = 1
+								while (global.ThrownItems[unused] ~= nil) do
+									unused = unused + 1
+								end
+								
+								global.ThrownItems[unused] = {
+									from = catapult.held_stack_position,
+									to = catapult.drop_position,
+									destination = properties.target.unit_number,
+									item = catapult.held_stack.name}
+									
+								if (global.ThrowerTargets[properties.target.unit_number].OnTheWay[catapult.held_stack.name] == nil) then
+									global.ThrowerTargets[properties.target.unit_number].OnTheWay[catapult.held_stack.name] = 1
+								else
+									global.ThrowerTargets[properties.target.unit_number].OnTheWay[catapult.held_stack.name] = global.ThrowerTargets[properties.target.unit_number].OnTheWay[catapult.held_stack.name] + 1
+								end
+								
 							end
 						end
 						catapult.held_stack.clear()
@@ -149,6 +215,7 @@ function(event)
 
 			elseif (catapult.valid == false) then
 				global.CatapultList[catapultID] = nil
+				
 			end
 		end
 	end
@@ -158,13 +225,16 @@ script.on_nth_tick(120,
 function(event)
 	if (settings.global["RTOverflowComp"].value == true) then
 		for catapultID, properties in pairs(global.CatapultList) do
-			properties.entity.surface.create_entity
-				({
-				name = "MaybeIllBeTracer-projectileFromRenaiTransportation",
-				position = properties.entity.position, --required setting for rendering, doesn't affect spawn
-				source = properties.entity, --launch from
-				target_position = properties.entity.drop_position --launch to
-				})
+			if (properties.ImAlreadyTracer == nil or properties.ImAlreadyTracer == "traced") then
+				properties.ImAlreadyTracer = "tracing"
+				properties.entity.surface.create_entity
+					({
+					name = "MaybeIllBeTracer-projectileFromRenaiTransportation",
+					position = properties.entity.position, --required setting for rendering, doesn't affect spawn
+					source = properties.entity, --launch from
+					target_position = properties.entity.drop_position --launch to
+					})
+			end
 		end
 	else
 	--dont
@@ -213,9 +283,18 @@ script.on_event(defines.events.on_player_changed_surface,
 -- .surface_index :: uint: The surface index the player was on
 function(event)
 local player = game.players[event.player_index]
-if (global.AllPlayers[event.player_index] and global.AllPlayers[event.player_index].sliding and global.AllPlayers[event.player_index].sliding == true and player.surface.name ~= global.AllPlayers[event.player_index].StartingSurface.name) then
-	player.teleport(player.position, game.get_surface(event.surface_index))
-	
-end
+	if (global.AllPlayers[event.player_index] and global.AllPlayers[event.player_index].sliding and global.AllPlayers[event.player_index].sliding == true and player.surface.name ~= global.AllPlayers[event.player_index].StartingSurface.name) then
+		player.teleport(player.position, game.get_surface(event.surface_index))
+	end
+end)
 
+script.on_event(defines.events.on_runtime_mod_setting_changed,
+-- player_index :: uint (optional): The player who changed the setting or nil if changed by script.
+-- setting :: string: The setting name that changed.
+-- setting_type :: string: The setting type: "runtime-per-user", or "runtime-global".
+function(event)
+	if (event.setting == "RTOverflowComp" and settings.global["RTOverflowComp"].value == false) then
+		global.ThrowerTargets = {}
+		global.ThrownItems = {}
+	end
 end)

info.json

@@ -1,6 +1,6 @@
 {
     "name": "RenaiTransportation",
-    "version": "0.7.7",
+    "version": "0.8.1",
     "title": "Renai Transportation",
     "author": "Kiplacon",
     "factorio_version": "1.1",

locale/en/config.cfg

@@ -115,12 +115,12 @@ RTTrainBounceSetting=Enable Train Bounce Pads (Requires Train Ramps)
 RTZiplineSetting=Enable Electric Ziplines
 RTZiplineSmoothSetting=Zipline Motion
 RTModdedThrowers=Enable modded thrower varients (Requires base throwers to be enabled)
-RTOverflowComp=Thrower Overflow Prevention [Experimental]
+RTOverflowComp=Thrower Overflow Prevention v2 [WIP]
 
 
 [mod-setting-description]
 RTBounceSetting=Circuit Bounce Pad and Primer Bounce Pad
 RTZiplineSmoothSetting=At faster speeds with poles closer together, the bobbing camera motion might be dizzying for some people. 
 RTModdedThrowers=Enables thrower varients of modded inserters, otherwise only vanilla inserter throwers are made.
-RTOverflowComp=Toggles on or off the logic that helps minimize overflow from throwers spilling items all over the place. Disabling probably saves UPS
+RTOverflowComp=Toggles on or off the logic that helps minimize overflow from throwers spilling items all over the place. Disabling probably saves a bit of UPS
 RTThrowersSetting=Enables the base features of thrower inserters, bounce pads, player launchers, and hatches. Required to be on for modded throwers to be created.

prototypes/TrainGoBrrrr/PropHunt.lua

@@ -33,12 +33,45 @@ MLG.track_particle_triggers = nil
 data:extend({ 
 
 MLG,
+{
+    type = "car",
+    name = "RTPropCart",
+	collision_mask = {},
+	selectable_in_game = false,
+	corpse = nil,
+	weight = 1,
+	braking_power = "1J",
+	energy_per_hit_point = 99999,
+	effectivity = 69,
+	inventory_size = 0,
+	consumption = "1J",
+	rotation_speed = 0,
+	has_belt_immunity = true,
+	energy_source ={type = "void"},
+	working_sound = 
+		{
+		  sound =
+		  {
+			filename = "__base__/sound/train-engine.ogg",
+			volume = 0.35
+		  },
+		  match_volume_to_activity = true
+		},
+	friction = 1e-98,
 
+	animation = 
+		{
+		filename = "__RenaiTransportation__/graphics/nothing.png",
+		size = 32,
+		direction_count = 1
+		}
+},
 { --------- prop item -------------
 	type = "item",
 	name = "RTPropCarItem",
 	icon = "__RenaiTransportation__/graphics/Untitled.png",
 	icon_size = 32,
+	flags = {"hidden"},
 	subgroup = "RT",
 	order = "c",
 	place_result = "RTPropCar",

script/event/config_changed.lua

@@ -58,6 +58,13 @@ local function config_changed()
 	if (global.About2Jump == nil) then
 		global.About2Jump = {}
 	end	
+	
+	if (global.ThrowerTargets == nil) then
+		global.ThrowerTargets = {}
+	end	
+	if (global.ThrownItems == nil) then
+		global.ThrownItems = {}
+	end
 end
 
 return config_changed

script/event/effect_triggered.lua

@@ -1,4 +1,33 @@
-local function effect_triggered(event) --has .effect_id, .surface_index, and .source_position, .source_entity, .target_position, and .target_entity depending on how the effect was triggered
+local function TrackProjectile(event)
+	if (settings.global["RTOverflowComp"].value == true) then
+		for id, stuff in pairs(global.ThrownItems) do
+			--game.print(string.gsub(event.effect_id, "-LandedRT", ""))
+			if (math.abs(event.target_position.x - stuff.to.x) < 0.1
+			and math.abs(event.target_position.y - stuff.to.y) < 0.1
+			and math.abs(event.source_position.x - stuff.from.x) < 0.1
+			and math.abs(event.source_position.y - stuff.from.y) < 0.1
+			and string.gsub(event.effect_id, "-LandedRT", "") == stuff.item) then
+				if (global.ThrowerTargets[stuff.destination] ~= nil) then
+					global.ThrowerTargets[stuff.destination].OnTheWay[stuff.item] = global.ThrowerTargets[stuff.destination].OnTheWay[stuff.item] - 1
+				end
+				global.ThrownItems[id] = nil
+				break
+			end
+		end
+	end
+end
+
+-- effect_id :: string: The effect_id specified in the trigger effect.
+-- surface_index :: uint: The surface the effect happened on.
+-- source_position :: Position (optional)
+-- source_entity :: LuaEntity (optional)
+-- target_position :: Position (optional)
+-- target_entity :: LuaEntity (optional)
+
+
+
+
+local function effect_triggered(event)
 
 	---- If it's from this mod ----
 	if (string.find(event.effect_id, "-LandedRT")) then
@@ -82,6 +111,8 @@ local function effect_triggered(event) --has .effect_id, .surface_index, and .so
 					target_position = {ThingLandedOn.position.x  +unitx*(range+RangeBonus)  +unity*(SidewaysShift), ThingLandedOn.position.y  +unity*(range+RangeBonus)  +unitx*(SidewaysShift)},
 					force = ThingLandedOn.force
 					})
+				-- game.print(cheesewheel.unit_number) -- projectiles dont have unit_numbers i guess
+				
 				if (event.effect_id ~= "MaybeIllBeTracer-LandedRT") then
 					ThingLandedOn.surface.create_particle
 						({
@@ -98,6 +129,23 @@ local function effect_triggered(event) --has .effect_id, .surface_index, and .so
 							position = ThingLandedOn.position,
 							volume = 0.7
 						}
+					if (settings.global["RTOverflowComp"].value == true and event.effect_id ~= "test-LandedRT") then
+						for id, stuff in pairs(global.ThrownItems) do
+							if (math.abs(event.target_position.x - stuff.to.x) < 0.1
+							and math.abs(event.target_position.y - stuff.to.y) < 0.1
+							and math.abs(event.source_position.x - stuff.from.x) < 0.1
+							and math.abs(event.source_position.y - stuff.from.y) < 0.1
+							and string.gsub(event.effect_id, "-LandedRT", "") == stuff.item) then
+								stuff.from.x = ThingLandedOn.position.x
+								stuff.from.y = ThingLandedOn.position.y
+								stuff.to.x = ThingLandedOn.position.x  +unitx*(range+RangeBonus)  +unity*(SidewaysShift)
+								stuff.to.y = ThingLandedOn.position.y  +unity*(range+RangeBonus)  +unitx*(SidewaysShift)
+								break
+							end
+						end
+					end
+				else
+					--global.CatapultList[event.source_entity.unit_number].bounces = global.CatapultList[event.source_entity.unit_number].bounces + 1
 				end
 				---- Handling players ----
 				if (event.effect_id == "test-LandedRT") then
@@ -145,22 +193,37 @@ local function effect_triggered(event) --has .effect_id, .surface_index, and .so
 							{name=string.gsub(event.effect_id, "-LandedRT", ""), count=1}
 						)
 				end
+				
+				TrackProjectile(event)
 
 			elseif (event.effect_id == "MaybeIllBeTracer-LandedRT") then
-				global.CatapultList[event.source_entity.unit_number].target = ThingLandedOn
+				if (global.CatapultList[event.source_entity.unit_number]) then
+					global.CatapultList[event.source_entity.unit_number].target = ThingLandedOn
+					global.CatapultList[event.source_entity.unit_number].ImAlreadyTracer = "traced"
+					if (global.ThrowerTargets[ThingLandedOn.unit_number] == nil) then
+						global.ThrowerTargets[ThingLandedOn.unit_number] = {}
+						global.ThrowerTargets[ThingLandedOn.unit_number].entity = ThingLandedOn
+						global.ThrowerTargets[ThingLandedOn.unit_number].OnTheWay = {}
+						script.register_on_entity_destroyed(ThingLandedOn)
+					end
+				end
 			end
 
 		---- If it didnt land on anything but theres a cargo wagon there
 		elseif (LandedOnCargoWagon ~= nil and LandedOnCargoWagon.can_insert({name=string.gsub(event.effect_id, "-LandedRT", "")})) then
 			LandedOnCargoWagon.insert({name=string.gsub(event.effect_id, "-LandedRT", ""), count=1})
-
+			TrackProjectile(event)
+			
 		---- if the item/character lands in the water, it's gone ----
 		elseif (event.effect_id ~= "MaybeIllBeTracer-LandedRT" and game.get_surface(event.surface_index).find_tiles_filtered{position = event.target_position, radius = 1, limit = 1, collision_mask = "player-layer"}[1] ~= nil) then -- in theory, tiles the player cant walk on are some sort of fluid or other non-survivable ground
 
 			---- drown the character ----
 			if (event.effect_id == "test-LandedRT") then
 				game.get_player(event.source_entity.player.index).character.destructible = true
 				game.get_player(event.source_entity.player.index).character.die()
+			else
+				---- dont drop an item ----
+				TrackProjectile(event)
 			end
 
 			---- splash ----
@@ -170,7 +233,7 @@ local function effect_triggered(event) --has .effect_id, .surface_index, and .so
 					position = event.target_position
 				})
 
-			---- dont drop an item ----
+			
 
 		---- if thrown thing didn't land on anything and not in water, i don't want characters to do anything upon landing. it would cause an error if it got to the item drop code  ----
 		elseif (event.effect_id == "test-LandedRT") then
@@ -180,8 +243,10 @@ local function effect_triggered(event) --has .effect_id, .surface_index, and .so
 		else --if it fell on nothing just drop it
 			if (event.effect_id ~= "MaybeIllBeTracer-LandedRT") then
 				game.get_surface(event.surface_index).spill_item_stack({event.target_position.x, event.target_position.y}, {name=string.gsub(event.effect_id, "-LandedRT", ""), count=1})
+				TrackProjectile(event)	
 			else
 				global.CatapultList[event.source_entity.unit_number].target = "nothing"
+				global.CatapultList[event.source_entity.unit_number].ImAlreadyTracer = "traced"
 			end
 			--[[ random item landing offset
 			local xoffset = 0.1*math.random(-1,6)