Spring RTS Engine

The GPLed engine is not a system library so linking to it statically or
dynamically can be done only under the terms of the GPL. The GPLed
engine may use system libraries, but this doesn't make the system
libraries exception apply to the engine. It only means that you do not
have to provide the source code for those system libraries when you
distribute the engine.

The Lua interpreter is indeed a separate facility. It may use system
libraries, but is not covered by the system library exception.

> To the best of the my understanding, the TDF files could in theory work
> with any mod. The TDF files behave more like configuration files. Files
> which have this type of relationship with the GPLed code can be
> distributed under any license which does not restrict the distribution
> of the whole mod more than what the GPL would.
>

An ├óÔé¼┼ôaggregate├óÔé¼┬Ø consists of a number of separate programs, distributed together on the same CD-ROM or other media. The GPL permits you to create and distribute an aggregate, even when the licenses of the other software are non-free or GPL-incompatible. The only condition is that you cannot release the aggregate under a license that prohibits users from exercising rights that each program's individual license would grant them.

Where's the line between two separate programs, and one program with two parts? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication (exec, pipes, rpc, function calls within a shared address space, etc.) and the semantics of the communication (what kinds of information are interchanged).

If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.

By contrast, pipes, sockets and command-line arguments are communication mechanisms normally used between two separate programs. So when they are used for communication, the modules normally are separate programs. But if the semantics of the communication are intimate enough, exchanging complex internal data structures, that too could be a basis to consider the two parts as combined into a larger program.

Argh wrote:However, most of that stuff, above, is untested ground. I can't take it really seriously, tbh, I think that courts will have a field day trying to argue about this, if it ever gets into court,

non-Turing-complete interpreted scripts like our Lua.

non-Turing-complete interpreted scripts like our Lua.

local tape = {}
local position = 2000

function Brainfuck(input, code, index)
	local output = ""
	local entry
	if not index then
		index = 1
	else
		entry = index
	end
	while index < #code do
		if code[index] == "+" then
			if tape[position] then
				tape[position] = tape[position] + 1
			else
				tape[position] = 1
			end
		elseif code[index] == "-" then
			if tape[position] then
				tape[position] = tape[position] - 1
			else
				tape[position] = -1
			end
		elseif code[index] == "<" then
			position = position - 1
		elseif code[index] == ">" then
			position = position + 1
		elseif code[index] == "," then
			tape[position] = input:byte(1)
			input = input:sub(2)
		elseif code[index] == "." then
			output = output .. string.char(tape[position])
		elseif code[index] == "[" then
			output, index = Brainfuck(input, code, index)
		elseif code[index] == "]" then
			if tape[position] and tape[position]~=0 then
				return output, entry
			else
				return output, index + 1
			end
		end
		index = index + 1
	end
	if entry then
		error()
	end
	return output, index
end

Forboding Angel wrote:Something tells me we are is some deep shit. I was afraid of this happening, but it's a lot worse than I feared.

Well, trepan wrote the lua stuff on the engine side, he could re-license it I believe? That would basically free mods I think from the snares. Assuming we can find all the lua devs that made our stuff and get the to re-license it as well.

What are the chances of the FSF coming after us? Do they care? TBH I don't really feel like opening thunderbird to a C&D.

The correct approach is probably to LGPL all engine code,
and distributed lua code (namely the widget/gadget handlers).
The bzflag project did the GPL -> LGPL conversion for all files
in their project some time ago for this very reason.

trepan wrote:The correct approach is probably to LGPL all engine code,
and distributed lua code (namely the widget/gadget handlers).