No announcement yet.

Ultimate ONS Tools (a touch of Kismet for mappers)

  • Filter
  • Time
  • Show
Clear All
new posts

    Ultimate ONS Tools (a touch of Kismet for mappers)

    Name: UltimateONSTools
    Version: 1.0
    Compatibility: UT2004 should be enough, I think you don't even need the ECE, although it's consider "stock" by the community, so maybe you want to install it anyway, just to be sure.

    Most of you have probably never seen me before because I am usually more active in pure ONS-forums, but now I created something that I want to share with the whole community. I hope that they can use it to let this game live for further ten years.

    So what have I done actually? The download link at the end of this post is a .u-file that you can load in the Actor Class Browser of UnrealEd 3, which will add some things to that list.
    These things will allow you to take a lot more influence in an ONS-map than you maybe ever dreamt of. I will give you some examples and then explain in detail how to use the tools.
    You will also find an example map attached, which I will explain further below and which demonstrates some things you can do. (The original map was created by Wulff)

    What you can do with this:

    This will probably look familiar to those of you who played Warfare in UT3:

    -Let's take the first one: a powernode that controls a bridge. It's really hard (if not even impossible) to achieve that in UT2004 with the default methods. With the tools will it be done in a few minutes.

    -Maybe you want to bring some more time pressure into the game? Imagine that you could pick a certain node. If a team builds that node, then a countdown will start, let's say 60 seconds. Now the enemy team needs to destroy that node within these 60 seconds, or something bad will happen. For example could a Levi be spawned there after 60 seconds. Or their powercore, although it is save considering the linksetup, could take damage.

    -One node with that time limit seems to unfair to you? Well, you can extend that condition!
    Maybe your team should need to hold 2 nodes for the bonus? And maybe must a certain enemy node be downed, or the condition to activate the countdown will not be fulfilled.

    Almost everything is possible. This is something what you could call a smaller version of Unreal Kismet, without that fancy interface, unfortunately.

    How it works:
    This package contains several actors that can be placed in a map. The actors are:
    -UltimateONSFactory (a subclass of a normal ONSFactory)
    -EventLogicGate (a subclass of Triggers)
    -the rest are subclasses of EventLogicGate, which is actually only there for the structuration.

    If you feel to skip this long manual, then just right-click on the actor that you want to know more about and click on "Edit Script…"
    I made a lot of comments to tell you what each variable that you see in it's properties is doing. Take a look on those comments and on the testmap and you should be fine.
    I also recommend to leave things at the default value if you are not sure what they do.

    However, I continue with the manual now.

    You will need to know the basics of digital circuits in order to use many of these things, but they are pretty simple.

    Digital circuits work with logical gates. This package contains similar logical gates. But while you use the Boolean values (True and False, or 1 and 0) in reality, this stuff is basing on the Trigger-system of the Unreal Engine.

    That means that certain actors can cause "Events" when a certain condition is fulfilled. The most known thing for that is a Trigger, which will cause an Event when you touch it. Touching the Trigger will call it's Touch-function in UnrealScript and that function will cause the Trigger to "trigger" every actor whose Tag matches the Event that you set in the properties of the Trigger (while you set the Tag in the properties of the actor that you want to trigger).
    Ok, so when one of the actors in this package is triggered, than a part (or the whole) condition is True. The actor will do something if or as long as the whole condition is True.

    "As long as" means, that it might cease doing what it is doing when the whole condition gets False. To achieve that it is enough to have only a part of the condition becoming False. And how can you get a condition False?
    By "untriggering" it. Not many of Epic's actors support the full triggering system, meaning they often can only trigger things, but not untrigger them.
    Untriggering uses the same Event-field as the Triggering does.
    One actor that does support untriggering is by chance the Trigger, that I described above already. It can untrigger it's Event when you leave the Trigger's collision radius.
    And Mover, for example, can be set to move when they get triggered and to stay there until they get untriggered. You see how that works out for our bridge idea, don't you?

    So ok, we have the Trigger that does the whole stuff, but that's actually a bit cheap in ONS. So that's why I created something that interprets the current constitution of a powernode out of it's Events. You need to know, that a node (or powercore, I use that name for both things) has, different from most other actors, not just the normal Event-field: it has 3 additional Event-fields, one that triggers when the Red team has build the node, one when the Blue team did that and one that triggers when the node gets destroyed.
    So you enter a different name for each of the 3 Event-fields and then place a NodeEventDirector from my package. That thing has 3 Tag-fields in which you should now enter the three names that you set for the node's Events.

    The NodeEventDirector will now take care of triggering and untriggering, depending on the node. But in order to have it work properly, you need to specify for which team it shall work actually (that is done with ObserverTeamNum). So if you set 0, then the "condition" will be True, when the Red team has build that node. 1 means the Blue team. You then just need to specify an Event that this NodeEventDirector shall trigger actually.

    What are the other things that this actor can do?
    -bSwitchTeamsOnReset: if True, then the ObserveTeamNumber is automatically adjusted when the sides swap in ONS. That means that if the condition was True when Red had the node in the first round, then it will be True for Blue in the second one. That is very useful to have equal conditions in both rounds for the teams, so it's basically just the teamcolour that switched.
    -LinksetupException: enter the name of a Linksetup in this array, which you want to ignore this actor. For example entering "default" (the name is not case-sensitive) will not let this NodeEventDirector trigger something at all, when the Default setup is active.

    I am talking about the actors that start with "Logical" in their name. They work like the real digital ones, so I will only explain what they compute:

    LogicalOR: As all LogicalGates (except the LogicalNOT) has the LogicalOR two Tag-fields in which you enter the name of two different Events that shall trigger this OR.
    The LogicalOR will itself trigger a new Event (which you have to specify) when at least one of the condition is True, meaning if at least one of two possible Events has triggered it.
    It will untrigger it's own Event, when it gets untriggered by both Events.

    LogicalAND: This behaves like the OR, except that it will only trigger it's own Event, when it got triggered by both of the conditional Events. It will untrigger it's own Event when at least one of the conditional Events untriggers the AND.

    LogicalXOR: The exclusive OR does the same as the OR, but it will only work if exactly one condition is fulfilled and the other one is not. So it will untrigger if both or none of the conditions is True.

    LogicalNOT: This reverses the incoming Event and will output the result (as every EventLogicGate) in a new Event-name.
    So if you trigger this thing, then it will untrigger it's output-Event, if you untrigger the NOT, then it will trigger the output.

    As I said above already, not every retail actor supports the untriggering, and that in both directions. Meaning that some don't understand untriggering and can only be toggle-triggered. Or some actors only send Trigger-Events and you won't get any Untrigger-Event from them.
    That's why I made this thing, which can turn one thing into the other.
    IMPORTANT: This is not the same as the LogicalNOT! That one would work in both directions, this one only in the specified one. You can specify the direction by going into the Object-group in the properties of this actor and to set the other InitialState.
    The UnTriggerCase will not care about the order in which the Events come in, so you need to have that done somehow by the actor that sends the Events. (That might be a possible feature for the next pack: Cast only each second incoming Event. But on the other hand should it work fine if you just put a Counter before or after this)

    A very important thing, when you trigger it will it wait for the specified number of seconds before it triggers the next Event.
    But in that time can it be untriggered to prevent it from triggering the next Event.
    You can also specify a ToleranceTime (leaving this one on 0 will disable it).
    The Tolerance can do two important things: If the countdown gets aborted (aka untriggered) before it had finished, then you have ToleranceTime much seconds to trigger the CountdownEventGate again. If you manage to do so, then you will continue from that time where the countdown was aborted, otherwise you have to start at the full time again.
    The second thing is that if there's a ToleranceTime specified and the countdown succeeded already and the CountdownEventGate gets untriggered, the next Event will not get untriggered immediately. If you can re-trigger the Gate before the ToleranceTime is over, then you prevent that untriggering.

    You can also specify a seperate CountdownStoppedEvent, that will trigger (not untrigger!) when the countdown was aborted in time.

    -bLoopCountdown: When the countdown succeeded and triggered the Event, then it will start from the full time again and loop until it really gets untriggered.
    -bBroadcastCountdown: Setting this to True will show the remaining time on that countdown in the player's HUD in regular intervals. The intervals become smaller the more the countdown is close to succeeding.
    -Messages: You can define different messages for the Red and Blue team that will be shown in their HUD when different things happen with the countdown.
    You can also choose the message type, what will change where the messages (and the remaining countdowntime, if broadcasted) will be shown. CriticalEvent is the default and best solution, but I want to leave the choice to you.
    It is also recommend to let the message teams be switched, so that the messages really match the right team. If choosing this, you should avoid to use "Red", "Blue" or unique descriptions of the map that might not apply to the switched team. Leave a message empty to disable it from being displayed.

    Simply choose a Target by clicking on Pick and then on the Target in the Editor. You can choose a different one for switched rounds too, or take the same as in the first because there need to be both set. Note, that the location of the cores will not switch in the rounds, so you probably want to choose the same core in both rounds when planning to damage it.
    Yes, this thing deals damage to nodes and cores when it gets triggered and it has no problem to also damage a shielded node or core.
    The player who triggered the Event that caused this actor to deal the damage will be rewarded with the points for that.
    Note, that someone can't damage it's own nodes or core, when they directly trigger that DamageGate (meaning the Instigator of the Event is from the team that owns the node). However, you can still accidentially damage your nodes when the damage got triggered by something that is not a Pawn EventInstigator (something that can have a teamnumber), like a node that your team build. So as a mapper it's your job to pay attention.

    -bNotifyAboutDamage: If True, this will enable messages like "Blue PowerCore under attack" when it is damaged by this actor, otherwise will it be a "silent" damage.

    For your information: a powercore has 4500 healthpoints, a node has 2000.

    It's really ultimate as it allows you to take so much influence on a map's vehicle balancing like never before!

    As for the NodeEventDirector, you can specify LinksetupExceptions in which this factory is NOT active.
    You have two arrays, one for Red and one for Blue, which can contain multiple, different vehicles. One of them is chosen randomly to be spawned, depending on which team holds the factory. If you leave a blank in between, that will be counted as bad luck and you have to wait for the whole RespawnTime again for the chance of a vehicle.
    (The arrays will only be used, if bRandomSpawn = True, otherwise the one, small VehicleClass-field is used)

    -You can spawn neutral vehicles (will use the array of Red's vehicles), set the factory to work only for one team (bUseStaticTeams / StaticTeamNum)
    -You can set for each vehicle in the array the size of the SpawnEffect, so for example having a Scorpion with the gigantic SpawnEffect of a Levi. This is more useful to custom vehicles, but besides that would there be no other way to properly implement the effects for so many different vehicles.
    -bUniqueVehicle: Spawn only one vehicle, stop doing anything after that. That could be used for very, very, very, powerful supervehicles, or neutral ones.
    -bIndependentFactory: The factory does not depend on a node! It will use the StaticTeamNum to be assigned to a team from the beginning (can also be 255= neutral, so the first who gets it will possess it). An independent factory will be active, no matter what's happening around it and it can be placed everywhere and still work for the same team.
    (Think of having a spawnpoint for neutral Leviathans that spawn every 5 minutes)
    -bEnabled: The factory is enabled from the beginning. Set this to False and let the factory be triggered by something to enable it. (Untriggering will disable it again)
    -bCrushable: Spawn the vehicle, no matter if there is a player. The player will be crushed by the spawning vehicle, even if he's in your team, but this is good against enemies who try to block a spawning vehicle.
    -bSpawnProtected[Red/Blue]: If True for one of the teams, then this team's vehicle will take no damage as long as it has not been used by the team. This prevents the enemy from camping and spamming your spawning vehicles.
    -bEnterringUnlocks: If False, this vehicle will still be teamlocked after being entered. Best use for this is, if you spawn MinigunTurrets with this factory and don't want them to be used by the enemy.

    See the script of this actor if you need further information.

    Note that "Red vehicle array" and "Blue vehicle array" can be considered as the position rather than the team. When sides are switched, then the factory that is placed in the Editor on the Red side and produces Red vehicles will work for Blue when Blue is on that side, but the vehicles to spawn will be taken from the Red vehicle array just like it would be done in a round without switched sides.


    That was it for now. I hope you can use this do give us some really good maps with things you were just not able to do until now.
    Think about vehicle balancing: You can spawn different vehicles for Red and Blue at the same node, giving the winning team for example weaker vehicles at the enemy prime nodes.

    Also, you can use a combination of all this actors to create something like this:
    When the Blue team was pushed back into it's base and survives very long, but sees no chance for a comeback, then you could spawn an additional helpful vehicle for them to free themselves.

    The actors for such a situation could be:
    NodeEventDirector at the two primary nodes observes if the Blue team has build the nodes -> LogicalNOT turns the Falses of both nodes into Trues -> LogicalAND connects these two things and sends the output -> CountdownEventGate counts two minutes before it triggers -> UltimateONSFactory at Blue base is triggered and spawns a vehicle (bUniqueVehicle = True).

    In words would that mean: If Blue team did not made it to build one of their primaries in the last two minutes, then spawn exactly one time an additional vehicle at their base to give them a chance for comeback.

    So, that was long, I am exhausted.
    This is a stable release that is there for you to use it.
    Please do not modify this package or take anything out of it. Just put the whole package with your maps if you use something of this. And please give credit to me where it should be done.

    Please give me feedback about this! I want to make an updated version of this one day, so tell me about bugs or what things you miss in such an UltimateONS-package.
    Don't worry if you use things of this in your map. You will not need to update everything in your map when a new package comes out, unless you need the new features in the new package.

    It's pretty hard to post screenshots for something that you usually see only in action. So take a look for yourself with the example map in this package.
    I was asked already to add some of these things in a real map, like Torlan, so that the people can see if it works out. It shall be done, but later.

    I said I would explain the testmap. Just open in the editor and see how it could have been done. The things that happen there, from the view of only one teamside:
    -Building the center node will spawn one of two possible, neutral, vehicles after some time.
    -Building the center and your prime will spawn a vehicle on your side.
    -Building the enemy prime will damage the enemy core unless the enemy takes his prime back.

    Have fun.

    Wormbo - I couldn't have done this without him. Whenever I had a question about UnrealScript -> Wormbo has the answer.
    Stepo - He did his best supporting me.
    TAhrrkijn - Always tried to help me where he could. What would Dr. House be without his team? Still brilliant, but he needs someone to discuss his problems with before he can solve them.
    Mychaeel - from the Jailbreak Developer Network. I couldn't have done anything that uses more than one Tag without his JBProbeEvent-script, which I borrowed. Thank you very much.
    SuperApe - He probably doesn't even know me, but his SuperVehicleFactory somehow started this project because that Factory didn't work well in ONS (it didn't care about the nodes), so I decided to make my own Factory. And then I wanted to control how nodes affect the Factory and step by step was this project born.

    Known bugs:
    -An Independent Factoy is unfortunately not 100% independent. Nodes have a bad habit to destroy any teamlocked vehicles that are closest to them in compare to other nodes. They dynamically find the vehicles when they get destroyed and call the Destroy()-function for each of these vehicles.
    The vehicles will respawn, but it can be annyoing, especially with a high respawn-time. However, when the Independent Factory spawns neutral vehicles, then it will be all fine, as those a already TeamUnlocked when spawning.
    There might also be the case that vehicles that are spawned with bEnterringTeamUnlocks = False will be destroyed by the destruction of close nodes when the driver left them.
    That's a bad thing, so that value is more experimental.

    -Since the NodeDamageGate needs to accept "InstigatorController == None" in the script in order to let it get triggered by the NodeEventDirector-chain, it can be triggered by pretty everything. It is doing a check if "InstigatorController != None" to find out whether the Target has the same TeamNum as the Instigator and so whether it should damage it or not.
    During testing I was running about the bug that a player itself couldn't damage a node by his team, but if he would die right infront of a simple Trigger and let the corpse touch the Trigger, then that could damage the node. So I recommend not to use the NodeDamageGate with Triggers that can be activated by simple touches, either restrict it to something specific (that should be possible), or use something like a UseTriggger.

    -bEnterringTeamUnlocks of the UltimateONSFactory will have no effect on a MinigunTurret from Assault, because this is already unlocked when it spawns. And so there's nothing to prevent from being unlocked anymore.

    Here are other threads in other forums where I posted that thing, so if you have a question or request, then it's maybe already answered there:

    Download: (should be a pretty small file in size)
    *Download is only for testing purpose, do not map with it, as it's not clean yet*

    So, this is what I already planned for the next release:
    +Giving more settings in the UltimateONSFactory, so the mapper has some more controls to play with, like bTeamLock (which will always lock the vehicle to the specified TeamNum)
    +Let some of these things cause some more Events at certain points, so that the mapper can control the gameflow even better.
    +Adding a new feature and aspect, which will devide in several subclasses:
    -One actor that, once placed in a map, will store the information about each team's "credit account", "resources", …however you wanna call it.
    -Then there's an actor that, when it gets triggered, will add a specific amout of points to this resource-counter.
    -Another one, that, when triggered, will decrease a specific amount of points.
    But that's not all, it will do that only if this won't get the resource-counter below 0. If it works, then it will trigger an Event, otherwise it will do nothing.

    What can you do with that feature? Imagine that controlling a node will give you resources over time and that the spawning of new vehicles will cost you resources. And you could "order" them by using a Trigger, so that the team needs to learn in what they can best invest.
    And it's not impossible to build whole bases with this… and that's not a custom gametype, it's still ONS and maps that do it this way will not unwhitelist the server!


      I need to ask you not to use this actor, as it has one little bug that prevents it from using all of it's possibilities and one left-over piece of debugging-code.

      However, the next version will be out soon and offers some new features too.


        Sounds truly awesome.



          Well, if someone codes something that allows to have unlinked Nodes in a Linksetup without using a mutator or modifying the ONSOnslaughtGame.u (probably only the PowerLink, ONSPowerCore and ONSPowerNode) but with the same functionality as a normal Node (Radar, VehicleFactories, Teleports, Playerstarts), then we really had EVERYTHING we need to make 1:1-portations of UT3-WAR-maps.
          Unlinked CountdownNodes could be so great and put much more on top of UT2k4's lifetime.

          But I took a look already and it seems pretty hard to me to do such a thing.

          One would probably need to have a Core, that can reference nodes that are placed in the map in an array, so that the Core knows that he shouldn't be vulnerable when he is linked to one of those.
          Then the same thing for the Node (the Nodes would automatically be linked to both Cores, maybe using a subclass of Powerlink, which has it's Alpha-colour set to 0, so that it would be translucent on the minimap).

          I unfortunately have not enough experience and time to dig into that, but someone else here…


            If you can port the orb to, you are going to be my hero . . .


              I already thought of that, but that won't be a feature for the next release. Maybe for a later one.
              Shouldn't be THAT hard, but will probably cost some performance too.

              But someone else should care about the orb's mesh and the link-effect.


                Originally posted by Crusha K. Rool View Post
                But someone else should care about the orb's mesh and the link-effect.
                UT2004 has Bombing Run, use its meshes.


                  Since everybody is posting his progress in these forums I thought that I could do that too.

                  These things have been expanded already:
                  -UltimateONSFactory can now set some different properties for every single vehicle, like ejecting player when the vehicle gets destroyed, spawnprotection for the vehicle, if enterring unlocks the vehicle for the enemy team and the health.
                  I also fixed the problem with MinigunTurrets that are always open for both teams. Now you can use this factory to have them locked for the other team.
                  There are also some small performance and memory improvements in this thing.
                  It's also no longer possible to use the single VehicleClass-field of the normal ONSFactory to use a single vehicle, the UltimateFactory will always use the VehicleArrays with a random selecetion by default. But in exchange I added the value bSequentialSpawn, if you want the vehicles in the arrays to be used in a specific order.

                  -NodeEventDirector no longer needs to have every single tag-name of the Node that is observed entered by hand. You still need to make up some unique names for the Events of each Node, but then you can use this actor and just click on the Node that you want to observe, the actor will then copy the necessary values of the Node at runtime, saving you some work.
                  I also fixed a bug that was pretty bad when used in combination with the LogcialNOT. Before, this thing wasn't doing anything when the Node wasn't built, now it sends an UnTriggerEvent, which can be turned to a TriggerEvent by the LogicalNOT.

                  These things are completely new:
                  -I added the fix for CameraTextureClients to work online in this collection. It's just a simple line of code that was changed and everyone who really needed it, did it already, but I thought it would be nice to have it comfortably in a package finally.

                  -RandomEventGate. The mapper can enter a floating point value that is in percent the probability with that an Event will be triggered when this actor gets triggered. You can either have another Event in the other case or do nothing.
                  This is useful if you want to get away from the "static" things that come with these actors. Maybe the players will notice after some time, that the tank will always spawn when our primaries are down for 2 minutes. Then they could decide to wait with capturing their primaries when the 2 minutes are almost over. But with this thing you could make the tank spawn only by a certain percentage, so if they have bad luck, the expected supplies won't arrive.

                  -PlayerCountEventGate triggers an Event if at least a certain number of players have entered the game. There is also an option that allows you to count only real human players.
                  That way you can layout your map for different playernumbers. Place some vehicles that are always there, then have some VehicleFactories that only enable when there are at least 24 players on the server, for example.
                  If the playercount shrinks below the specified amount, then the Event will be untriggered again.
                  You can also let this thing work in the other direction by using a LogicalNOT. Then it will Trigger if less than the specified amount of players are in the match.

                  -ScoreContainer: This stores an abstract score for both teams that has nothing to do with kills or the health of nodes or anything like that.
                  Instead you have two actors that can, when triggered, add or subtract a specified amount of points from the team's account.
                  The ScoreAdd can loop to add the score in a certain interval until it get's untriggered, so you could constantly add points by holding a Node.
                  The ScoreSubtract really revels the concept behind the Score: when being triggered, it will first check whether the team is liquid enough, meaning if it has >= 0 points on it's account if the Subtract would remove the specified amount of points.
                  If not, then the Subtract will do nothing.
                  But otherwise will it subtract the amount and trigger an Event - making these three actors something like a bank accounts for each team, where everyone can give and take. You could buy certain vehicles from the money by triggering UltimateVehicleFactories or buying weapons (requires a new weaponbase-class) or buy something like access across a bridge or through a door.
                  The ScoreContainer will display the team's score in the team's HUD with a customizable message at a customizable location, spectators can't see the messages but the scores of both teams at a not-customizable location.

                  What is still planned to be done / what is making problems:
                  -UltimateONSFactory: it shall be possible to set a value for each individual vehicle that allows to show that vehicle on the RadarMap permanently.
                  Besides a clever idea about the performance, I am still lacking knowledge about how to display something in the big RadarMap in the ONS-tab in menu. I hope that ONSPlus can give me some examples.

                  -Option in ScoreSubtract and ScoreAdd to allow only players of the own team to have effect on those actors. It would be bad if the enemy can manipulate your team's account. This is easy to be done.

                  -UnTriggerCast shall have an option that allows to convert only every second incoming Event, making it much more useful in some areas.

                  -UltimateWeaponLocker, UltimateWeaponBase. I haven't taken a look at all yet, but these shall let you modify the RespawnTime of a weapon, working like a WildCardBase and be able to be turned on and off, optionally turning off means that the collision is also turned off and bHidden is set to True. Shouldn't be so hard to tell the bots then, that the weapon is not available.

                  Things for later release, maybe V3:
                  -Independent Nodes
                  -FixedCameraKillVolumes. Something like in UT3: You fall down a cliff but instead of having your camera always with your Pawn, it should instead stay at the entry-location of the Volume and maybe keep fixed on the corpse. That way you don't need to care about the optic in areas where you can fall down, the camera will just not get there. However, I don't know yet how to implement it in a way that the camera position won't switch when another Pawn also enters the Volume after you and dies.

                  Any more suggestions?


                    Originally posted by Crusha K. Rool View Post
                    I also fixed the problem with MinigunTurrets that are always open for both teams. Now you can use this factory to have them locked for the other team.
                    This is quite a good thing (among the others of course ).
                    I have often read comments of people disliking those turrets because they can be hijacked by anyone, with some people specializing in spending the match in the turrets of the other team (and I quite agree with these complaints).

                    This is especially true in VCTF (given the relatively small map size compared to ONS).

                    Does you fix also affect the Linkgun turrets, which have the same issue I believe? I don't know many maps that use those (ONS-Toysoldiers does, I think ONS-Mothership too) but it still could be a way to have them gain popularity.


                      Heh, I was actually planning to put some auto-turrets at the base in the next version of Battlefront.

                      The issue with the auto-turrets was, that they were set to one specific team, not changing in ONS, since they were thought to change due to certain circumstances in AS.
                      But with this factory you can set StaticTeamNums, so you can use them at the Core bases without any problem, for the use at Nodes you would need to have one that is set to work for one team and the other one to work for the other and then to always trigger one on and the other one off, depending on which team built the Node.


                        Added a ScoreCheck and a LinksetupEventGate.

                        The first one will check a team's score in a ScoreContainer on every Tick and will trigger an Event if the value goes above a defined limit. It will untrigger the Event if the score falls below that limit again. And of course does this work very fine and useful with the LogicalNOT.

                        The second one will only let a triggered Event pass, if the current Linksetup matches one of the Linksetups that are defined in that actor.
                        UnTrigger also needs to pass the check.

                        Should it trigger an alternative Event if it doesn't get through the check? Probably yes. Any more suggestions for actors? These tools should really work like Kismet and give you interaction with many things that can happen in a match.

                        I might add something that triggers if a Player in collisionradius has a specific weapon or health, or name, etc. (what attributes should be available to choose from?). Or is such a thing already handled by UnrealScriptedSequences?


                          Added EnhancedLevelGameRules.
                          Additionally to the normal functions of a LevelGameRules-actor (forcing Mutators for the map), this one also allows the mapper to forbid certain Mutators for the map and to override the server's settings that way.

                          This is an intervention in the admin's work, you should use it wisely and only if it's really necessary, I put this in here mainly for the reason of theoretically being able to do it, using it is another story. Don't be evil.

                          Personally I only needed such a thing once, when I had a map where the Stunt-Mutator from the Server-Mutator list could ruin the whole balancing, so Wormbo coded me a short script to prevent the Mutator from working. I took that script and put in some kind of interface, so this one's credit goes mainly to Wormbo.

                          I also saw already an interesting proposition for another actor in this pack on the VehicleMaster VCTF-forum, maybe I should rename this project at a certain point to UltimateMapperTools when it gets some features that don't work with ONS at all.
                          The idea was a Mover-CTF-Flag, like in one UT3-map. I wonder whether that works from the UT2004-gamemechanic (bots will probably not really know where the flag is when it moved) and whether you can move gameobjectives at all, but I'll take a look at the code. When I have some time, unfortunately there's a lot of work to be done currently and for the next 2 weeks, especially on WE.

                          And for everyone who didn't notice yet: the Score-system was mainly created with the thoughts on Fort Sport maps…


                            hey Crusha, how it going? So this means we could make a countdown node in ONS? I'm getting the itch to make a map for 2k4 ONS, would you want to team up on a project like we did before? This project would have a countdown node in it that would damage the enemy core if a team holds it for a minute or so.

                            The idea I have is to make a "container city" themed map as in this upcoming game:

                            I already made a map for UT3 with this theme but seeing as UT3 is pretty dead I would at least like to work on a map that will get some play. Here is my UT3 map:


                            I'm not saying I want to port that map but expand on the idea. I havent started anything in 2k4 editor yet but I may be laying some BSP down soon.

                            Another idea I have is to make some custom textures that have a bump map effect faked. Not sure if this idea will work out or not.

                            let me know


                              Yeah, I got a bit stuck in the development when I created maps again and when I started to collect the tools from other mappers and include them here.

                              I won't release anything separate from the package, so you will need to wait until the next version is finished before you can use it. (Although I would like to use some of them already in my maps, but I wait till the end.)

                              So this is the current development status:
                              -I coded many stuff in the last months without testing it. In theory it should work fine, but you never know what happens at runtime then and I didn't test any of the actors in netplay yet.
                              -Can't really compile it yet because some thing are only halfway finished, so the test needs to wait.
                              -The hardest thing I am currently at is to show the location of chosen vehicles of the UltimateONSFactory on the radar. That requires a custom linked list of ReplicationInfos, a "MasterActor" that handles the procedure of adding and removing ReplicationInfos from that linked list, special parameters in the UltimateVehicleFactory and a custom HUDOverlay that draws the vehicles on the radar according to the ReplicationInfos.
                              Most of that is done (in theory), I now just need to get the HUDOverlay to use those ReplicationInfos. I used code from the TeamRadar mutator and changed it a bit, but that thing is huge and I took only that what I thought was necessary, so I hope it works afterwards.
                              -I probably need to create a fancy HUDOverlay for the CountdownEventGate to give the mapper more control over the position of the countdown in the HUD. But I am pretty used to HUDOverlays in the meanwhile, my only worry is that it might not be good for the performance if I have so many actors that use HUDOverlays…
                              -Not done yet are:
                              *LinksetupChanger, which changes the Linksetup at runtime to a specified one when being triggered.
                              *UltimateWeaponLocker, although I am not exactly sure about what this thing should do actually. I think it should be able to remove the old inventory completely, to work only for a specified team (like TeamspecificWeaponLocker), to be able to triggered 'off' (invisible and no collision) and to always refill to the ammo amount that you get with a new weapon and not the extra ammo.
                              *UltimateONSPowerNode (or DirectionalONSPowerNode), which chooses the correct location of NodeShield and NodeSphere and NodeHealEffect depending on the rotation of the Node and not only changing the rotation of these things. That way you shall be able to get the Node to work properly also when it's upside down or something like that. And you can specify the height in which the NodeSphere should be, so that it doesn't get stuck in solid BSP.
                              Of course I would prefer to have the ability to make the Node an independent one, but I have no clue how that should be done right now because the whole Linksetup process in ONS is **** complicated. Any help with this is appreciated.
                              *UltimateVCTFFactory, which is pretty similar to the UltimateONSFactory, but that has only the things needed in VCTF and maybe some more features like being able to track the vehicle on the HUD that is used by the flag carrier.

                              -I also want to include some more tools from JBToolbox2, so I will wait for Wormbo to release it.

                              -And of course do I need to provide a good documentation to the toolset, that's why I am currently writing one here:

                              It will be extended whenever I find some time and joy. It's by far not a final design and will be probably moved to UE2: namespace when it's done.