ddnet/default.bam

CheckVersion("0.2")

Import("other/sdl/sdl.bam")

--- Setup Config --------
config = NewConfig()
config:Add(OptFindCompiler())
config:Add(OptTestCompileC("stackprotector", "int main(){return 0;}", "-fstack-protector -fstack-protector-all"))
config:Add(OptFindLibrary("zlib", "zlib.h", false))
config:Add(SDL.OptFind("sdl", true))
config:Finalize("config.bam")

-- data compiler
function Script(name)
	if family == "windows" then
		return str_replace(name, "/", "\\")
	end
	return "python " .. name
end

function CHash(output, ...)
	local inputs = FlatternTable({...})
	
	output = Path(output)
	
	-- compile all the files
	local cmd = Script("scripts/cmd5.py") .. " "
	for index, inname in ipairs(inputs) do
		cmd = cmd .. Path(inname) .. " " 
	end
	
	cmd = cmd .. " > " .. output
	
	AddJob(output, "cmd5 " .. output, cmd)
	for index, inname in ipairs(inputs) do
		AddDependency(output, inname)
	end
	return output
end

function ResCompile(scriptfile)
	scriptfile = Path(scriptfile)
	output = PathBase(scriptfile) .. ".res"
	AddJob(output, "rc " .. scriptfile, "rc /fo " .. output .. " " .. scriptfile)
	AddDependency(output, scriptfile)
	return output
end

function Dat2c(datafile, sourcefile, arrayname)
	datafile = Path(datafile)
	sourcefile = Path(sourcefile)

	AddJob(
		sourcefile,
		"dat2c " .. PathFilename(sourcefile) .. " = " .. PathFilename(datafile),
		Script("scripts/dat2c.py") .. " " .. datafile .. " " .. arrayname .. " > " .. sourcefile
	)
	AddDependency(sourcefile, datafile)
	return sourcefile
end

function ContentCompile(action, output)
	output = Path(output)
	AddJob(
		output,
		action .. " > " .. output,
		Script("datasrc/compile.py") .. " " .. action .. " > " .. Path(output)
	)
	AddDependency(output, Path("datasrc/content.py")) -- do this more proper
	AddDependency(output, Path("datasrc/network.py"))
	AddDependency(output, Path("datasrc/compile.py"))
	AddDependency(output, Path("datasrc/datatypes.py"))
	return output
end

-- Content Compile
network_source = ContentCompile("network_source", "src/game/generated/g_protocol.cpp")
network_header = ContentCompile("network_header", "src/game/generated/g_protocol.hpp")
client_content_source = ContentCompile("client_content_source", "src/game/generated/gc_data.cpp")
client_content_header = ContentCompile("client_content_header", "src/game/generated/gc_data.hpp")
server_content_source = ContentCompile("server_content_source", "src/game/generated/gs_data.cpp")
server_content_header = ContentCompile("server_content_header", "src/game/generated/gs_data.hpp")

AddDependency(network_source, network_header)
AddDependency(client_content_source, client_content_header)
AddDependency(server_content_source, server_content_header)

nethash = CHash("src/game/generated/nethash.c", "src/engine/e_protocol.h", "src/game/generated/g_protocol.hpp", "src/game/tuning.hpp", "src/game/gamecore.cpp", network_header)

client_link_other = {}
client_depends = {}

if family == "windows" then
	table.insert(client_depends, Copy(".", "other\\sdl\\vc2005libs\\SDL.dll"))
end
	

if config.compiler.value == "cl" then
	client_link_other = {ResCompile("other/icons/teeworlds.rc")}
end

function Intermediate_Output(settings, input)
	return Path("objs/" .. PathBase(PathFilename(input)) .. settings.config_ext)
end

function build(settings)
	--settings.objdir = Path("objs")
	settings.cc.Output = Intermediate_Output

	if config.compiler.value == "cl" then
		settings.cc.flags:Add("/wd4244")
	else
		settings.cc.flags:Add("-Wall", "-fno-exceptions")
		if platform == "macosx" then
			settings.cc.flags:Add("-mmacosx-version-min=10.4", "-isysroot /Developer/SDKs/MacOSX10.4u.sdk")
			settings.link.flags:Add("-mmacosx-version-min=10.4", "-isysroot /Developer/SDKs/MacOSX10.4u.sdk")
		elseif config.stackprotector.value == 1 then
			settings.cc.flags:Add("-fstack-protector", "-fstack-protector-all")
			settings.link.flags:Add("-fstack-protector", "-fstack-protector-all")
		end
	end

	-- set some platform specific settings
	settings.cc.includes:Add("src")

	if family == "unix" then
   		if platform == "macosx" then
			glfw_platform = "macosx"
			pa_platform = "mac_osx"
			settings.link.frameworks:Add("Carbon")
			settings.link.frameworks:Add("AppKit")
		else
			glfw_platform = "x11"
			pa_platform = "unix"
			settings.link.libs:Add("pthread")
		end
	elseif family == "windows" then
		glfw_platform = "win32"
		pa_platform = "win"
		settings.link.libs:Add("gdi32")
		settings.link.libs:Add("user32")
		settings.link.libs:Add("ws2_32")
		settings.link.libs:Add("ole32")
		settings.link.libs:Add("shell32")
	end
	
	-- compile zlib if needed
	if config.zlib.value == 1 then
		settings.link.libs:Add("z")
		if config.zlib.include_path then
			settings.cc.includes:Add(config.zlib.include_path)
		end
		zlib = {}
	else
		zlib = Compile(settings, Collect("src/engine/external/zlib/*.c"))
		settings.cc.includes:Add("src/engine/external/zlib")
	end

	-- build the small libraries
	wavpack = Compile(settings, Collect("src/engine/external/wavpack/*.c"))
	pnglite = Compile(settings, Collect("src/engine/external/pnglite/*.c"))
	
	-- build game components
	engine_settings = settings:Copy()
	server_settings = engine_settings:Copy()
	client_settings = engine_settings:Copy()

	if family == "unix" then
   		if platform == "macosx" then
			client_settings.link.frameworks:Add("OpenGL")
            client_settings.link.frameworks:Add("AGL")
            client_settings.link.frameworks:Add("Carbon")
            client_settings.link.frameworks:Add("Cocoa")
		else
			client_settings.link.libs:Add("X11")
			client_settings.link.libs:Add("GL")
			client_settings.link.libs:Add("GLU")
		end
	elseif family == "windows" then
		client_settings.link.libs:Add("opengl32")
		client_settings.link.libs:Add("glu32")
		client_settings.link.libs:Add("winmm")
	end

	-- apply sdl settings
	config.sdl:Apply(client_settings)
	
	engine = Compile(engine_settings, Collect("src/engine/*.c", "src/base/*.c"))
	client = Compile(client_settings, Collect("src/engine/client/*.c"))
	server = Compile(server_settings, Collect("src/engine/server/*.c"))
	
	versionserver = Compile(settings, Collect("src/versionsrv/*.cpp"))
	masterserver = Compile(settings, Collect("src/mastersrv/*.cpp"))
	game_shared = Compile(settings, Collect("src/game/*.cpp"), nethash, network_source)
	game_client = Compile(settings, CollectRecursive("src/game/client/*.cpp"), client_content_source)
	game_server = Compile(settings, CollectRecursive("src/game/server/*.cpp"), server_content_source)
	game_editor = Compile(settings, Collect("src/game/editor/*.cpp"))

	-- build tools (TODO: fix this so we don't get double _d_d stuff)
	tools_src = Collect("src/tools/*.cpp", "src/tools/*.c")

	osxlaunch = {}
	if platform == "macosx" then
		osxlaunch = Compile(client_settings, Collect("src/osxlaunch/*.m"))
	end
	
	tools = {}
	for i,v in ipairs(tools_src) do
		toolname = PathFilename(PathBase(v))
		tools[i] = Link(settings, toolname, Compile(settings, v), engine, zlib)
	end
	
	-- build client, server, version server and master server
	client_exe = Link(client_settings, "teeworlds", game_shared, game_client,
		engine, client, game_editor, zlib, pnglite, wavpack,
		client_link_other, osxlaunch)

	server_exe = Link(server_settings, "teeworlds_srv", engine, server,
		game_shared, game_server, zlib)
		
	versionserver_exe = Link(server_settings, "versionsrv", versionserver,
		engine, zlib)

	masterserver_exe = Link(server_settings, "mastersrv", masterserver,
		engine, zlib)

	-- make targets
	c = PseudoTarget("client".."_"..settings.config_name, client_exe, client_depends)
	s = PseudoTarget("server".."_"..settings.config_name, server_exe)
	g = PseudoTarget("game".."_"..settings.config_name, client_exe, server_exe)

	v = PseudoTarget("versionserver".."_"..settings.config_name, versionserver_exe)
	m = PseudoTarget("masterserver".."_"..settings.config_name, masterserver_exe)
	t = PseudoTarget("tools".."_"..settings.config_name, tools)

	Target(c)
	Target(s)
	Target(v)
	Target(m)
	Target(t)
	
	all = PseudoTarget(settings.config_name, c, s, v, m, t)

	Target(all)
	return all
end

if platform == "macosx"  and arch == "ia32" then
	debug_settings_ppc = NewSettings()
	debug_settings_ppc.config_name = "debug_ppc"
	debug_settings_ppc.config_ext = "_ppc_d"
	debug_settings_ppc.debug = 1
	debug_settings_ppc.cc.optimize = 0
	debug_settings_ppc.cc.flags:Add("-arch ppc")
	debug_settings_ppc.link.flags:Add("-arch ppc")

	release_settings_ppc = NewSettings()
	release_settings_ppc.config_name = "release_ppc"
	release_settings_ppc.config_ext = "_ppc"
	release_settings_ppc.debug = 0
	release_settings_ppc.cc.optimize = 1
	release_settings_ppc.cc.flags:Add("-arch ppc")
	release_settings_ppc.link.flags:Add("-arch ppc")

	debug_settings_x86 = NewSettings()
	debug_settings_x86.config_name = "debug_x86"
	debug_settings_x86.config_ext = "_x86_d"
	debug_settings_x86.debug = 1
	debug_settings_x86.cc.optimize = 0

	release_settings_x86 = NewSettings()
	release_settings_x86.config_name = "release_x86"
	release_settings_x86.config_ext = "_x86"
	release_settings_x86.debug = 0
	release_settings_x86.cc.optimize = 1

	ppc_d = build(debug_settings_ppc)
	x86_d = build(debug_settings_x86)
	ppc_r = build(release_settings_ppc)
	x86_r = build(release_settings_x86)
	DefaultTarget("game_debug_x86")
	PseudoTarget("release", ppc_r, x86_r)
	PseudoTarget("debug", ppc_d, x86_d)

	PseudoTarget("server_release", "server_release_x86", "server_release_ppc")
	PseudoTarget("server_debug", "server_debug_x86", "server_debug_ppc")
	PseudoTarget("client_release", "client_release_x86", "client_release_ppc")
	PseudoTarget("client_debug", "client_debug_x86", "client_debug_ppc")
else
	debug_settings = NewSettings()
	debug_settings.config_name = "debug"
	debug_settings.config_ext = "_d"
	debug_settings.debug = 1
	debug_settings.cc.optimize = 0

	release_settings = NewSettings()
	release_settings.config_name = "release"
	release_settings.config_ext = ""
	release_settings.debug = 0
	release_settings.cc.optimize = 1

	build(debug_settings)
	build(release_settings)
	DefaultTarget("game_debug")
end