multiplayer fixed

clusterio_0.0.2/control.lua

@@ -1,4 +1,5 @@
 require("config")
+local json = require("json")
 
 function HashPosition(position)
 	return 40000 * (position.y) + position.x
@@ -8,23 +9,39 @@ function OnBuiltEntity(event)
 	local entity = event.created_entity
 	--only add entities that are not ghosts
 	if entity.type ~= "entity-ghost" then
-		if entity.name == INPUT_CHEST_NAME then
-			global.inputChests = global.inputChests or {}
-			--add the chests to a lists if these chests so they can be interated over
-			global.inputChests[HashPosition(entity.position)] = entity
-		elseif entity.name == OUTPUT_CHEST_NAME then
-			global.outputChests = global.outputChests or {}
-			--add the chests to a lists if these chests so they can be interated over
-			global.outputChests[HashPosition(entity.position)] = entity
-		elseif entity.name == INPUT_TANK_NAME then
-			global.inputTanks = global.inputTanks or {}
-			--add the chests to a lists if these chests so they can be interated over
-			global.inputTanks[HashPosition(entity.position)] = entity
-		elseif entity.name == OUTPUT_TANK_NAME then
-			global.outputTanks = global.outputTanks or {}
-			--add the chests to a lists if these chests so they can be interated over
-			global.outputTanks[HashPosition(entity.position)] = entity
-		end
+		AddEntity(entity)
+	end
+end
+
+function AddAllEntitiesOfName(name)
+	for k, surface in pairs(game.surfaces) do
+		AddEntities(surface.find_entities_filtered({["name"] = name}))
+	end
+end
+
+function AddEntities(entities)
+	for k, entity in pairs(entities) do
+		AddEntity(entity)
+	end
+end
+
+function AddEntity(entity)
+	if entity.name == INPUT_CHEST_NAME then
+		global.inputChests = global.inputChests or {}
+		--add the chests to a lists if these chests so they can be interated over
+		global.inputChests[HashPosition(entity.position)] = entity
+	elseif entity.name == OUTPUT_CHEST_NAME then
+		global.outputChests = global.outputChests or {}
+		--add the chests to a lists if these chests so they can be interated over
+		global.outputChests[HashPosition(entity.position)] = entity
+	elseif entity.name == INPUT_TANK_NAME then
+		global.inputTanks = global.inputTanks or {}
+		--add the chests to a lists if these chests so they can be interated over
+		global.inputTanks[HashPosition(entity.position)] = entity
+	elseif entity.name == OUTPUT_TANK_NAME then
+		global.outputTanks = global.outputTanks or {}
+		--add the chests to a lists if these chests so they can be interated over
+		global.outputTanks[HashPosition(entity.position)] = entity
 	end
 end
 
@@ -66,9 +83,8 @@ script.on_event(defines.events.on_preplayer_mined_item, function(event)
 end)
 
 
-
-
 script.on_event(defines.events.on_tick, function(event)
+	
 	global.inputChests = global.inputChests or {}
 	global.outputChests = global.outputChests or {}
 	global.inputTanks = global.inputTanks or {}
@@ -78,6 +94,13 @@ script.on_event(defines.events.on_tick, function(event)
 	
 	local todo = game.tick % UPATE_RATE
 	
+	local onlinePlayers = GetOnlinePlayerCount()
+	
+	if global.previousPlayerCount == nil or global.previousPlayerCount ~= onlinePlayers then
+		Reset()
+	end
+	global.previousPlayerCount = onlinePlayers
+	
 	if todo == 0 then
 		HandleInputChests()
 	elseif todo == 1 then
@@ -93,6 +116,33 @@ script.on_event(defines.events.on_tick, function(event)
 	end
 end)
 
+function GetOnlinePlayerCount()
+	local onlinePlayers = 0
+	for k, player in pairs(game.players) do
+		if player.connected then
+			onlinePlayers = onlinePlayers + 1
+		end
+	end
+	return onlinePlayers
+end
+
+function Reset()
+	global.outputList = {}
+	global.inputList = {}
+	global.itemStorage = {}
+	
+	global.inputChests = {}
+	global.outputChests = {}
+	global.inputTanks = {}
+	global.outputTanks = {}
+	
+	AddAllEntitiesOfName(INPUT_CHEST_NAME)
+	AddAllEntitiesOfName(OUTPUT_CHEST_NAME)
+	AddAllEntitiesOfName(INPUT_TANK_NAME)
+	AddAllEntitiesOfName(OUTPUT_TANK_NAME)
+	game.print("reset")
+end
+
 function HandleInputChests()
 	for k, v in pairs(global.inputChests) do
 		if v.valid then
@@ -113,9 +163,7 @@ function HandleInputTanks()
 		if v.valid then
 			--get the content of the chest
 			local fluid = v.fluidbox[1]
-			if fluid ~= nil and
-			   fluid.type == "crude-oil" and
-			   math.floor(fluid.amount) > 0 then
+			if fluid ~= nil and math.floor(fluid.amount) > 0 then
 				AddItemToInputList(fluid.type, math.floor(fluid.amount))
 				fluid.amount = fluid.amount - math.floor(fluid.amount)
 			end
@@ -164,12 +212,23 @@ end
 function HandleOutputTanks()
 	local MAX_FLUID_AMOUNT = 1000
 	 for k,v in pairs(global.outputTanks) do
-		local fluid = v.fluidbox[1] or {type = "crude-oil", amount = 0}
-		if fluid.type == "crude-oil" then
+		--.recipe.products[1].name
+		
+		if v.recipe ~= nil then
+			local fluidName = v.recipe.products[1].name
 			
-			local missingFluid = math.ceil(MAX_FLUID_AMOUNT - fluid.amount)
+			--either get the fluid or reset it to the requested fluid
+			local fluid = v.fluidbox[1] or {type = fluidName, amount = 0}
+			if fluid.type ~= fluidName then
+				fluid = {type = fluidName, amount = 0}
+			end
+			
+			--if any fluid is missing then request the fluid
+			--from store and give either what it's missing or
+			--the rest of the liquid in the system
+			local missingFluid = math.max(math.ceil(MAX_FLUID_AMOUNT - fluid.amount), 0)
 			if missingFluid > 0 then
-				local fluidToInsert = RequestItemsFromStorage("crude-oil", missingFluid)
+				local fluidToInsert = RequestItemsFromStorage(fluidName, missingFluid)
 				if fluidToInsert > 0 then
 					fluid.amount = fluid.amount + fluidToInsert
 				else
@@ -177,8 +236,9 @@ function HandleOutputTanks()
 					AddItemToOutputList(fluid.type, fluidToRequestAmount)
 				end
 			end
+			
+			v.fluidbox[1] = fluid
 		end
-		v.fluidbox[1] = fluid
 	 end
 end
 
@@ -256,11 +316,23 @@ remote.add_interface("clusterio",
 	import = function(itemName, itemCount)
 		GiveItemsToStorage(itemName, itemCount)
 	end,
-	importMany = function(items)
-		for itemName, itemCount in pairs(items) do
-			GiveItemsToStorage(itemName, itemCount)
+	importMany = function(jsonString)
+		local items = json:decode(jsonString)
+		game.print(serpent.block(items))
+		for k, item in pairs(items) do
+			for itemName, itemCount in pairs(item) do
+				GiveItemsToStorage(itemName, itemCount)
+			end
 		end
-	end
+	end,
+	printStorage = function()
+		local items = ""
+		for itemName, itemCount in pairs(global.itemStorage) do
+			items = items.."\n"..itemName..": "..tostring(itemCount)
+		end
+		game.print(items)
+	end,
+	reset = Reset
 })
 
 

clusterio_0.0.2/data.lua

@@ -20,7 +20,7 @@ function MakeLogisticEntity(entity, name, pictureFilename, pictureTablePath, ico
 	entity.icon = iconPath or entity.icon
 	
 	-- add the entity to a technology so it can be unlocked
-	local wasAddedToTech = AddEntityToTech("construction-robotics", name)
+	--local wasAddedToTech = AddEntityToTech("construction-robotics", name)
 	
 	data:extend(
 	{
@@ -34,7 +34,7 @@ function MakeLogisticEntity(entity, name, pictureFilename, pictureTablePath, ico
 			--shouldn't be enabled to begin with.
 			--but if the recipe isn't attached to a tech then it should
 			--be enabled to begin with because otherwise the player can never use the item ingame
-			enabled = not wasAddedToTech,
+			enabled = true,
 			ingredients =
 			{
 			  {"steel-chest", 1},
@@ -55,6 +55,7 @@ function MakeLogisticEntity(entity, name, pictureFilename, pictureTablePath, ico
 			stack_size = 50
 		}
 	})
+	return entity
 end
 
 --adds a recipe to a tech and returns true or if that fails returns false
@@ -83,11 +84,78 @@ MakeLogisticEntity(table.deepcopy(data.raw["logistic-container"]["logistic-chest
 MakeLogisticEntity(table.deepcopy(data.raw["container"]["iron-chest"]), 					    INPUT_CHEST_NAME,  INPUT_CHEST_PICTURE_PATH, { "picture" },  INPUT_CHEST_ICON_PATH)
 
 --make tanks
-MakeLogisticEntity(table.deepcopy(data.raw["storage-tank"]["storage-tank"]), OUTPUT_TANK_NAME, OUTPUT_TANK_PICTURE_PATH, { "pictures", "picture", "sheet" }, OUTPUT_TANK_ICON_PATH)
+--MakeLogisticEntity(table.deepcopy(data.raw["storage-tank"]["storage-tank"]), OUTPUT_TANK_NAME, OUTPUT_TANK_PICTURE_PATH, { "pictures", "picture", "sheet" }, OUTPUT_TANK_ICON_PATH)
 MakeLogisticEntity(table.deepcopy(data.raw["storage-tank"]["storage-tank"]),  INPUT_TANK_NAME,  INPUT_TANK_PICTURE_PATH, { "pictures", "picture", "sheet" },  INPUT_TANK_ICON_PATH)
 
 
+data:extend(
+{
+	{
+		type = "recipe-category",
+		name = "crafting-fluids"
+	}
+})
 
+local fluidCreator = MakeLogisticEntity(table.deepcopy(data.raw["assembling-machine"]["assembling-machine-3"]), OUTPUT_TANK_NAME, OUTPUT_TANK_PICTURE_PATH, { "animation" }, OUTPUT_TANK_ICON_PATH)
+fluidCreator.fluid_boxes =
+{
+	{
+		production_type = "output",
+		pipe_picture = assembler3pipepictures(),
+		pipe_covers = pipecoverspictures(),
+		base_area = 250,
+		base_level = 1,
+		pipe_connections = 
+		{
+			{ 
+				type="output", position = {0, 2} 
+			}
+		}
+	},
+	off_when_no_fluid_recipe = false
+}
+fluidCreator.crafting_categories = {"crafting-fluids"}
+--fluidCreator.energy_source = nil
+fluidCreator.energy_usage = "1kW"
+fluidCreator.ingredient_count = 1
+fluidCreator.module_specification.module_slots = 0
+
+for k,v in pairs(data.raw.fluid) do
+	data:extend(
+	{
+		{
+			type = "recipe",
+			name = v.name,
+			icon = v.icon,
+			category = "crafting-fluids",
+			energy_required = 1,
+			subgroup = "barrel",
+			order = "b[fill-crude-oil-barrel]",
+			enabled = true,
+			ingredients =
+			{
+				{type="item", name="none", amount=1}
+			},
+			results=
+			{
+			  {type="fluid", name=v.name, amount=-1}
+			}
+		}
+	})
+end
+
+data:extend(
+{
+	{
+		type = "item",
+		name = "none",
+		icon = "__clusterio__/graphics/icons/none.png",
+		flags = { "goes-to-quickbar" },
+		subgroup = "intermediate-product",
+		order = "c[other]-a[power-switch]",
+		stack_size= 1,
+  }
+})
 
 
 

clusterio_0.0.2/info.json

@@ -6,6 +6,6 @@
 "date": "19-08-2016",
 "author": "Danielv123 & Keyboardhack",
 "dependencies": ["base >= 0.13"],
-"factorio_version": "0.13",
+"factorio_version": "0.14",
 "description": "Adds 2 chests to transfer items between saves and servers over the internet."
 }

clusterio_0.0.2/json.lua

@@ -0,0 +1,851 @@
+-- Simple JSON encoding and decoding in pure Lua.
+--
+-- Copyright 2010-2016 Jeffrey Friedl
+-- http://regex.info/blog/
+-- Latest version: http://regex.info/blog/lua/json
+--
+-- This code is released under a Creative Commons CC-BY "Attribution" License:
+-- http://creativecommons.org/licenses/by/3.0/deed.en_US
+--
+-- It can be used for any purpose so long as the copyright notice above,
+-- the web-page links above, and the 'AUTHOR_NOTE' string below are
+-- maintained. Enjoy.
+--
+local VERSION = 20160728.17 -- version history at end of file
+local AUTHOR_NOTE = "-[ JSON.lua package by Jeffrey Friedl (http://regex.info/blog/lua/json) version 20160728.17 ]-"
+
+--
+-- The 'AUTHOR_NOTE' variable exists so that information about the source
+-- of the package is maintained even in compiled versions. It's also
+-- included in OBJDEF below mostly to quiet warnings about unused variables.
+--
+local OBJDEF = {
+   VERSION      = VERSION,
+   AUTHOR_NOTE  = AUTHOR_NOTE,
+}
+
+local default_pretty_indent  = "  "
+local default_pretty_options = { pretty = true, align_keys = false, indent = default_pretty_indent  }
+
+local isArray  = { __tostring = function() return "JSON array"         end }  isArray.__index  = isArray
+local isObject = { __tostring = function() return "JSON object"        end }  isObject.__index = isObject
+
+function OBJDEF:newArray(tbl)
+   return setmetatable(tbl or {}, isArray)
+end
+
+function OBJDEF:newObject(tbl)
+   return setmetatable(tbl or {}, isObject)
+end
+
+
+
+
+local function getnum(op)
+   return type(op) == 'number' and op or op.N
+end
+
+local isNumber = {
+   __index = isNumber,
+
+   __tostring = function(T)  return T.S        end,
+   __unm      = function(op) return getnum(op) end,
+
+   __concat   = function(op1, op2) return tostring(op1) .. tostring(op2) end,
+   __add      = function(op1, op2) return getnum(op1)   +   getnum(op2)  end,
+   __sub      = function(op1, op2) return getnum(op1)   -   getnum(op2)  end,
+   __mul      = function(op1, op2) return getnum(op1)   *   getnum(op2)  end,
+   __div      = function(op1, op2) return getnum(op1)   /   getnum(op2)  end,
+   __mod      = function(op1, op2) return getnum(op1)   %   getnum(op2)  end,
+   __pow      = function(op1, op2) return getnum(op1)   ^   getnum(op2)  end,
+   __lt       = function(op1, op2) return getnum(op1)   <   getnum(op2)  end,
+   __eq       = function(op1, op2) return getnum(op1)   ==  getnum(op2)  end,
+   __le       = function(op1, op2) return getnum(op1)   <=  getnum(op2)  end,
+}
+
+function OBJDEF:asNumber(item)
+
+   if getmetatable(item) == isNumber then
+      -- it's already a JSON number object.
+      return item
+   elseif type(item) == 'table' and type(item.S) == 'string' and type(item.N) == 'number' then
+      -- it's a number-object table that lost its metatable, so give it one
+      return setmetatable(item, isNumber)
+   else
+      -- the normal situation... given a number or a string representation of a number....
+      local holder = {
+         S = tostring(item), -- S is the representation of the number as a string, which remains precise
+         N = tonumber(item), -- N is the number as a Lua number.
+      }
+      return setmetatable(holder, isNumber)
+   end
+end
+
+local function unicode_codepoint_as_utf8(codepoint)
+   --
+   -- codepoint is a number
+   --
+   if codepoint <= 127 then
+      return string.char(codepoint)
+
+   elseif codepoint <= 2047 then
+      --
+      -- 110yyyxx 10xxxxxx         <-- useful notation from http://en.wikipedia.org/wiki/Utf8
+      --
+      local highpart = math.floor(codepoint / 0x40)
+      local lowpart  = codepoint - (0x40 * highpart)
+      return string.char(0xC0 + highpart,
+                         0x80 + lowpart)
+
+   elseif codepoint <= 65535 then
+      --
+      -- 1110yyyy 10yyyyxx 10xxxxxx
+      --
+      local highpart  = math.floor(codepoint / 0x1000)
+      local remainder = codepoint - 0x1000 * highpart
+      local midpart   = math.floor(remainder / 0x40)
+      local lowpart   = remainder - 0x40 * midpart
+
+      highpart = 0xE0 + highpart
+      midpart  = 0x80 + midpart
+      lowpart  = 0x80 + lowpart
+
+      --
+      -- Check for an invalid character (thanks Andy R. at Adobe).
+      -- See table 3.7, page 93, in http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf#G28070
+      --
+      if ( highpart == 0xE0 and midpart < 0xA0 ) or
+         ( highpart == 0xED and midpart > 0x9F ) or
+         ( highpart == 0xF0 and midpart < 0x90 ) or
+         ( highpart == 0xF4 and midpart > 0x8F )
+      then
+         return "?"
+      else
+         return string.char(highpart,
+                            midpart,
+                            lowpart)
+      end
+
+   else
+      --
+      -- 11110zzz 10zzyyyy 10yyyyxx 10xxxxxx
+      --
+      local highpart  = math.floor(codepoint / 0x40000)
+      local remainder = codepoint - 0x40000 * highpart
+      local midA      = math.floor(remainder / 0x1000)
+      remainder       = remainder - 0x1000 * midA
+      local midB      = math.floor(remainder / 0x40)
+      local lowpart   = remainder - 0x40 * midB
+
+      return string.char(0xF0 + highpart,
+                         0x80 + midA,
+                         0x80 + midB,
+                         0x80 + lowpart)
+   end
+end
+
+function OBJDEF:onDecodeError(message, text, location, etc)
+   if text then
+      if location then
+         message = string.format("%s at char %d of: %s", message, location, text)
+      else
+         message = string.format("%s: %s", message, text)
+      end
+   end
+
+   if etc ~= nil then
+      message = message .. " (" .. OBJDEF:encode(etc) .. ")"
+   end
+
+   if self.assert then
+      self.assert(false, message)
+   else
+      assert(false, message)
+   end
+end
+
+OBJDEF.onDecodeOfNilError  = OBJDEF.onDecodeError
+OBJDEF.onDecodeOfHTMLError = OBJDEF.onDecodeError
+
+function OBJDEF:onEncodeError(message, etc)
+   if etc ~= nil then
+      message = message .. " (" .. OBJDEF:encode(etc) .. ")"
+   end
+
+   if self.assert then
+      self.assert(false, message)
+   else
+      assert(false, message)
+   end
+end
+
+local function grok_number(self, text, start, options)
+   --
+   -- Grab the integer part
+   --
+   local integer_part = text:match('^-?[1-9]%d*', start)
+                     or text:match("^-?0",        start)
+
+   if not integer_part then
+      self:onDecodeError("expected number", text, start, options.etc)
+   end
+
+   local i = start + integer_part:len()
+
+   --
+   -- Grab an optional decimal part
+   --
+   local decimal_part = text:match('^%.%d+', i) or ""
+
+   i = i + decimal_part:len()
+
+   --
+   -- Grab an optional exponential part
+   --
+   local exponent_part = text:match('^[eE][-+]?%d+', i) or ""
+
+   i = i + exponent_part:len()
+
+   local full_number_text = integer_part .. decimal_part .. exponent_part
+
+   if options.decodeNumbersAsObjects then
+      return OBJDEF:asNumber(full_number_text), i
+   end
+
+   --
+   -- If we're told to stringify under certain conditions, so do.
+   -- We punt a bit when there's an exponent by just stringifying no matter what.
+   -- I suppose we should really look to see whether the exponent is actually big enough one
+   -- way or the other to trip stringification, but I'll be lazy about it until someone asks.
+   --
+   if (options.decodeIntegerStringificationLength
+       and
+      (integer_part:len() >= options.decodeIntegerStringificationLength or exponent_part:len() > 0))
+
+       or
+
+      (options.decodeDecimalStringificationLength 
+       and
+       (decimal_part:len() >= options.decodeDecimalStringificationLength or exponent_part:len() > 0))
+   then
+      return full_number_text, i -- this returns the exact string representation seen in the original JSON
+   end
+
+
+
+   local as_number = tonumber(full_number_text)
+
+   if not as_number then
+      self:onDecodeError("bad number", text, start, options.etc)
+   end
+
+   return as_number, i
+end
+
+
+local function grok_string(self, text, start, options)
+
+   if text:sub(start,start) ~= '"' then
+      self:onDecodeError("expected string's opening quote", text, start, options.etc)
+   end
+
+   local i = start + 1 -- +1 to bypass the initial quote
+   local text_len = text:len()
+   local VALUE = ""
+   while i <= text_len do
+      local c = text:sub(i,i)
+      if c == '"' then
+         return VALUE, i + 1
+      end
+      if c ~= '\\' then
+         VALUE = VALUE .. c
+         i = i + 1
+      elseif text:match('^\\b', i) then
+         VALUE = VALUE .. "\b"
+         i = i + 2
+      elseif text:match('^\\f', i) then
+         VALUE = VALUE .. "\f"
+         i = i + 2
+      elseif text:match('^\\n', i) then
+         VALUE = VALUE .. "\n"
+         i = i + 2
+      elseif text:match('^\\r', i) then
+         VALUE = VALUE .. "\r"
+         i = i + 2
+      elseif text:match('^\\t', i) then
+         VALUE = VALUE .. "\t"
+         i = i + 2
+      else
+         local hex = text:match('^\\u([0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF])', i)
+         if hex then
+            i = i + 6 -- bypass what we just read
+
+            -- We have a Unicode codepoint. It could be standalone, or if in the proper range and
+            -- followed by another in a specific range, it'll be a two-code surrogate pair.
+            local codepoint = tonumber(hex, 16)
+            if codepoint >= 0xD800 and codepoint <= 0xDBFF then
+               -- it's a hi surrogate... see whether we have a following low
+               local lo_surrogate = text:match('^\\u([dD][cdefCDEF][0123456789aAbBcCdDeEfF][0123456789aAbBcCdDeEfF])', i)
+               if lo_surrogate then
+                  i = i + 6 -- bypass the low surrogate we just read
+                  codepoint = 0x2400 + (codepoint - 0xD800) * 0x400 + tonumber(lo_surrogate, 16)
+               else
+                  -- not a proper low, so we'll just leave the first codepoint as is and spit it out.
+               end
+            end
+            VALUE = VALUE .. unicode_codepoint_as_utf8(codepoint)
+
+         else
+
+            -- just pass through what's escaped
+            VALUE = VALUE .. text:match('^\\(.)', i)
+            i = i + 2
+         end
+      end
+   end
+
+   self:onDecodeError("unclosed string", text, start, options.etc)
+end
+
+local function skip_whitespace(text, start)
+
+   local _, match_end = text:find("^[ \n\r\t]+", start) -- [http://www.ietf.org/rfc/rfc4627.txt] Section 2
+   if match_end then
+      return match_end + 1
+   else
+      return start
+   end
+end
+
+local grok_one -- assigned later
+
+local function grok_object(self, text, start, options)
+
+   if text:sub(start,start) ~= '{' then
+      self:onDecodeError("expected '{'", text, start, options.etc)
+   end
+
+   local i = skip_whitespace(text, start + 1) -- +1 to skip the '{'
+
+   local VALUE = self.strictTypes and self:newObject { } or { }
+
+   if text:sub(i,i) == '}' then
+      return VALUE, i + 1
+   end
+   local text_len = text:len()
+   while i <= text_len do
+      local key, new_i = grok_string(self, text, i, options)
+
+      i = skip_whitespace(text, new_i)
+
+      if text:sub(i, i) ~= ':' then
+         self:onDecodeError("expected colon", text, i, options.etc)
+      end
+
+      i = skip_whitespace(text, i + 1)
+
+      local new_val, new_i = grok_one(self, text, i, options)
+
+      VALUE[key] = new_val
+
+      --
+      -- Expect now either '}' to end things, or a ',' to allow us to continue.
+      --
+      i = skip_whitespace(text, new_i)
+
+      local c = text:sub(i,i)
+
+      if c == '}' then
+         return VALUE, i + 1
+      end
+
+      if text:sub(i, i) ~= ',' then
+         self:onDecodeError("expected comma or '}'", text, i, options.etc)
+      end
+
+      i = skip_whitespace(text, i + 1)
+   end
+
+   self:onDecodeError("unclosed '{'", text, start, options.etc)
+end
+
+local function grok_array(self, text, start, options)
+   if text:sub(start,start) ~= '[' then
+      self:onDecodeError("expected '['", text, start, options.etc)
+   end
+
+   local i = skip_whitespace(text, start + 1) -- +1 to skip the '['
+   local VALUE = self.strictTypes and self:newArray { } or { }
+   if text:sub(i,i) == ']' then
+      return VALUE, i + 1
+   end
+
+   local VALUE_INDEX = 1
+
+   local text_len = text:len()
+   while i <= text_len do
+      local val, new_i = grok_one(self, text, i, options)
+
+      -- can't table.insert(VALUE, val) here because it's a no-op if val is nil
+      VALUE[VALUE_INDEX] = val
+      VALUE_INDEX = VALUE_INDEX + 1
+
+      i = skip_whitespace(text, new_i)
+
+      --
+      -- Expect now either ']' to end things, or a ',' to allow us to continue.
+      --
+      local c = text:sub(i,i)
+      if c == ']' then
+         return VALUE, i + 1
+      end
+      if text:sub(i, i) ~= ',' then
+         self:onDecodeError("expected comma or '['", text, i, options.etc)
+      end
+      i = skip_whitespace(text, i + 1)
+   end
+   self:onDecodeError("unclosed '['", text, start, options.etc)
+end
+
+
+grok_one = function(self, text, start, options)
+   -- Skip any whitespace
+   start = skip_whitespace(text, start)
+
+   if start > text:len() then
+      self:onDecodeError("unexpected end of string", text, nil, options.etc)
+   end
+
+   if text:find('^"', start) then
+      return grok_string(self, text, start, options.etc)
+
+   elseif text:find('^[-0123456789 ]', start) then
+      return grok_number(self, text, start, options)
+
+   elseif text:find('^%{', start) then
+      return grok_object(self, text, start, options)
+
+   elseif text:find('^%[', start) then
+      return grok_array(self, text, start, options)
+
+   elseif text:find('^true', start) then
+      return true, start + 4
+
+   elseif text:find('^false', start) then
+      return false, start + 5
+
+   elseif text:find('^null', start) then
+      return nil, start + 4
+
+   else
+      self:onDecodeError("can't parse JSON", text, start, options.etc)
+   end
+end
+
+function OBJDEF:decode(text, etc, options)
+   --
+   -- If the user didn't pass in a table of decode options, make an empty one.
+   --
+   if type(options) ~= 'table' then
+      options = {}
+   end
+
+   --
+   -- If they passed in an 'etc' argument, stuff it into the options.
+   -- (If not, any 'etc' field in the options they passed in remains to be used)
+   --
+   if etc ~= nil then
+      options.etc = etc
+   end
+
+
+   if type(self) ~= 'table' or self.__index ~= OBJDEF then
+      OBJDEF:onDecodeError("JSON:decode must be called in method format", nil, nil, options.etc)
+   end
+
+   if text == nil then
+      self:onDecodeOfNilError(string.format("nil passed to JSON:decode()"), nil, nil, options.etc)
+   elseif type(text) ~= 'string' then
+      self:onDecodeError(string.format("expected string argument to JSON:decode(), got %s", type(text)), nil, nil, options.etc)
+   end
+
+   if text:match('^%s*$') then
+      return nil
+   end
+
+   if text:match('^%s*<') then
+      -- Can't be JSON... we'll assume it's HTML
+      self:onDecodeOfHTMLError(string.format("html passed to JSON:decode()"), text, nil, options.etc)
+   end
+
+   --
+   -- Ensure that it's not UTF-32 or UTF-16.
+   -- Those are perfectly valid encodings for JSON (as per RFC 4627 section 3),
+   -- but this package can't handle them.
+   --
+   if text:sub(1,1):byte() == 0 or (text:len() >= 2 and text:sub(2,2):byte() == 0) then
+      self:onDecodeError("JSON package groks only UTF-8, sorry", text, nil, options.etc)
+   end
+
+   --
+   -- apply global options
+   --
+   if options.decodeNumbersAsObjects == nil then
+      options.decodeNumbersAsObjects = self.decodeNumbersAsObjects
+   end
+   if options.decodeIntegerStringificationLength == nil then
+      options.decodeIntegerStringificationLength = self.decodeIntegerStringificationLength
+   end
+   if options.decodeDecimalStringificationLength == nil then
+      options.decodeDecimalStringificationLength = self.decodeDecimalStringificationLength
+   end
+
+   local success, value = pcall(grok_one, self, text, 1, options)
+
+   if success then
+      return value
+   else
+      -- if JSON:onDecodeError() didn't abort out of the pcall, we'll have received the error message here as "value", so pass it along as an assert.
+      if self.assert then
+         self.assert(false, value)
+      else
+         assert(false, value)
+      end
+      -- and if we're still here, return a nil and throw the error message on as a second arg
+      return nil, value
+   end
+end
+
+local function backslash_replacement_function(c)
+   if c == "\n" then
+      return "\\n"
+   elseif c == "\r" then
+      return "\\r"
+   elseif c == "\t" then
+      return "\\t"
+   elseif c == "\b" then
+      return "\\b"
+   elseif c == "\f" then
+      return "\\f"
+   elseif c == '"' then
+      return '\\"'
+   elseif c == '\\' then
+      return '\\\\'
+   else
+      return string.format("\\u%04x", c:byte())
+   end
+end
+
+local chars_to_be_escaped_in_JSON_string
+   = '['
+   ..    '"'    -- class sub-pattern to match a double quote
+   ..    '%\\'  -- class sub-pattern to match a backslash
+   ..    '%z'   -- class sub-pattern to match a null
+   ..    '\001' .. '-' .. '\031' -- class sub-pattern to match control characters
+   .. ']'
+
+
+local LINE_SEPARATOR_as_utf8      = unicode_codepoint_as_utf8(0x2028)
+local PARAGRAPH_SEPARATOR_as_utf8 = unicode_codepoint_as_utf8(0x2029)
+local function json_string_literal(value, options)
+   local newval = value:gsub(chars_to_be_escaped_in_JSON_string, backslash_replacement_function)
+   if options.stringsAreUtf8 then
+      --
+      -- This feels really ugly to just look into a string for the sequence of bytes that we know to be a particular utf8 character,
+      -- but utf8 was designed purposefully to make this kind of thing possible. Still, feels dirty.
+      -- I'd rather decode the byte stream into a character stream, but it's not technically needed so
+      -- not technically worth it.
+      --
+      newval = newval:gsub(LINE_SEPARATOR_as_utf8, '\\u2028'):gsub(PARAGRAPH_SEPARATOR_as_utf8,'\\u2029')
+   end
+   return '"' .. newval .. '"'
+end
+
+local function object_or_array(self, T, etc)
+   --
+   -- We need to inspect all the keys... if there are any strings, we'll convert to a JSON
+   -- object. If there are only numbers, it's a JSON array.
+   --
+   -- If we'll be converting to a JSON object, we'll want to sort the keys so that the
+   -- end result is deterministic.
+   --
+   local string_keys = { }
+   local number_keys = { }
+   local number_keys_must_be_strings = false
+   local maximum_number_key
+
+   for key in pairs(T) do
+      if type(key) == 'string' then
+         table.insert(string_keys, key)
+      elseif type(key) == 'number' then
+         table.insert(number_keys, key)
+         if key <= 0 or key >= math.huge then
+            number_keys_must_be_strings = true
+         elseif not maximum_number_key or key > maximum_number_key then
+            maximum_number_key = key
+         end
+      else
+         self:onEncodeError("can't encode table with a key of type " .. type(key), etc)
+      end
+   end
+
+   if #string_keys == 0 and not number_keys_must_be_strings then
+      --
+      -- An empty table, or a numeric-only array
+      --
+      if #number_keys > 0 then
+         return nil, maximum_number_key -- an array
+      elseif tostring(T) == "JSON array" then
+         return nil
+      elseif tostring(T) == "JSON object" then
+         return { }
+      else
+         -- have to guess, so we'll pick array, since empty arrays are likely more common than empty objects
+         return nil
+      end
+   end
+
+   table.sort(string_keys)
+
+   local map
+   if #number_keys > 0 then
+      --
+      -- If we're here then we have either mixed string/number keys, or numbers inappropriate for a JSON array
+      -- It's not ideal, but we'll turn the numbers into strings so that we can at least create a JSON object.
+      --
+
+      if self.noKeyConversion then
+         self:onEncodeError("a table with both numeric and string keys could be an object or array; aborting", etc)
+      end
+
+      --
+      -- Have to make a shallow copy of the source table so we can remap the numeric keys to be strings
+      --
+      map = { }
+      for key, val in pairs(T) do
+         map[key] = val
+      end
+
+      table.sort(number_keys)
+
+      --
+      -- Throw numeric keys in there as strings
+      --
+      for _, number_key in ipairs(number_keys) do
+         local string_key = tostring(number_key)
+         if map[string_key] == nil then
+            table.insert(string_keys , string_key)
+            map[string_key] = T[number_key]
+         else
+            self:onEncodeError("conflict converting table with mixed-type keys into a JSON object: key " .. number_key .. " exists both as a string and a number.", etc)
+         end
+      end
+   end
+
+   return string_keys, nil, map
+end
+
+--
+-- Encode
+--
+-- 'options' is nil, or a table with possible keys:
+--
+--    pretty         -- If true, return a pretty-printed version.
+--
+--    indent         -- A string (usually of spaces) used to indent each nested level.
+--
+--    align_keys     -- If true, align all the keys when formatting a table.
+--
+--    null           -- If this exists with a string value, table elements with this value are output as JSON null.
+--
+--    stringsAreUtf8 -- If true, consider Lua strings not as a sequence of bytes, but as a sequence of UTF-8 characters.
+--                      (Currently, the only practical effect of setting this option is that Unicode LINE and PARAGRAPH
+--                       separators, if found in a string, are encoded with a JSON escape instead of as raw UTF-8.
+--                       The JSON is valid either way, but encoding this way, apparently, allows the resulting JSON
+--                       to also be valid Java.)
+--
+--
+local encode_value -- must predeclare because it calls itself
+function encode_value(self, value, parents, etc, options, indent, for_key)
+
+   --
+   -- keys in a JSON object can never be null, so we don't even consider options.null when converting a key value
+   --
+   if value == nil or (not for_key and options and options.null and value == options.null) then
+      return 'null'
+
+   elseif type(value) == 'string' then
+      return json_string_literal(value, options)
+
+   elseif type(value) == 'number' then
+      if value ~= value then
+         --
+         -- NaN (Not a Number).
+         -- JSON has no NaN, so we have to fudge the best we can. This should really be a package option.
+         --
+         return "null"
+      elseif value >= math.huge then
+         --
+         -- Positive infinity. JSON has no INF, so we have to fudge the best we can. This should
+         -- really be a package option. Note: at least with some implementations, positive infinity
+         -- is both ">= math.huge" and "<= -math.huge", which makes no sense but that's how it is.
+         -- Negative infinity is properly "<= -math.huge". So, we must be sure to check the ">="
+         -- case first.
+         --
+         return "1e+9999"
+      elseif value <= -math.huge then
+         --
+         -- Negative infinity.
+         -- JSON has no INF, so we have to fudge the best we can. This should really be a package option.
+         --
+         return "-1e+9999"
+      else
+         return tostring(value)
+      end
+
+   elseif type(value) == 'boolean' then
+      return tostring(value)
+
+   elseif type(value) ~= 'table' then
+      self:onEncodeError("can't convert " .. type(value) .. " to JSON", etc)
+
+   elseif getmetatable(value) == isNumber then
+      return tostring(value)
+   else
+      --
+      -- A table to be converted to either a JSON object or array.
+      --
+      local T = value
+
+      if type(options) ~= 'table' then
+         options = {}
+      end
+      if type(indent) ~= 'string' then
+         indent = ""
+      end
+
+      if parents[T] then
+         self:onEncodeError("table " .. tostring(T) .. " is a child of itself", etc)
+      else
+         parents[T] = true
+      end
+
+      local result_value
+
+      local object_keys, maximum_number_key, map = object_or_array(self, T, etc)
+      if maximum_number_key then
+         --
+         -- An array...
+         --
+         local ITEMS = { }
+         for i = 1, maximum_number_key do
+            table.insert(ITEMS, encode_value(self, T[i], parents, etc, options, indent))
+         end
+
+         if options.pretty then
+            result_value = "[ " .. table.concat(ITEMS, ", ") .. " ]"
+         else
+            result_value = "["  .. table.concat(ITEMS, ",")  .. "]"
+         end
+
+      elseif object_keys then
+         --
+         -- An object
+         --
+         local TT = map or T
+
+         if options.pretty then
+
+            local KEYS = { }
+            local max_key_length = 0
+            for _, key in ipairs(object_keys) do
+               local encoded = encode_value(self, tostring(key), parents, etc, options, indent, true)
+               if options.align_keys then
+                  max_key_length = math.max(max_key_length, #encoded)
+               end
+               table.insert(KEYS, encoded)
+            end
+            local key_indent = indent .. tostring(options.indent or "")
+            local subtable_indent = key_indent .. string.rep(" ", max_key_length) .. (options.align_keys and "  " or "")
+            local FORMAT = "%s%" .. string.format("%d", max_key_length) .. "s: %s"
+
+            local COMBINED_PARTS = { }
+            for i, key in ipairs(object_keys) do
+               local encoded_val = encode_value(self, TT[key], parents, etc, options, subtable_indent)
+               table.insert(COMBINED_PARTS, string.format(FORMAT, key_indent, KEYS[i], encoded_val))
+            end
+            result_value = "{\n" .. table.concat(COMBINED_PARTS, ",\n") .. "\n" .. indent .. "}"
+
+         else
+
+            local PARTS = { }
+            for _, key in ipairs(object_keys) do
+               local encoded_val = encode_value(self, TT[key],       parents, etc, options, indent)
+               local encoded_key = encode_value(self, tostring(key), parents, etc, options, indent, true)
+               table.insert(PARTS, string.format("%s:%s", encoded_key, encoded_val))
+            end
+            result_value = "{" .. table.concat(PARTS, ",") .. "}"
+
+         end
+      else
+         --
+         -- An empty array/object... we'll treat it as an array, though it should really be an option
+         --
+         result_value = "[]"
+      end
+
+      parents[T] = false
+      return result_value
+   end
+end
+
+
+function OBJDEF:encode(value, etc, options)
+   if type(self) ~= 'table' or self.__index ~= OBJDEF then
+      OBJDEF:onEncodeError("JSON:encode must be called in method format", etc)
+   end
+
+   --
+   -- If the user didn't pass in a table of decode options, make an empty one.
+   --
+   if type(options) ~= 'table' then
+      options = {}
+   end
+
+   return encode_value(self, value, {}, etc, options)
+end
+
+function OBJDEF:encode_pretty(value, etc, options)
+   if type(self) ~= 'table' or self.__index ~= OBJDEF then
+      OBJDEF:onEncodeError("JSON:encode_pretty must be called in method format", etc)
+   end
+
+   --
+   -- If the user didn't pass in a table of decode options, use the default pretty ones
+   --
+   if type(options) ~= 'table' then
+      options = default_pretty_options
+   end
+
+   return encode_value(self, value, {}, etc, options)
+end
+
+function OBJDEF.__tostring()
+   return "JSON encode/decode package"
+end
+
+OBJDEF.__index = OBJDEF
+
+function OBJDEF:new(args)
+   local new = { }
+
+   if args then
+      for key, val in pairs(args) do
+         new[key] = val
+      end
+   end
+
+   return setmetatable(new, OBJDEF)
+end
+
+return OBJDEF:new()