Moved mods/ra/lua to mods/common/lua

mods/common/lua/actor.lua

@@ -0,0 +1,176 @@
+Actor = { }
+
+Actor.Create = function(name, init)
+	if name == nil then error("No actor name specified", 2) end
+	if init.Owner == nil then error("No actor owner specified", 2) end
+	local td = OpenRA.New("TypeDictionary")
+	local addToWorld = true
+	for key, value in pairs(init) do
+		if key == "AddToWorld" then
+			addToWorld = value
+		else
+			td:Add(OpenRA.New(key .. "Init", { value }))
+		end
+	end
+	return World:CreateActor(addToWorld, name, td)
+end
+
+Actor.Turn = function(actor, facing)
+	actor:QueueActivity(OpenRA.New("Turn", { { facing, "Int32" } }))
+end
+
+Actor.Move = function(actor, location)
+	Actor.MoveNear(actor, location, 0)
+end
+
+Actor.MoveNear = function(actor, location, nearEnough)
+	actor:QueueActivity(OpenRA.New("Move", { location, WRange.FromCells(nearEnough) }))
+end
+
+Actor.ScriptedMove = function(actor, location)
+	actor:QueueActivity(OpenRA.New("Move", { location }))
+end
+
+Actor.Teleport = function(actor, location)
+	actor:QueueActivity(OpenRA.New("SimpleTeleport", { location }))
+end
+
+Actor.AttackMove = function(actor, location)
+	Internal.AttackMove(actor, location)
+end
+
+Actor.HeliFly = function(actor, position)
+	actor:QueueActivity(OpenRA.New("HeliFly", { position }))
+end
+
+Actor.HeliLand = function(actor, requireSpace)
+	actor:QueueActivity(OpenRA.New("HeliLand", { requireSpace }))
+end
+
+Actor.Fly = function(actor, position)
+	Internal.FlyToPos(actor, position)
+end
+
+Actor.FlyAttackActor = function(actor, targetActor)
+	Internal.FlyAttackActor(actor, targetActor)
+end
+
+Actor.FlyAttackCell = function(actor, location)
+	Internal.FlyAttackCell(actor, location)
+end
+
+Actor.FlyOffMap = function(actor)
+	actor:QueueActivity(OpenRA.New("FlyOffMap"))
+end
+
+Actor.Hunt = function(actor)
+	actor:QueueActivity(OpenRA.New("Hunt", { actor }))
+end
+
+Actor.UnloadCargo = function(actor, unloadAll)
+	actor:QueueActivity(OpenRA.New("UnloadCargo", { unloadAll }))
+end
+
+Actor.Harvest = function(actor)
+	actor:QueueActivity(OpenRA.New("FindResources"))
+end
+
+Actor.Scatter = function(actor)
+	local mobile = Actor.Trait(actor, "Mobile")
+	mobile:Nudge(actor, actor, true)
+end
+
+Actor.Wait = function(actor, period)
+	actor:QueueActivity(OpenRA.New("Wait", { { period, "Int32" } }))
+end
+
+Actor.WaitFor = function(actor, func)
+	Internal.WaitFor(actor, func)
+end
+
+Actor.CallFunc = function(actor, func)
+	Internal.CallFunc(actor, func)
+end
+
+Actor.DeployTransform = function(actor)
+	Actor.CallFunc(actor, function()
+		-- Queue the transform order
+		Actor.Trait(actor, "Transforms"):DeployTransform(true)
+	end)
+end
+
+Actor.RemoveSelf = function(actor)
+	actor:QueueActivity(OpenRA.New("RemoveSelf"))
+end
+
+Actor.Stop = function(actor)
+	actor:CancelActivity()
+end
+
+Actor.IsDead = function(actor)
+	return Internal.IsDead(actor)
+end
+
+Actor.IsInWorld = function(actor)
+	return actor.IsInWorld
+end
+
+Actor.Owner = function(actor)
+	return actor.Owner
+end
+
+Actor.Facing = function(actor)
+	return Actor.Trait(actor, "IFacing"):get_Facing()
+end
+
+Actor.IsIdle = function(actor)
+	return actor.IsIdle
+end
+
+Actor.SetStance = function(actor, stance)
+	Internal.SetUnitStance(actor, stance)
+end
+
+Actor.OnKilled = function(actor, eh)
+	Actor.Trait(actor, "LuaScriptEvents").OnKilled:Add(eh)
+end
+
+Actor.OnAddedToWorld = function(actor, eh)
+	Actor.Trait(actor, "LuaScriptEvents").OnAddedToWorld:Add(eh)
+end
+
+Actor.OnRemovedFromWorld = function(actor, eh)
+	Actor.Trait(actor, "LuaScriptEvents").OnRemovedFromWorld:Add(eh)
+end
+
+Actor.ActorsWithTrait = function(className)
+	local ret = { }
+	for item in Utils.Enumerate(Internal.ActorsWithTrait(className)) do
+		table.insert(ret, item.Actor)
+	end
+	return ret
+end
+
+Actor.HasTrait = function(actor, className)
+	return Internal.HasTrait(actor, className)
+end
+
+Actor.TraitOrDefault = function(actor, className)
+	return Internal.TraitOrDefault(actor, className)
+end
+
+Actor.Trait = function(actor, className)
+	return Internal.Trait(actor, className)
+end
+
+Actor.HasTraitInfo = function(actorType, className)
+	return Internal.HasTraitInfo(actorType, className)
+end
+
+Actor.TraitInfoOrDefault = function(actorType, className)
+	return Internal.TraitInfoOrDefault(actorType, className)
+end
+
+Actor.TraitInfo = function(actorType, className)
+	return Internal.TraitInfo(actorType, className)
+end

mods/common/lua/map.lua

@@ -0,0 +1,47 @@
+Map = { }
+
+Map.GetFacing = function(vec, currentFacing)
+	return Internal.GetFacing(vec, currentFacing)
+end
+
+Map.GetRandomCell = function()
+	return Internal.GetRandomCell()
+end
+
+Map.GetRandomEdgeCell = function()
+	return Internal.GetRandomEdgeCell()
+end
+
+CPos.New = function(x, y)
+	return OpenRA.New("CPos", { { x, "Int32" }, { y, "Int32" } })
+end
+
+WPos.New = function(x, y, z)
+	if z == nil then
+		z = 0
+	end
+	return OpenRA.New("WPos", { { x, "Int32" }, { y, "Int32" }, { z, "Int32" } })
+end
+
+WPos.FromCPos = function(location)
+	return WPos.New(location.X * 1024, location.Y * 1024, 0)
+end
+
+CVec.New = function(x, y)
+	return OpenRA.New("CVec", { { x, "Int32" }, { y, "Int32" } })
+end
+
+WVec.New = function(x, y, z)
+	if z == nil then
+		z = 0
+	end
+	return OpenRA.New("WVec", { { x, "Int32" }, { y, "Int32" }, { z, "Int32" } })
+end
+
+WRange.New = function(r)
+	return OpenRA.New("WRange", { { r, "Int32" } })
+end
+
+WRange.FromCells = function(cells)
+	return WRange.New(cells * 1024)
+end

mods/common/lua/media.lua

@@ -0,0 +1,20 @@
+Media = { }
+
+Media.PlaySpeechNotification = function(notification, player)
+	Internal.PlaySpeechNotification(player, notification)
+end
+
+Media.PlaySoundNotification = function(notification, player)
+	Internal.PlaySoundNotification(player, notification)
+end
+
+Media.PlayRandomMusic = function()
+	Internal.PlayRandomMusic()
+end
+
+Media.PlayMovieFullscreen = function(movie, onComplete)
+	if onComplete == nil then
+		onComplete = function() end
+	end
+	Internal.PlayMovieFullscreen(movie, onComplete)
+end

mods/common/lua/mission.lua

@@ -0,0 +1,37 @@
+Mission = { }
+
+Mission.MissionOver = function(winners, losers, setWinStates)
+	World:SetLocalPauseState(true)
+	World:set_PauseStateLocked(true)
+	if winners then
+		for i, player in ipairs(winners) do
+			Media.PlaySpeechNotification("Win", player)
+			if setWinStates then
+				OpenRA.SetWinState(player, "Won")
+			end
+		end
+	end
+	if losers then
+		for i, player in ipairs(losers) do
+			Media.PlaySpeechNotification("Lose", player)
+			if setWinStates then
+				OpenRA.SetWinState(player, "Lost")
+			end
+		end
+	end
+	Mission.MissionIsOver = true
+end
+
+Mission.GetGroundAttackersOf = function(player)
+	return Utils.Where(Actor.ActorsWithTrait("AttackBase"), function(actor)
+		return not Actor.IsDead(actor) and Actor.IsInWorld(actor) and Actor.Owner(actor) == player and Actor.HasTrait(actor, "Mobile")
+	end)
+end
+
+Mission.TickTakeOre = function(player)
+	OpenRA.TakeOre(player, 0.01 * OpenRA.GetOreCapacity(player) / 25)
+end
+
+Mission.RequiredUnitsAreDestroyed = function(player)
+	return Internal.RequiredUnitsAreDestroyed(player)
+end

mods/common/lua/openra.lua

@@ -0,0 +1,78 @@
+print = Internal.Debug
+
+OpenRA = { }
+
+OpenRA.New = function(className, args)
+	if args == nil then
+		args = { }
+	end
+	return Internal.New(className, args)
+end
+
+OpenRA.RunAfterDelay = function(delay, func)
+	Internal.RunAfterDelay(delay, func)
+end
+
+OpenRA.SetViewportCenterPosition = function(position)
+	WorldRenderer.Viewport:Center(position)
+end
+
+OpenRA.GetViewportCenterPosition = function()
+	return WorldRenderer.Viewport.CenterPosition
+end
+
+OpenRA.GetDifficulty = function()
+	return World.LobbyInfo.GlobalSettings.Difficulty
+end
+
+OpenRA.IsSinglePlayer = function()
+	return World.LobbyInfo:get_IsSinglePlayer()
+end
+
+OpenRA.GetPlayer = function(internalName)
+	return Utils.EnumerableFirstOrNil(World.Players, function(p) return p.InternalName == internalName end)
+end
+
+OpenRA.GetPlayers = function(func)
+	return Utils.EnumerableWhere(World.Players, func)
+end
+
+OpenRA.SetWinState = function(player, winState)
+	Internal.SetWinState(player, winState)
+end
+
+OpenRA.GetRandomInteger = function(low, high)
+	return Internal.GetRandomInteger(low, high)
+end
+
+OpenRA.TakeOre = function(player, amount)
+	Actor.Trait(player.PlayerActor, "PlayerResources"):TakeOre(amount)
+end
+
+OpenRA.TakeCash = function(player, amount)
+	Actor.Trait(player.PlayerActor, "PlayerResources"):TakeCash(amount)
+end
+
+OpenRA.GiveOre = function(player, amount)
+	Actor.Trait(player.PlayerActor, "PlayerResources"):GiveOre(amount)
+end
+
+OpenRA.GiveCash = function(player, amount)
+	Actor.Trait(player.PlayerActor, "PlayerResources"):GiveCash(amount)
+end
+
+OpenRA.CanGiveOre = function(player, amount)
+	return Actor.Trait(player.PlayerActor, "PlayerResources"):CanGiveOre(amount)
+end
+
+OpenRA.GetOreCapacity = function(player)
+	return Actor.Trait(player.PlayerActor, "PlayerResources").OreCapacity
+end
+
+OpenRA.GetOre = function(player)
+	return Actor.Trait(player.PlayerActor, "PlayerResources").Ore
+end
+
+OpenRA.GetCash = function(player)
+	return Actor.Trait(player.PlayerActor, "PlayerResources").Cash
+end

mods/common/lua/reinforcements.lua

@@ -0,0 +1,77 @@
+Reinforcements = { }
+
+Reinforcements.PerformHelicopterInsertion = function(owner, helicopterName, passengerNames, enterPosition, unloadPosition, exitPosition)
+	local facing = { Map.GetFacing(WPos.op_Subtraction(unloadPosition, enterPosition), 0), "Int32" }
+	local altitude = { Actor.TraitInfo(helicopterName, "AircraftInfo").CruiseAltitude, "Int32" }
+	local heli = Actor.Create(helicopterName, { Owner = owner, CenterPosition = enterPosition, Facing = facing, Altitude = altitude })
+	local cargo = Actor.Trait(heli, "Cargo")
+	local passengers = { }
+	for i, passengerName in ipairs(passengerNames) do
+		local passenger = Actor.Create(passengerName, { AddToWorld = false, Owner = owner })
+		cargo:Load(heli, passenger)
+		passengers[i] = passenger
+	end
+	Actor.HeliFly(heli, unloadPosition)
+	Actor.Turn(heli, 0)
+	Actor.HeliLand(heli, true)
+	Actor.UnloadCargo(heli, true)
+	Actor.Wait(heli, 125)
+	Actor.HeliFly(heli, exitPosition)
+	Actor.RemoveSelf(heli)
+	return heli, passengers
+end
+
+Reinforcements.PerformHelicopterExtraction = function(owner, helicopterName, passengers, enterPosition, loadPosition, exitPosition)
+	local facing = { Map.GetFacing(WPos.op_Subtraction(loadPosition, enterPosition), 0), "Int32" }
+	local altitude = { Actor.TraitInfo(helicopterName, "AircraftInfo").CruiseAltitude, "Int32" }
+	local heli = Actor.Create(helicopterName, { Owner = owner, CenterPosition = enterPosition, Facing = facing, Altitude = altitude })
+	local cargo = Actor.Trait(heli, "Cargo")
+	Actor.HeliFly(heli, loadPosition)
+	Actor.Turn(heli, 0)
+	Actor.HeliLand(heli, true)
+	Actor.WaitFor(heli, function()
+		return Utils.All(passengers, function(passenger) return cargo.Passengers:Contains(passenger) end)
+	end)
+	Actor.Wait(heli, 125)
+	Actor.HeliFly(heli, exitPosition)
+	Actor.RemoveSelf(heli)
+	return heli
+end
+
+Reinforcements.PerformInsertion = function(owner, vehicleName, passengerNames, enterPath, exitPath)
+	local facing = { 0, "Int32" }
+	if #enterPath > 1 then
+		facing = { Map.GetFacing(CPos.op_Subtraction(enterPath[2], enterPath[1]), 0), "Int32" }
+	end
+	local vehicle = Actor.Create(vehicleName, { Owner = owner, Location = enterPath[1], Facing = facing })
+	local cargo = Actor.Trait(vehicle, "Cargo")
+	local passengers = { }
+	for i, passengerName in ipairs(passengerNames) do
+		local passenger = Actor.Create(passengerName, { AddToWorld = false, Owner = owner })
+		passengers[i] = passenger
+		cargo:Load(vehicle, passenger)
+	end
+	Utils.Do(Utils.Skip(enterPath, 1), function(l) Actor.ScriptedMove(vehicle, l) end)
+	Actor.UnloadCargo(vehicle, true)
+	Actor.Wait(vehicle, 25)
+	Utils.Do(exitPath, function(l) Actor.ScriptedMove(vehicle, l) end)
+	Actor.RemoveSelf(vehicle)
+	return vehicle, passengers
+end
+
+Reinforcements.Reinforce = function(owner, reinforcementNames, enterLocation, rallyPointLocation, interval, onCreateFunc)
+	local facing = { Map.GetFacing(CPos.op_Subtraction(rallyPointLocation, enterLocation), 0), "Int32" }
+	local reinforcements = { }
+	for i, reinforcementName in ipairs(reinforcementNames) do
+		local reinforcement = Actor.Create(reinforcementName, { AddToWorld = false, Owner = owner, Location = enterLocation, Facing = facing })
+		reinforcements[i] = reinforcement
+		OpenRA.RunAfterDelay((i - 1) * interval, function()
+			World:Add(reinforcement)
+			Actor.MoveNear(reinforcement, rallyPointLocation, 2)
+			if onCreateFunc ~= nil then
+				onCreateFunc(reinforcement)
+			end
+		end)
+	end
+	return reinforcements
+end

mods/common/lua/supportpowers.lua

@@ -0,0 +1,28 @@
+SupportPowers = { }
+
+SupportPowers.Parabomb = function(owner, planeName, enterLocation, bombLocation)
+	local facing = { Map.GetFacing(CPos.op_Subtraction(bombLocation, enterLocation), 0), "Int32" }
+	local altitude = { Actor.TraitInfo(planeName, "AircraftInfo").CruiseAltitude, "Int32" }
+	local plane = Actor.Create(planeName, { Location = enterLocation, Owner = owner, Facing = facing, Altitude = altitude })
+	Actor.Trait(plane, "AttackBomber"):SetTarget(bombLocation.CenterPosition)
+	Actor.Fly(plane, bombLocation.CenterPosition)
+	Actor.FlyOffMap(plane)
+	Actor.RemoveSelf(plane)
+	return plane
+end
+
+SupportPowers.Paradrop = function(owner, planeName, passengerNames, enterLocation, dropLocation)
+	local facing = { Map.GetFacing(CPos.op_Subtraction(dropLocation, enterLocation), 0), "Int32" }
+	local altitude = { Actor.TraitInfo(planeName, "AircraftInfo").CruiseAltitude, "Int32" }
+	local plane = Actor.Create(planeName, { Location = enterLocation, Owner = owner, Facing = facing, Altitude = altitude })
+	Actor.FlyAttackCell(plane, dropLocation)
+	Actor.Trait(plane, "ParaDrop"):SetLZ(dropLocation)
+	local cargo = Actor.Trait(plane, "Cargo")
+	local passengers = { }
+	for i, passengerName in ipairs(passengerNames) do
+		local passenger = Actor.Create(passengerName, { AddToWorld = false, Owner = owner })
+		passengers[i] = passenger
+		cargo:Load(plane, passenger)
+	end
+	return plane, passengers
+end

mods/common/lua/team.lua

@@ -0,0 +1,61 @@
+Team = { }
+
+Team.New = function(actors)
+	local team = { }
+	team.Actors = actors
+	team.OnAllKilled = { }
+	team.OnAnyKilled = { }
+	team.OnAllRemovedFromWorld = { }
+	team.OnAnyRemovedFromWorld = { }
+	Team.AddActorEventHandlers(team)
+	return team
+end
+
+Team.AddActorEventHandlers = function(team)
+	for i, actor in ipairs(team.Actors) do
+
+		Actor.OnKilled(actor, function()
+			Team.InvokeHandlers(team.OnAnyKilled)
+			if Team.AllAreDead(team) then Team.InvokeHandlers(team.OnAllKilled) end
+		end)
+		
+		Actor.OnRemovedFromWorld(actor, function()
+			Team.InvokeHandlers(team.OnAnyRemovedFromWorld)
+			if not Team.AnyAreInWorld(team) then Team.InvokeHandlers(team.OnAllRemovedFromWorld) end
+		end)
+	end
+end
+
+Team.InvokeHandlers = function(event)
+	for i, handler in ipairs(event) do
+		handler()
+	end
+end
+
+Team.AllAreDead = function(team)
+	return Utils.All(team.Actors, Actor.IsDead)
+end
+
+Team.AnyAreDead = function(team)
+	return Utils.Any(team.Actors, Actor.IsDead)
+end
+
+Team.AllAreInWorld = function(team)
+	return Utils.All(team.Actors, Actor.IsInWorld)
+end
+
+Team.AnyAreInWorld = function(team)
+	return Utils.Any(team.Actors, Actor.IsInWorld)
+end
+
+Team.AddEventHandler = function(event, func)
+	table.insert(event, func)
+end
+
+Team.Contains = function(team, actor)
+	return Utils.Any(team.Actors, function(a) return a == actor end)
+end
+
+Team.Do = function(team, func)
+	Utils.Do(team.Actors, func)
+end

mods/common/lua/utils.lua

@@ -0,0 +1,77 @@
+Utils = { }
+
+Utils.Enumerate = function(netEnumerable)
+	local enum = netEnumerable:GetEnumerator()
+	return function()
+		if enum:MoveNext() then
+			return enum:get_Current()
+		end
+	end
+end
+
+Utils.EnumerableFirstOrNil = function(netEnumerable, func)
+	for item in Utils.Enumerate(netEnumerable) do
+		if func(item) then
+			return item
+		end
+	end
+	return nil
+end
+
+Utils.EnumerableWhere = function(netEnumerable, func)
+	local ret = { }
+	for item in Utils.Enumerate(netEnumerable) do
+		if func(item) then
+			table.insert(ret, item)
+		end
+	end
+	return ret
+end
+
+Utils.Where = function(array, func)
+	local ret = { }
+	for i, item in ipairs(array) do
+		if func(item) then
+			table.insert(ret, item)
+		end
+	end
+	return ret
+end
+
+Utils.All = function(array, func)
+	for i, item in ipairs(array) do
+		if not func(item) then
+			return false
+		end
+	end
+	return true
+end
+
+Utils.Any = function(array, func)
+	for i, item in ipairs(array) do
+		if func(item) then
+			return true
+		end
+	end
+	return false
+end
+
+Utils.Do = function(array, func)
+	for i, item in ipairs(array) do
+		func(item)
+	end
+end
+
+Utils.Skip = function(array, n)
+	local ret = { }
+	for i, item in ipairs(array) do
+		if i > n then
+			table.insert(ret, item)
+		end
+	end
+	return ret
+end
+
+Utils.TableToArray = function(luaTable)
+	return Internal.TableToArray(luaTable)
+end