Ergebnis 1 bis 5 von 5
  1. #1
    12 of 5
    Registriert seit
    20.10.2015
    Beiträge
    4
    Downloads
    0
    Uploads
    0

    Standard Rspawn-Armeen in SP und MP brauchen Review

    Hallo liebe Siedler-Freunde

    Vor vielen Jahren habe ich erstmals versucht, eine Karte zu erstellen mit einer respawn-Armee wie in der Mission [Siedler 5 Hauptkampagne "Folklung-Feste"] oder so ähnlich. Diese Karte möchte ich nach all den Jahren in denen ich immer wieder mal herumprobiert und lange die Foren durchstöbert habe endlich fertigstellen Es soll auch und vor allem eine MP-Variante geben. Für die Spawn-Kontrolle habe ich einen Counter-Mechanismus entwickelt, welcher im SP auf einer anderen Testkarte gut funktioniert. Ich vermute in den Counter-Funktionen keine Fehler.

    Mir wurde zwar schon viel geholfen, aber in diesen Versionen bekomme ich die Skripte einfach nicht zum laufen Für die MP-Karte habe ich als Skript-Referenz verwendet "EuropeanForestv1.0" von Author "Huskywelpe85". Die Karten stürzen nicht mehr ab. Auf der SP-Karte wird die Ki richtig geladen, die Karte funktioniert nun so. Leider werden die Garnisons-Truppen nicht generiert, wenn der Spawngenerator "TurmBurg1/2" zerstört ist.

    Größeres Problem: Im MP wird die Ki scheinbar nicht geladen, und die Karten werden nicht aufgedeckt. Es werden keine Armeen erzeugt, was vllt an der nicht erstellten Ki liegt.

    Ich hoffe, einem von Euch die Ihr Euch durch diese Codes quälen müsstet, um zu helfen, fällt bei dem heldenhaften Versuch etwas auf - liebe Grüße

    Name:  SP.JPG
Hits: 126
Größe:  249.2 KB


    SP-Karte:
    ° Spieler und KI-Spieler (Nr. 4) bekommen eine Armee aus einem Gebäude
    ° Spieler bekommt diese Armee auis einem Gebäude der Spieler-ID 2, damit die isDead-Abfrage funktioniert.
    ° Es gibt zwei fake-Player mit den Farben a) des Spielers und b) des aggressiven KI-Spielers
    ° Spieler (ID1), fake Spieler für Abfrage (ID2), Statics für Spieler 1 (ID 3), Ki-Spieler (ID4) und Statics für ID4 (ID5)

    Code:
    ---------------------------------------------------------------------------------
     ----------------------------------------------------------------------------------------------------
     Script.Load( Folders.MapTools.."Main.lua" )
     IncludeGlobals("MapEditorTools")
     
     
     refreshCounter = 0
     counter = 25
     runde = 1
     
     
     refreshCounterZ = 40
     counterZ = 15
     rundeZ = 10
     
     
     refreshCounter2 = 0
     counter2 = 25
     runde2 = 1
     
     
     ----------------------------------------------------------------------------------------------------
     function InitResources()
         AddGold  (500)
         AddSulfur(100)
         AddIron  (200)
         AddWood  (1200)     
         AddStone (500)  
         AddClay  (1000)
      
         AddGold  (4,5000)
     end
     
     
     function InitDiplomacy()
     -- Spieler 1 (ID = 4) mit Statics
         SetFriendly(1,3) -- 3: statics für Spieler1
         SetFriendly(1,5) -- 5: statics für Spieler4
     
     
     -- Spieler 2 (ID = 4) mit Statics
         SetFriendly(4,3) -- 3: statics für Spieler1
         SetFriendly(4,5) -- 5: statics für Spieler4
     
     
     -- Spieler untereinander und gegen ID-kontrollierte fake-Spieler
         SetFriendly(1,2) -- Spieler 1 und Fake Verbündeter
     
     
         SetHostile(1,4)  -- Spieler 1 und fake-Verb. gg. Spieler 4
         SetHostile(2,4)  -- ''
     
     
     end
     ----------------------------------------------------------------------------------------------------
     function InitTechnologies()
     end
     ----------------------------------------------------------------------------------------------------
     function InitWeatherGfxSets()
     SetupMediterraneanWeatherGfxSet()
     end
     ----------------------------------------------------------------------------------------------------
     function InitWeather()
     AddPeriodicSummer(480)
     AddPeriodicRain(120)
     AddPeriodicWinter(180)
     AddPeriodicRain(60)
     end
     ----------------------------------------------------------------------------------------------------
     function InitPlayerColorMapping()
     
     
     Display.SetPlayerColorMapping(1,FRIENDLY_COLOR1) -- orange(1)/ gelb/ weiß
     Display.SetPlayerColorMapping(2,FRIENDLY_COLOR1)
     Display.SetPlayerColorMapping(3,FRIENDLY_COLOR1)
     Display.SetPlayerColorMapping(4,ENEMY_COLOR2)    -- lila(1)/ cyan(2)
     Display.SetPlayerColorMapping(5,ENEMY_COLOR2)
     -- Display.SetPlayerColorMapping(6,ENEMY_COLOR2)   -- für menschl. Spieler falls fake-Verb. nötig
     
     
     -- NPC_/NEPHILIM_/EVIL_GOVERNOR_/KERBEROS_/Robbers_COLOR (beige/rot/grün/grau/schwarz)
     
     
     end
     ----------------------------------------------------------------------------------------------------
     function FirstMapAction()
     
     
     -- !!ACHTUNG: Zahlen in Aufrufen (außer Spielernamen) bewirken Fehler
     
     
      CreatePlayer2()
      CreatePlayer3()
      CreatePlayer4()
      CreatePlayer5()
     
     
      CreateSimpleJobs() --enthält Armee-Jobs  
     
     
      Tools.ExploreArea(-1,-1,900) --Karte aufdecken
     
     
     end
     ----------------------------------------------------------------------------------------------------  
     function CreatePlayer2()   -- fake player mit spielerfarbe, um isExisting Abfrage bzgl Spielertum machen zu können
     
     
         player2     = {}
     
     
         player2.id     = 2
         player2.name     = "Garnison" -- if shall have no name just delete the name within the quotation marks
     
     
     -- create the description table for the player (the table will not be needed anymore, so it can be local)
     --[[local description = {}
           description.serfLimit = 0
     
     
         SetupPlayerAi(player2.id,description)    -- call the comfort function "SetupPlayerAi" to start the AI system
         SetupPlayerAi( 2, {constructing = false, extracting = 0, repairing = false, serfLimit = 0} )
     ]]
     
     
     end
     ----------------------------------------------------------------------------------------------------
     function CreatePlayer3()   -- STATICS: neutraler fake-player mit spielerfarbe, um Mauern unzerstörbar und nachhaltig nutzbar zu machen
     
     
         player3     = {}
     
     
         player3.id     = 3
         player3.name     = "Festung"
     
     
     local description = {}
         description.serfLimit = 0
     
     
         -- SetupPlayerAi(player3.id,description)
      
     -- Can have an Ai?
     
     
     end
     ----------------------------------------------------------------------------------------------------
     function CreatePlayer4()   -- feindlicher Spieler
     
     
         player4     = {}
     
     
         player4.id     = 4
         player4.name     = "Barbaren des Nordens"
     
     
     -- May NOT have an Ai
     
     
     end
     ----------------------------------------------------------------------------------------------------
     function CreatePlayer5()   -- neutraler fake-player mit spielerfarbe, um Mauern unzerstörbar und nachhaltig nutzbar zu machen
     
     
         player5     = {}
     
     
         player5.id     = 5
         player5.name     = "Barbaren des Nordens"
     
     
     -- May NOT have an Ai
     
     
     end
     ----------------------------------------------------------------------------------------------------
     function CreateSimpleJobs()
     
     
        StartSimpleJob("ArmeeCounterOne")  -- SimpleJob wird pro Sekunde einmal ausgeführt
        StartSimpleJob("ZitadellenCounterOne")  -- wie oben für Zitadellen
     
     
        StartSimpleJob("ArmeeCounterTwo")  -- SimpleJob wird pro Sekunde einmal ausgeführt
     
     
     -- Danach wird der Job nicht mehr gebraucht
     returntrue
     
     
     end 
     ---------------------------------------------------------------------------
     function CreatePlayerOneFortress()
     
     
     local PlayerMace = {   -- keine genauen Angaben erforderlich, da es eine local ist
         player = 1
         };
     
     
     local troopDescription1 = {
         maxNumberOfSoldiers = 4,
         minNumberOfSoldiers = 0,
         experiencePoints    = NORMAL_EXPERIENCE,
         leaderType          = Entities.CU_BlackKnight_LeaderMace2,
         position            = GetPosition("Burg1Mace")
         };
     
     
     local nMaceID = CreateTroop(PlayerMace,troopDescription1);
     
     
             Attack(nMaceID,"VerteidigerPunkt") -- "Move" is possible, too, but causes unfair battles
     
     
     --------------
     local PlayerBogen = {  
         player = 1
         };
     
     
     local troopDescription2 = {
         maxNumberOfSoldiers = 4,
         minNumberOfSoldiers = 0,
         experiencePoints    = NORMAL_EXPERIENCE,
         leaderType          = Entities.PU_LeaderBow2,
         position            = GetPosition("Burg1Bogen")
         };
     
     
     
     
     local nBowID = CreateTroop(PlayerBogen,troopDescription2);
     
     
             Attack(nBowID,"VerteidigerPunkt")
     
     
     --------------
     local PlayerSchwert = {  
         player = 1
         };
     
     
     local troopDescription3 = {
         maxNumberOfSoldiers = 4,
         minNumberOfSoldiers = 0,
         experiencePoints    = LOW_EXPERIENCE,
         leaderType          = Entities.PU_LeaderSword3,
         position            = GetPosition("Burg1Schwert")
         };
     
     
     
     
     local nSwordID = CreateTroop(PlayerSchwert,troopDescription3);
     
     
             Attack(nSwordID,"VerteidigerPunkt")
     
     
     end
     ---------------------------------------------------------------------------
     -------------------------
     function ArmeeCounterOne()
     
     
     if  IsExisting("TurmBurg1") then
     
     
     if ( counter > 0 ) then
             counter = counter -1  -- Sekunden werden runtergezählt
     else
     
     
     if ( runde < 5 ) then
            CreatePlayerOneFortress()
            Message("Ein kleiner Trupp zur Unterstützung ist auf dem Weg")
            counter = 25   -- jedes Mal die Wartezeit wieder auf 20Sek setzen
            runde = runde +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
     
     
     else 
           StartSimpleJob("ArmeeCounterOneReset")
           Message("Eure Armeen sind erschöpft!")
     returntrue
     end
     
     
     end
     
     
     else
      Message("Die Bastion ist gefallen!")
     returntrue
     end
     
     
     end
     -----------------------
     function ArmeeCounterOneReset()
     
     
     -- when armyOne has no leader alive, then ... (ACHTUNG!! Abfragen funktionieren nicht ohne CreatePlayer(-> 2))
     if  IsExisting("TurmBurg1") then-- attached to player 2
     
     
     if  ( refreshCounter < 180) then
             refreshCounter = refreshCounter + 1  -- Sekunden werden hochgezählt
     else
             counter = 5  -- nach der Wartezeit nicht noch einmal die volle Zeit für ArmyCounterOne() abwarten
             runde = 1
             refreshCounter = 0
     
     
             StartSimpleJob("ArmeeCounterOne")
             Message("Neue Soldaten sind ausgehoben!")   
     -- and destroy this job, it will be generated in a loop anyway
     returntrue
     end
     
     
     else 
     returntrue
     end
     
     
     end
     ---------------------------------------------------------------------------------------------
     ---------------------------------------------------------------------------------------------
     function CreatePlayerOneCastleGarnison()
     
     
     local PlayerCastle = {   -- keine genauen Angaben erforderlich, da es eine local ist
         player = 1
         };
     
     
     local troopDescription = {
         maxNumberOfSoldiers = 6,
         minNumberOfSoldiers = 0,
         experiencePoints    = HIGH_EXPERIENCE,
         leaderType          = Entities.PU_LeaderPoleArm4,
         position            = GetPosition("Festung1")
         };
     
     
     local nPoleID = CreateTroop(PlayerCastle,troopDescription);
             Attack(nPoleID,"TorBurg1")
     
     
     end
     ---------------------------------------------------------------------------
     -------------------------
     function ZitadellenCounterOne()
     
     
     ifnot TurmBurg1.created then
         TurmBurg1.created = not isDead
     end
     
     
     ifnotZitadelle1.created then
     Zitadelle1.created = not isDead
     end
     
     
     
     
     if  IsDead(TurmBurg1) then-- attached to player 2
     if  IsExisting("Zitadelle1") then
     
     
     if ( counterZ > 0 ) then
            counterZ = counterZ -1  -- Sekunden werden runtergezählt
     else
     
     
     if ( rundeZ < 10 ) then
            CreatePlayerOneCastleGarnison()
            Message("Soldaten aus der Festung sind auf dem Weg!")
            counterZ = 15   -- jedes Mal die Wartezeit wieder auf 15Sek setzten
            rundeZ = rundeZ +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
     
     
     else 
            StartSimpleJob("ZitadellenCounterOneReset")
            Message("Eure Armeen sind erschöpft!")
     returntrue
     end
     
     
     end
     
     
     else
      Message("Die Bastion ist gefallen!")
     returntrue
     end
     end
     
     
     end
     -----------------------
     function ZitadellenCounterOneReset()
     
     
     if  IsDead(TurmBurg1) then-- attached to player 2
     if  IsExisting("Zitadelle1") then-- attached to player 2
     
     
     if  ( refreshCounterZ < 40) then
             refreshCounterZ = refreshCounterZ + 1  -- Sekunden werden hochgezählt
     else
             counterZ = 5  -- nach der Wartezeit nicht noch einmal die volle Zeit abwarten
             rundeZ = 1
             refreshCounterZ = 0
     
     
             StartSimpleJob("ZitadellenCounterOne")
             Message("Neue Soldaten sind ausgehoben!")   
     -- and destroy this job, it will be generated in loop anyway
     returntrue
     end
     
     
     else 
     returntrue
     end
     end
     
     
     end
     ----------------------------------------------------------------------------------------------
     ---------------------------------------------------------------------------------
     function CreatePlayerTwoFortress()
     
     
     local PlayerMace = {   -- keine genauen Angaben erforderlich, da es eine local ist
         player = 4
         };
     
     
     local troopDescription1 = {
         maxNumberOfSoldiers = 4,
         minNumberOfSoldiers = 0,
         experiencePoints    = NORMAL_EXPERIENCE,
         leaderType          = Entities.CU_BlackKnight_LeaderMace2,
         position            = GetPosition("Burg2Mace")
         };
     
     
     local nMaceID = CreateTroop(PlayerMace,troopDescription1);
     
     
             Attack(nMaceID,"TorBurg1")
     
     
     --------------
     local PlayerBogen = {  
         player = 4
         };
     
     
     local troopDescription2 = {
         maxNumberOfSoldiers = 4,
         minNumberOfSoldiers = 0,
         experiencePoints    = NORMAL_EXPERIENCE,
         leaderType          = Entities.PU_LeaderBow2,
         position            = GetPosition("Burg2Bogen")
         };
     
     
     
     
     local nBowID = CreateTroop(PlayerBogen,troopDescription2);
     
     
             Attack(nBowID,"TorBurg1")
     
     
     --------------
     local PlayerSchwert = {  
         player = 4
         };
     
     
     local troopDescription3 = {
         maxNumberOfSoldiers = 4,
         minNumberOfSoldiers = 0,
         experiencePoints    = LOW_EXPERIENCE,
         leaderType          = Entities.PU_LeaderSword3,
         position            = GetPosition("Burg2Schwert")
         };
     
     
     
     
     local nSwordID = CreateTroop(PlayerSchwert,troopDescription3);
     
     
             Attack(nSwordID,"TorBurg1")
     
     
     end
     ---------------------------------------------------------------------------
     function ArmeeCounterTwo()
     
     
     if  IsExisting("TurmBurg2") then-- attached to player 4
     
     
     if ( counter2 > 0 ) then
             counter2 = counter2 -1  -- Sekunden werden runtergezählt
     else
     
     
     if ( runde2 < 5 ) then
            CreatePlayerTwoFortress()
            Message("Ein kleiner Trupp zur Unterstützung ist auf dem Weg")
            counter2 = 25   -- jedes Mal die Wartezeit wieder auf 20Sek setzten
            runde2 = runde2 +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
     
     
     else 
           StartSimpleJob("ArmeeCounterTwoReset")
           Message("Eure Armeen sind erschöpft!")
     returntrue
     end
     end
     
     
     else
     --Message("Die Bastion ist gefallen!")
     returntrue
     end
     
     
     end
     -----------------------
     function ArmeeCounterTwoReset()
     
     
     -- when armyOne has no leader alive, then ... (ACHTUNG!! Abfragen funktionieren nicht ohne CreatePlayer(-> 2))
     if  IsExisting("TurmBurg2") then-- attached to player 4
     
     
     if  ( refreshCounter2 < 180) then
             refreshCounter2 = refreshCounter2 + 1  
     else
             counter2 = 5   
             runde2 = 1
             refreshCounter2 = 0
     
     
             StartSimpleJob("ArmeeCounterTwo")
     --Message("Neue Soldaten sind ausgehoben!")   
     returntrue
     end
     
     
     else 
     returntrue
     end
     
     
     end
     ---------------------------------------------------------------------------------------------
      -- Quest data
     MapEditor_QuestTitle           = "Name"
     MapEditor_QuestDescription     = "Beschreibung"
    MP-Karte:
    ° 2 menschliche Spieler mit je einer Respawn-Armee, der Code für diese Armeen ist, bis auf die ID-Kennungen, identisch mit dem der Spieler-1 -Armee aus der SP-Karte
    ° Für beide Spieler gibt es einen fake-Spieler für die isDead-Abfrage (ID´s 4 und 6)
    °...sowie Statics (ID´s 3 und 5)

    Code:
    --------------------------------------------------------------------------------
    -- MapName: Cold Winter Days MP
    --
    -- Author: XXX
    --
    --------------------------------------------------------------------------------
    
    function GameCallback_OnGameStart()     
        
        -- Include global tool script functions    
        Script.Load(Folders.MapTools.."Ai\\Support.lua")
        Script.Load( Folders.MapTools.."Main.lua" )
    
        -- Unbedingt muß für die Einbindung der Ki hier auch dieses am Anfang geladen werden
        IncludeGlobals("MapEditorTools")
    
        Script.Load( "Data\\Script\\MapTools\\Counter.lua" ) --sagt mir nichts, in SP-Karten nicht drin
        Script.Load( "Data\\Script\\MapTools\\MultiPlayer\\MultiplayerTools.lua" )    
        Script.Load( "Data\\Script\\MapTools\\Tools.lua" )    
        Script.Load( "Data\\Script\\MapTools\\WeatherSets.lua" )
        IncludeGlobals("Comfort")
    
    
    ------My global variables------------------------
    refreshCounter = 0
    counter = 35
    runde = 1
    
    refreshCounterZ = 40
    counterZ = 15
    rundeZ = 10
    
    refreshCounter2 = 0
    counter2 = 35
    runde2 = 1
    
    refreshCounterZ2 = 40
    counterZ2 = 15
    rundeZ2 = 10
    
    -------------------------------------------------
    
        --Init local map stuff
        Mission_InitWeatherGfxSets()
        Mission_InitWeather()
        Mission_InitGroups()    
        Mission_InitLocalResources()
        
        -- Init  global MP stuff
        --MultiplayerTools.InitResources("normal")
        MultiplayerTools.InitCameraPositionsForPlayers()    
        MultiplayerTools.SetUpGameLogicOnMPGameConfig()
        MultiplayerTools.GiveBuyableHerosToHumanPlayer( 2 )
        
        if XNetwork.Manager_DoesExist() == 0 then        
            for i=1,2,1 do
                MultiplayerTools.DeleteFastGameStuff(i)
            end
            local PlayerID = GUI.GetPlayerID()
            Logic.PlayerSetIsHumanFlag( PlayerID, 1 )
            Logic.PlayerSetGameStateToPlaying( PlayerID )
        end
    
    
    -----------------------
    ----FMA----------------
    -----------------------
    
    ---KI Feindlichkeit--
      Setfriendly(1,4) --fake-Player für Spieler 1
      Setfriendly(2,6) --fake-Player für Spieler 2
    
      SetHostile(1,6) --fake-Player für Spieler 2
      SetHostile(2,4) --fake-Player für Spieler 1
    
      SetHostile(4,6) --fake-fake
    
      Setfriendly(1,3)    -- Statics für Spieler 1
      Setfriendly(1,5)    -- Statics für Spieler 2
      Setfriendly(2,3)    -- Statics für Spieler 1
      Setfriendly(2,5)    -- Statics für Spieler 2
    
      Setfriendly(3,4)    -- Statics-fake 1
      SetFriendly(5,4)
      Setfriendly(3,6)    -- Statics-fake 2
      SetFriendly(5,6)
    
        
        LocalMusic.UseSet = HIGHLANDMUSIC
    
    
    
    ---hier geht´s mit der KI los-------------------
    
    function CreatePlayer3()     -- STATICS: neutraler fake-player mit Spielerfarbe, um Mauern unzerstörbar und nachhaltig nutzbar zu machen
    
        player3     = {}
    
        player3.id     = 3
        player3.name     = "Festung des Herren des Nordens"
    
       -- MUST NOT have an Ai
        Display.SetPlayerColorMapping(3,1)
    
    end
    
    
          --Zweite Ki
    function CreatePlayer4()   -- fake player mit Spielerfarbe, um isExisting Abfrage bzgl Spielertum machen zu können
    
        player4     = {}
    
        player4.id     = 4
        player4.name     = "Zitadelle des Königs"
    
       -- MUST NOT have an Ai
        Display.SetPlayerColorMapping(4,1)
    
    end
    
    --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
          --Dritte Ki
    function CreatePlayer5()   -- STATICS: neutraler fake-player mit Spielerfarbe, um Mauern unzerstörbar und nachhaltig nutzbar zu machen
    
        player5     = {}
    
        player5.id     = 5
        player5.name     = "Barbaren des Nordens"
    
    -- MUST NOT have an Ai
        Display.SetPlayerColorMapping(5,2)
    end
    
    
          --Vierte Ki
    function CreatePlayer6()   -- fake player mit Spielerfarbe, um isExisting Abfrage bzgl Spielertum machen zu können
    
        player6     = {}
    
        player6.id     = 6
        player6.name     = "Nachschublinien der Barbaren"
    
    -- MUST NOT have an Ai
        Display.SetPlayerColorMapping(6,2)
    end
    
    ----------------------------------------------------------------------------------------------
       ArmeeCounterOne()
       ZitadellenCounterOne()
    
       ArmeeCounterTwo()
       ZitadellenCounterTwo()
    
     Tools.ExploreArea(-1,-1,9000) --Karte aufdecken
    
    end
    
    --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    -- This function is called on game start and after save game is loaded, setup your weather gfx
    -- sets here
    function Mission_InitWeatherGfxSets()
        
        -- Use gfx sets
        SetupHighlandWeatherGfxSet()
    
    end
    
    --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    -- This function is called on game start you should setup your weather periods here
    function Mission_InitWeather()
        
        -- Init with gfx set 1
        AddPeriodicSummer(10)
    
    end
    
    --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    -- Build Groups and attach Leaders
    function Mission_InitGroups()
            
    end
    
    --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    -- Limit the Technologies here. For example Weathermashine.
    function Mission_InitTechnologies()
    
    end
    
    --++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    -- Set local resources
    function Mission_InitLocalResources()
    
        local HumenPlayer = XNetwork.GameInformation_GetMapMaximumNumberOfHumanPlayer()
        
        -- Initial Resources
        local InitGoldRaw         = 200
        local InitClayRaw         = 600
        local InitWoodRaw         = 400
        local InitStoneRaw         = 100
        local InitIronRaw         = 300
        local InitSulfurRaw        = 20
    
        
        --Add Players Resources
        local i
        for i=1,8,1
        do
            Tools.GiveResouces(i, InitGoldRaw, InitClayRaw,InitWoodRaw, InitStoneRaw,InitIronRaw, InitSulfurRaw)
        end
    end
    
    
    -----------------------
    --Funktionen-----------
    -----------------------
    ---   mcb    v 1.0     modDT
    --   Ersetzt den Bau für den Player von PB_TowerX durch PB_DarkTowerX und erlaubt deren Ausbau.
    --   
    --   Aufruf:
    --   - modDT.init()                Startet die Ersetzung (in die FMA)
    --   
    --   Benötigt:
    --   unpack-Fix (enthalten)
    --   IsEntityOfType (enthalten)
    modDT = {}
    function modDT.init()
        modDT.unpackFix()
        modDT.GameCallback_GUI_SelectionChanged = GameCallback_GUI_SelectionChanged
        GameCallback_GUI_SelectionChanged = function()
        modDT.GameCallback_GUI_SelectionChanged()
        local sel = GUI.GetSelectedEntity()
        if IsEntityOfType(sel, "PB_DarkTower1") and Logic.IsConstructionComplete(sel)==1 then
                XGUIEng.ShowWidget("Tower", 1)
                XGUIEng.ShowWidget("Commands_Tower", 1)
                XGUIEng.ShowWidget("Upgrade_Tower1", 1)
                XGUIEng.ShowWidget("Upgrade_Tower2", 0)
            elseif IsEntityOfType(sel, "PB_DarkTower2") then
                XGUIEng.ShowWidget("Tower", 1)
                XGUIEng.ShowWidget("Commands_Tower", 1)
                XGUIEng.ShowWidget("Upgrade_Tower1", 0)
                XGUIEng.ShowWidget("Upgrade_Tower2", 1)
            end
        end
        modDT.GUIAction_PlaceBuilding = GUIAction_PlaceBuilding
        GUIAction_PlaceBuilding = function(...)
            if arg[1] == UpgradeCategories.Tower then
                arg[1] = UpgradeCategories.DarkTower
            end
            modDT.GUIAction_PlaceBuilding(unpack(arg))
        end
    end
    function modDT.unpackFix()
        if not unpack{true} then
            unpack = function(t, i)
                i = i or 1
                if i <= table.getn(t) then
                    return t[i], unpack(t, i+1)
                end
            end
        end
    end
    
    
    --- Original: Noigi
    -- Erweitert: mcb, mehrere Entitytypen
    -- 
    -- Gibt zurück, ob ein Entity von einem der angegebenen Typen ist.
    -- 
    -- Parameter:
    -- - id            Entity (id, name)
    -- - ...        typen (Entities.XXX, XXX)
    -- 
    -- Rückgabe:
    -- - true/false
    -- 
    -- Benötigt:
    -- - unpack-Fix
    function IsEntityOfType(id, ...)
        if IsDestroyed(id) then
            return false
        end
        local ty = Logic.GetEntityType(GetID(id))
        assert(table.getn(arg)>0)
        for _,t in ipairs(arg) do
            if type(t)=="string" then
                t = Entities[t]
            end
            if ty == t then
                return true
            end
        end
        return false
    end
    
    -----------Armeen-----------------------------------------------------------------------------------
    function CreatePlayerOneFortress()
    
        local PlayerMace = {   -- keine genauen Angaben erforderlich, da es eine local ist
        player = 1
        };
    
        local troopDescription1 = {
        maxNumberOfSoldiers = 4,
        minNumberOfSoldiers = 0,
        experiencePoints    = NORMAL_EXPERIENCE,
        leaderType          = Entities.CU_BlackKnight_LeaderMace2,
        position            = GetPosition("Burg1Mace")
        };
    
            local nMaceID = CreateTroop(PlayerMace,troopDescription1);
    
            Attack(nMaceID,"TorBurg2") -- "Move" is possible, too, but causes unfair battles
    
    --------------
        local PlayerBogen = { 
        player = 1
        };
    
        local troopDescription2 = {
        maxNumberOfSoldiers = 4,
        minNumberOfSoldiers = 0,
        experiencePoints    = NORMAL_EXPERIENCE,
        leaderType          = Entities.PU_LeaderBow2,
        position            = GetPosition("Burg1Bogen")
        };
    
    
            local nBowID = CreateTroop(PlayerBogen,troopDescription2);
    
            Attack(nBowID,"TorBurg2")
    
    --------------
        local PlayerSchwert = { 
        player = 1
        };
    
        local troopDescription3 = {
        maxNumberOfSoldiers = 4,
        minNumberOfSoldiers = 0,
        experiencePoints    = LOW_EXPERIENCE,
        leaderType          = Entities.PU_LeaderSword3,
        position            = GetPosition("Burg1Schwert")
        };
    
    
            local nSwordID = CreateTroop(PlayerSchwert,troopDescription3);
    
            Attack(nSwordID,"TorBurg2")
    
    end
    ---------------------------------------------------------------------------
    function ArmeeCounterOne()
    
     if  IsExisting("TurmBurg1") then
    
        if ( counter > 0 ) then
            counter = counter -1  -- Sekunden werden runtergezählt
        else
    
          if ( runde < 5 ) then
           CreatePlayerOneFortress()
           Message("Ein kleiner Trupp zur Unterstützung ist auf dem Weg")
           counter = 35   -- jedes Mal die Wartezeit wieder auf 35Sek setzen
         runde = runde +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
    
        else 
          StartSimpleJob("ArmeeCounterOneReset")
          Message("Eure Armeen sind erschöpft!")
          return true
        end
    
        end
    
     else
     Message("Die Bastion ist gefallen!")
     return true
     end
    
    end
    -----------------------
    function ArmeeCounterOneReset()
    
        -- when armyOne has no leader alive, then ... (ACHTUNG!! Abfragen funktionieren nicht ohne CreatePlayer(-> 2))
      if  IsExisting("TurmBurg1") then  -- attached to player 4
    
        if  ( refreshCounter < 180) then
            refreshCounter = refreshCounter + 1  -- Sekunden werden hochgezählt
        else
            counter = 5  -- nach der Wartezeit nicht noch einmal die volle Zeit für ArmyCounterOne() abwarten
            runde = 1
            refreshCounter = 0
    
            StartSimpleJob("ArmeeCounterOne")
            Message("Neue Soldaten sind ausgehoben!")  
            -- and destroy this job, it will be generated in a loop anyway
            return true
        end
    
      else 
      return true
      end
    
    end
    ---------------------------------------------------------------------------------------------
    function CreatePlayerOneCastleGarnison()
    
        local PlayerCastle = {   -- keine genauen Angaben erforderlich, da es eine local ist
        player = 1
        };
    
        local troopDescription = {
        maxNumberOfSoldiers = 6,
        minNumberOfSoldiers = 0,
        experiencePoints    = HIGH_EXPERIENCE,
        leaderType          = Entities.PU_LeaderPoleArm4,
        position            = GetPosition("Festung1")
        };
    
            local nPoleID = CreateTroop(PlayerCastle,troopDescription);
            Attack(nPoleID,"TorBurg1")
    
    end
    ---------------------------------------------------------------------------
    function ZitadellenCounterOne()
    
     if not TurmBurg1.created then
        TurmBurg1.created = not isDead
     end
    
     if  IsDead(TurmBurg1) then  -- attached to player 4
     if  IsExisting("Zitadelle1") then  -- attached to player 4
    
         if ( counterZ > 0 ) then
             counterZ = counterZ -1  -- Sekunden werden runtergezählt
         else
    
          if ( rundeZ < 10 ) then
           CreatePlayerOneCastleGarnison()
           Message("Soldaten aus der Festung sind auf dem Weg!")
           counterZ = 15   -- jedes Mal die Wartezeit wieder auf 15Sek setzten
         rundeZ = rundeZ +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
    
        else 
          StartSimpleJob("ZitadellenCounterOneReset")
          Message("Die königlichen Truppen sind erschöpft!")
          return true
        end
    
        end
    
     else
     Message("Die Bastion ist gefallen!")
     return true
     end
     end
    
    end
    -----------------------
    function ZitadellenCounterOneReset()
    
      if  IsDead(TurmBurg1) then  -- attached to player 4
      if  IsExisting("Zitadelle1") then  -- attached to player 4
    
        if  ( refreshCounterZ < 240) then
            refreshCounterZ = refreshCounterZ + 1  -- Sekunden werden hochgezählt
        else
            counterZ = 5  -- nach der Wartezeit nicht noch einmal die volle Zeit abwarten
            rundeZ = 1
            refreshCounterZ = 0
    
            StartSimpleJob("ZitadellenCounterOne")
            Message("Neue Soldaten sind ausgehoben!")  
            -- and destroy this job, it will be generated in loop anyway
            return true
        end
    
      else 
      return true
      end
      end
    
    end
    ----------------------------------------------------------------------------------------------
    function CreatePlayerTwoFortress()
    
        local PlayerMace = {   -- keine genauen Angaben erforderlich, da es eine local ist
        player = 2
        };
    
        local troopDescription1 = {
        maxNumberOfSoldiers = 4,
        minNumberOfSoldiers = 0,
        experiencePoints    = NORMAL_EXPERIENCE,
        leaderType          = Entities.CU_BlackKnight_LeaderMace2,
        position            = GetPosition("Burg2Mace")
        };
    
            local nMaceID = CreateTroop(PlayerMace,troopDescription1);
    
            Attack(nMaceID,"TorBurg1")
    
    --------------
        local PlayerBogen = { 
        player = 2
        };
    
        local troopDescription2 = {
        maxNumberOfSoldiers = 4,
        minNumberOfSoldiers = 0,
        experiencePoints    = NORMAL_EXPERIENCE,
        leaderType          = Entities.PU_LeaderBow2,
        position            = GetPosition("Burg2Bogen")
        };
    
    
            local nBowID = CreateTroop(PlayerBogen,troopDescription2);
    
            Attack(nBowID,"TorBurg1")
    
    --------------
        local PlayerSchwert = { 
        player = 2
        };
    
        local troopDescription3 = {
        maxNumberOfSoldiers = 4,
        minNumberOfSoldiers = 0,
        experiencePoints    = LOW_EXPERIENCE,
        leaderType          = Entities.PU_LeaderSword3,
        position            = GetPosition("Burg2Schwert")
        };
    
    
            local nSwordID = CreateTroop(PlayerSchwert,troopDescription3);
    
            Attack(nSwordID,"TorBurg1")
    
    end
    ---------------------------------------------------------------------------
    function ArmeeCounterTwo()
    
     if  IsExisting("TurmBurg2") then
    
        if ( counter2 > 0 ) then
            counter2 = counter2 -1  -- Sekunden werden runtergezählt
        else
    
          if ( runde2 < 5 ) then
           CreatePlayerTwoFortress()
           Message("Ein kleiner Trupp zur Unterstützung ist auf dem Weg")
           counter2 = 25   -- jedes Mal die Wartezeit wieder auf 20Sek setzten
         runde2 = runde2 +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
    
        else 
          StartSimpleJob("ArmeeCounterTwoReset")
          Message("Die Barbaren sind erschöpft!")
          return true
        end
    
        end
    
     else
     Message("Das Lager der Barbaren wurde zerstört!")
    
     return true
     end
    
    end
    -----------------------
    function ArmeeCounterTwoReset()
    
        -- when armyOne has no leader alive, then... (Abfragen funktionieren nicht ohne CreatePlayer(-> xx))
      if  IsExisting("TurmBurg2") then  -- attached to player 6
    
        if  ( refreshCounter2 < 180) then
            refreshCounter2 = refreshCounter2 + 1 
        else
            counter2 = 5  
            runde2 = 1
            refreshCounter2 = 0
    
            StartSimpleJob("ArmeeCounterTwo")
            Message("Die Barbaren greifen wieder an!")  
            return true
        end
    
      else 
      return true
      end
    
    end
    ---------------------------------------------------------------------------------------------
    ---------------------------------------------------------------------------------------------
    function CreatePlayerTwoCastleGarnison()
    
        local PlayerCastle = {   -- keine genauen Angaben erforderlich, da es eine local ist
        player = 2
        };
    
        local troopDescription = {
        maxNumberOfSoldiers = 6,
        minNumberOfSoldiers = 0,
        experiencePoints    = HIGH_EXPERIENCE,
        leaderType          = Entities.PU_LeaderPoleArm4,
        position            = GetPosition("Festung2")
        };
    
            local nPoleID = CreateTroop(PlayerCastle,troopDescription);
            Attack(nPoleID,"TorBurg2")
    
    end
    ---------------------------------------------------------------------------
    function ZitadellenCounterTwo()
    
     if not TurmBurg2.created then
        TurmBurg2.created = not isDead
     end
    
     if  IsDead(TurmBurg2) then  -- attached to player 6
     if  IsExisting("Zitadelle2") then
    
         if ( counterZ2 > 0 ) then
             counterZ2 = counterZ2 -1  -- Sekunden werden runtergezählt
         else
    
          if ( rundeZ2 < 10 ) then
           CreatePlayerTwoCastleGarnison()
           Message("Soldaten aus der Festung sind auf dem Weg!")
           counterZ2 = 15   -- jedes Mal die Wartezeit wieder auf 15Sek setzten
         rundeZ2 = rundeZ2 +1  -- "runde = runde" so müsste die Limitierung aufgehoben sein
    
        else 
          StartSimpleJob("ZitadellenCounterTwoReset")
          Message("Die barbarischen Horden sind zerstreut worden - fürs erste...")
          return true
        end
    
        end
    
     else
     Message("Die Bastion der Barbaren ist gefallen!")
     return true
     end
     end
    
    end
    -----------------------
    function ZitadellenCounterTwoReset()
    
      if  IsDead(TurmBurg2) then  -- attached to player 6
      if  IsExisting("Zitadelle2") then  -- attached to player 6
    
        if  ( refreshCounterZ2 < 240) then
            refreshCounterZ2 = refreshCounterZ2 + 1  -- Sekunden werden hochgezählt
        else
            counterZ2 = 5  -- nach der Wartezeit nicht noch einmal die volle Zeit abwarten
            rundeZ2 = 1
            refreshCounterZ2 = 0
    
            StartSimpleJob("ZitadellenCounterTwo")
            Message("Nachschubtruppen der Barbaren greifen an!")  
            -- and destroy this job, it will be generated in loop anyway
            return true
        end
    
      else 
      return true
      end
      end
    
    end
    ----------------------------------------------------------------------------------------------
    -- Quest data
    MapEditor_QuestTitle                = "Name"
    MapEditor_QuestDescription     = "Beschreibung"
    Edit: (1) Um Verwirrungen vorzubeugen wurden einige alte "-- attached to player x" Kommentare in die richtige ID umgeschrieben. (2) Grafik der SP-Karte eingefügt (3) Stand aktualisiert.
    Geändert von Indianer (19.12.2015 um 16:51 Uhr)

  2. #2
    12 of 5
    Registriert seit
    20.10.2015
    Beiträge
    4
    Downloads
    0
    Uploads
    0

    Standard AW: Rspawn-Armeen in SP und MP brauchen Review

    Guys...anyone...?

  3. #3
    Administrator Avatar von SpiderFive
    Registriert seit
    17.10.2002
    Beiträge
    24,569
    Downloads
    1
    Uploads
    0

    Standard AW: Rspawn-Armeen in SP und MP brauchen Review

    sry scheint keiner den Fehler zu finden
    Man kann alle Leute einige Zeit zum Narren halten und einige Leute allezeit; aber alle Leute allezeit zum Narren halten kann man nicht. (Abraham Lincoln)



    Siedele lang und erfolgreich

  4. #4
    12 of 5
    Registriert seit
    20.10.2015
    Beiträge
    4
    Downloads
    0
    Uploads
    0

    Standard AW: Rspawn-Armeen in SP und MP brauchen Review

    Sieht fast so aus...ist aber auch insgesamt n sehr langes Skript, schwer zu prüfen..

    Naja, vllt findet sich ja doch noch was.

  5. #5
    12 of 5
    Registriert seit
    20.10.2015
    Beiträge
    4
    Downloads
    0
    Uploads
    0

    Standard AW: Rspawn-Armeen in SP und MP brauchen Review

    Okay, die Karten stürzen jetzt nicht mehr ab - man darf kein "SetupAi" machen für eine Ki, die eine per Skript generierte und gesteuerte Armee besitzt...scheinbar... und für eine Ki, die nur aus drei Mauern besteht, auch nicht - das macht keinen Sinn, aber nun gut...

    Auf der SP-Karte wird die Ki richtig geladen, die Karte funktioniert nun so. Leider Werden die Garnisons-Truppen nicht generiert, wenn der Spawngenerator "TurmBurg1/2" zerstört ist.

    Größeres Problem: Im MP wird die Ki scheinbar nicht geladen, und die Karten werden nicht aufgedeckt. Es werden keine Armeen erzeugt, was vllt an der nicht erstellten Ki liegt. Kann Jemand helfen? Es ist jetzt schon nicht mehr viel zu tun, aber ich schaffs nicht allein glaube ich :/

    Liebe Grüße!

Aktive Benutzer

Aktive Benutzer

Aktive Benutzer in diesem Thema: 1 (Registrierte Benutzer: 0, Gäste: 1)

Ähnliche Themen

  1. Brauchen wir etwa ein
    Von SpiderFive im Forum Cafe Paperlapapp (Klön)
    Antworten: 46
    Letzter Beitrag: 25.01.2009, 17:35
  2. Was brauchen wir noch als Questmodule
    Von SpiderFive im Forum Siedler 6 AeK Mapperecke
    Antworten: 123
    Letzter Beitrag: 08.11.2008, 12:02
  3. Gameswelt:[PC] Die Siedler 2: Die nächste Generation (Review)
    Von SpiderFive im Forum Siedler 2 DnG Die nächste Generation
    Antworten: 0
    Letzter Beitrag: 08.09.2006, 18:16
  4. [Spellforce] Spellforce 2 Review
    Von SpiderFive im Forum Allgemein
    Antworten: 0
    Letzter Beitrag: 31.03.2006, 16:32

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •