neue(?) Komfortfunktion

[siedlereldeis]

Hier ist mein Beitrag zum Siedlerallgemeinwohl. Der korrekte Funktionsname sollte wohl GetPlayersEntitiesInCategoriesInTerritories lauten, naja.

function EntitiesInCategories(spieler, kategorien, territorien)
-- spieler: Table mit Spieler IDs oder Spieler ID
-- kategorien: Table mit Kategorien oder Kategorie
-- territorien: Table mit IDs oder ID
    
    local sp = {}
    local kat = {}
    local terr = {}
    local spielerentities = {}
    local entities = {}
    
    if type(spieler) ~= "table" then sp[1] = spieler else sp = spieler end
    if type(kategorien) ~= "table" then kat[1] = kategorien else kat = kategorien end
    if type(territorien) ~= "table" then terr[1] = territorien else terr = territorien end
    
    -- Entities aller Spieler in allen Kategorien
    for k = 1, #sp do
        -- Entities eines Spielers in allen Kategorien
        for i = 1, #kat do
            -- Entities eines Spielers in einer Kategorie
            local e = {Logic.GetPlayerEntitiesInCategory(sp[k], kat[i])}
            if #e > 0 then
                for j = 1, #e do table.insert(spielerentities, e[j]) end
            end
        end
    end
    
    if terr[1] == 0 then entities = spielerentities
    else
        if #spielerentities > 0 then
            for i = 1, #spielerentities do
                for j = 1, #terr do
                    if GetTerritoryUnderEntity(spielerentities[i]) == terr[j] then 
                        table.insert(entities, spielerentities[i])
                        break
                    end
                end
            end
        end
    end
    
    return entities
end

Funktionsaufrufe können z.B. so aussehen:

EntitiesInCategories(4, EntityCategories.AttackableBuilding, 38)

für angreifbare Gebäude von Spieler 4 in Territorium Nr. 38,

EntitiesInCategories(3, {EntityCategories.CityWallSegment, EntityCategories.CityWallGate, EntityCategories.PalisadeSegment}, 0)

für alle Mauern und Palisaden von Spieler 3 oder

EntitiesInCategories({2, 3, 4}, {EntityCategories.Leader, EntityCategories.HeavyWeapon}, {10, 11, 12, 13, 14})

für Bataillone und Belagerungswaffen der Spieler 2, 3 und 4 in den Territorien 10 bis 14.


Es wird ein Table mit den IDs zurückgegeben.

[LordFWD]

Logic.GetEntitiesOfCategoryInTerritory

[siedlereldeis]

Die liefert aber nur eine begrenzte Anzahl an Entitäten, für einen Spieler, eine Kategorie, eine Territorium. Die müsste man dann in eine ähnliche Schleifenkonstruktion packen.

[totalwarANGEL]

Diese alte DEdK-Funktion umbauen bzw erweitern:

function SucheAufDerWelt(_player, _entity, _groesse, _punkt)
	local punktX1, punktX2, punktY1, punktY2, data
	local gefunden = {}
	local rueck
	if not _groesse then
		_groesse = Logic.WorldGetSize() 
	end
	if not _punkt then
		_punkt = {X = _groesse/2, Y = _groesse/2}
	end
	if _player == 0 then
		data ={Logic.GetEntitiesInArea(_entity, _punkt.X, _punkt.Y, math.floor(_groesse * 0.71), 16)}
	else
		data ={Logic.GetPlayerEntitiesInArea(_player,_entity, _punkt.X, _punkt.Y, math.floor(_groesse * 0.71), 16)}
	end
	if data[1] >= 16 then -- Aufteilen angesagt
		local _klgroesse = _groesse / 2 
		-- Ausgangspunkt ist _punkt
		-- _punkt verteilen
		local punktX1 = _punkt.X - _groesse / 4
		local punktX2 = _punkt.X + _groesse / 4
		local punktY1 = _punkt.Y - _groesse / 4
		local punktY2 = _punkt.Y + _groesse / 4
		rueck = SucheAufDerWelt(_player, _entity, _klgroesse, {X=punktX1,Y=punktY1})
		for i = 1, #rueck do
			if not IstDrin(rueck[i], gefunden) then
				table.insert(gefunden, rueck[i])
			end
		end
		rueck = SucheAufDerWelt(_player, _entity, _klgroesse, {X=punktX1,Y=punktY2})
		for i = 1, #rueck do
			if not IstDrin(rueck[i], gefunden) then
				table.insert(gefunden, rueck[i])
			end
		end
		rueck = SucheAufDerWelt(_player, _entity, _klgroesse, {X=punktX2,Y=punktY1})
		for i = 1, #rueck do
			if not IstDrin(rueck[i], gefunden) then
				table.insert(gefunden, rueck[i])
			end
		end
		rueck = SucheAufDerWelt(_player, _entity, _klgroesse, {X=punktX2,Y=punktY2})
		for i = 1, #rueck do
			if not IstDrin(rueck[i], gefunden) then
				table.insert(gefunden, rueck[i])
			end
		end
	else
		table.remove(data,1)
		for i = 1, #data do
			if not IstDrin(data[i], gefunden) then
				table.insert(gefunden, data[i])
			end
		end
	end
	return gefunden
end
function IstDrin(_wert, _table)
	for i = 1, #_table do
		if _table[i] == _wert then 
			return true 
		end 
	end
	return false
end

Das Rad muss doch nicht immer neu Erfunden werden, wenn der Reifen platzt...

Edit:
Diese Funktion ist natürlich NICHT von mir. Das wird nur mal erwähnt, ehe es heißt, ich schmücke mich mit fremden Federn.