Patrol Points (PPs), what they are and how they work

(G0-Gerbil) #1

http://theburrow.fragland.net/forums/viewtopic.php?t=132

Some more work to go into them, as well as the graphics I’ll be using (to make them standardised and easy to implement), but it’s a start :slight_smile:

(seven_dc) #2

Awesome. This is a cool idea. I would like to see some prefabs on this one for easy and painless implementation!

Chevrolet corvair engine specifications

(Drakir) #3

This is a great idea!
Kinda like the way i handled the forward spawn in Navarone, Making it permanenlty owned after 2 minutes.
Could be used for a territorial map, if one team owns a certain area for an ammount of time then it falls into their hands permanent. Best out of 7 territorys win.

(G0-Gerbil) #4

Well, it’s much more than just a flag - I’ve laid out the code so that you can do anything you want with them.
I’ll be working on some prefabs and textures to go with them - they need an effort in-game to be clear on what they are, and it would help if they all used the same graphics / style (or similar at least).
Next few days, hopefully.

Possibly also a script re-write - first ti take into account the trigger accum thingy which might help simplify the code, and secondly to put in relevant messages (eg letting the correct class etc know when it’s in, and when it’s got X seconds left to go etc).

(G0-Gerbil) #5

Also, the main problem with prefabs as such is there’s a million different permutations - off the top of my head you only need 4 entities to make it all work, and that’s covered in my tutorial. Prefabs only help with the entity side which is simplicity itself - you still have to script what you want to happen.

(G0-Gerbil) #6

I’m working on updating them as I’ve fitted them into my own maps.
Extended their functionality as well as done a few test setups for some better notifications (in the current script I exampled with wm_announces, which is a bit annoying - now they only do specific team / player messages).
Also created some standardised textures / shaders so implementing them in a recognisable way should be simple.
Expect an update in the next day or two with new script and textures / prefabs etc.

Here’s a sample of all available team / class icons as well as the boundary markers - the observant will note I stole the icons direct from the limbo screen so they should be pretty easy to work out which is which. Blue = allies only, red = axis only:

(nUllSkillZ) #7

Great idea. Have you seen maps with this functionallity so far?
Question:
Is it possible to open doors that way?
(Although I’m not a mapper/scripter I’ve had the following idea:
The attacking team has to open a door with the help of a patrol point.
This PP is in front of the door but in some distance.
If one player of the attacking team reaches the door it will open.
But the distance between the PP and door must be so big that the door will be closed before this player would reach the door (even if the player would be sprinting).
So one player is needed to open the door and to keep it open while other players will go through the door.)

(G0-Gerbil) #8

Great idea. Have you seen maps with this functionallity so far?

Well, erm no, I came up with the idea myself - if anyone can claim to have done something new using old tools :slight_smile:
As for whether you could open a door this way, then yes, very simply indeed.
I’ve set up the scripting for PPs to be as simple as possible - while there’s actually a lot of script (more so now I’ve tweaked it), the bits you need to worry about are very simple and clearly marked, eg for your door, you’d presumably want a very quick activation time (1 second, IE virtually immediately), and a very quick ‘death’ time (no more than a couple of seconds). Here’s the bits you need to tweak to achieve the triggering:

//////////////////////////////////////////////////////////////// 
   // How long you must be in the PP to enable it 
   // Note this is MEANT to use same accum as trigger disabletime 
   trigger enabletime 
   { 
      accum 2 set 1 
   } 
   //////////////////////////////////////////////////////////////// 
   // How long the PP must be unattended for to disable 
   // Note this is MEANT to use same accum as trigger enabletime 
   trigger disabletime 
   { 
      accum 2 set 2
   } 
   //////////////////////////////////////////////////////////////// 
   // Whether 'keep alive' is enabled [0 = disabled, 1 = enabled] 
   trigger keepalive 
   { 
      accum 4 set 1 
   } 
   //////////////////////////////////////////////////////////////// 
   // Number of times PP can be used [-1 = infinite, 0 = never, >0 = number of times] 
   trigger reusable 
   { 
      accum 5 set -1 
   } 
   //////////////////////////////////////////////////////////////// 
   // This is where you put anything you want to happen when the PP is enabled 
   trigger enable 
   { 
      // script to open door, probably just rotate the script_mover door
   } 
   //////////////////////////////////////////////////////////////// 
   // This is where you put anything you want to happen when the PP is disabled 
   // Usually you'd cancel whatever happened when the PP was enabled 
   trigger disable 
   { 
      // script to close the door, probably just rotating the script_mover door
   }

You’d want keep alive enabled, (so the door stays open while someone is in the PP) and you’d want unlimited uses - these are set up as above.
Note that’s not all the script (but you arne’t supposed to change any of the rest) - check out the tutorial link at top for full details and how to set up the entities (which is pretty simple).

(nUllSkillZ) #9

Thanks a lot. Sounds great.
I’ve seen your forum side with the example script-code some times before.
I will try mapping soon. And if I will get better I will try using PP’s.

(kevinski) #10

Isn’t this basically similar to King of the Hill maps in principle?

Anyway, I realize that this may be a bit off-topic, but it’d be cool to create some sort of mod that really put this feature to work. For instance, let’s say that someone wanted to create some sort of multiplayer stealth mod. Defending players would be restricted to a certain area, their paths blocked by imaginary barriers that only appeared on-screen in order to show their patrol routes. Upon an intruder being spotted, the patrol area for each defending player would become an alert area, which would be much larger.

The offensive team must remain out of enemy sight for fifteen seconds in order for these alert areas to become patrol areas again. Once the patrol areas became active again, defending players must return to their respective patrol areas within a certain period of time or risk being shot by their own numbers. (Kinda like leaving the battle area in Battlefield 1942.)

It all has a very Metal Gear Solid-ish sound to it.

(G0-Gerbil) #11

Isn’t this basically similar to King of the Hill maps in principle?

Depends, king of the hill is a capture and hold flag, PPs can be used for whatever you want. For example to create spawns, unlock health cabinets, give instant respawns, increase charge speed etc. Since the interaction with your bits of the levels are purely scripted (you just write into the functions I’ve already created for the purposes) absolutely anything you want can be done. Although their uses in Helmsdeep won’t be particularly inspiring, as I use them more (most likely in minas tirith) their use will get varied (eg field op PP rains mortar fire down on specific areas etc).

I like your idea :slight_smile:
It made me think about PPs a bit differently - usually I think of (say) an allied PP either giving allies an advantage, or axis a disadvantage.
But if you make invisible PPs, then when say axis triggers it, unbeknownst to them, their location shows up on an allied map - IE they could be used as motion sensors or something similar. In other words, one team could have a control room with a map of the level, and dots appear on it where the enemy triggers hidden PPs. Of course, for this you wouldn’t need the full blown PP, you could do it a bit simpler yourself but would probably need essentially the same core code to switch thing off.
Better yet, you could make these enemy detectors buildable and destroyable, so it’d be like the classic ‘sneak into a building and destroy it’s security cameras to get in unseen’. You’d need a WW2 analogy of course!

(kevinski) #12

Good idea. :slight_smile:

(G0-Gerbil) #13

another idea would be for simple atmospherics, that doubles as a kind of ‘alert’.
You could stick one of these hidden PPs in on terrain (say deep in foliage) and when the enemy goes in it it sends a flock of birds up (as if they disturbed it), giving away their position :slight_smile:

(G0-Gerbil) #14

Just out of curiousity - who has tried these in MML Helmsdeep A2, and what are people’s thoughts?
I’m interested on comments on the mechanism, as opposed to the actual rewards (I’ll be upping them massively for A3, to make them more than a novelty, certainly for Allies).
Are they clear enough how to be used, marked clearly enough etc?

(nUllSkillZ) #15

Hi,

I have just re-read the thread Patrol Points (PPs), what they are and how they work in your forum.
You have posted that you have re-written the script.
Is the script in the first post up-to-date?

And another question.
Is it possible to download the textures that can be seen in the picture?

As you have mentioned, would be great to have all of these as some kind of “prefab”.
Because then it can be taken as some kind of standard.

Thank you very much in advance.

(nUllSkillZ) #16

I’ve just re-written some minor parts of your script-code.
Now it uses only 3 accum’s instead of 5.
I have achieved this by using the bit’s of one accum.
I haven’t tested if this script is working.
And hopefully I haven’t made any mistakes.

EDIT:
Another idea:
If you do not limit access (accum 5) PP’s can be done by using only 2 accum’s.
/EDIT

EDIT1
Sorry guys:
As far as accum’s can store 32 bit:
1 globalaccum per 10 PP’s + 1 accum per PP
Should use my brain before posting :bash:
/EDIT1

Source with comments:


// originally used accums:
// accum 1 // yes / no
// accum 2 // int
// accum 3 // yes / no
// accum 4 // yes / no
// accum 5 // int

// new:
// accum 1 = accum 1 bit 1
// accum 3 = accum 1 bit 3
// accum 4 = accum 1 bit 4
// accum 2 // int
// accum 5 // int

// syntax ( http://www.planetquake.com/simland/ldr1_1/appendix_a.htm )
//(global)accum <buffer_index> <command> <<paramater...> 
//(global)accum <n> bitset <m>
//(global)accum <n> bitreset <m>
//(global)accum <n> abort_if_bitset <m>
//(global)accum <n> abort_if_not_bitset <m>

// abort_if_not_equal 0 = abort_if_equal 1 = abort_if_bitset
// abort_if_not_equal 1 =                  = abort_if_not_bitset


//////////////////////////////////////////////////////////////////////// 
<name> 
{ 
   ///////////////////////////// 
   // User modifiable scripts // 
   ///////////////////////////// 

   //////////////////////////////////////////////////////////////// 
   // How long you must be in the PP to enable it 
   // Note this is MEANT to use same accum as trigger disabletime 
   trigger enabletime 
   { 
      accum 2 set 10 
   } 
   //////////////////////////////////////////////////////////////// 
   // How long the PP must be unattended for to disable 
   // Note this is MEANT to use same accum as trigger enabletime 
   trigger disabletime 
   { 
      accum 2 set 60 
   } 
   //////////////////////////////////////////////////////////////// 
   // Whether 'keep alive' is enabled [0 = disabled, 1 = enabled] 
   trigger keepalive 
   { 
      //accum 4 set 1 
      accum 1 bitset 4 // bit 4 (of accum 1) is set to 1
   } 
   //////////////////////////////////////////////////////////////// 
   // Number of times PP can be used [-1 = infinite, 0 = never, >0 = number of times] 
   trigger reusable 
   { 
      accum 5 set -1 
   } 
   //////////////////////////////////////////////////////////////// 
   // This is where you put anything you want to happen when the PP is enabled 
   trigger enable 
   { 
      wm_announce "Patrol point was activated!" 
   } 
   //////////////////////////////////////////////////////////////// 
   // This is where you put anything you want to happen when the PP is disabled 
   // Usually you'd cancel whatever happened when the PP was enabled 
   trigger disable 
   { 
      wm_announce "Patrol point was deactivated!" 
   } 
   //////////////////////////////////////////////////////////////// 
   // This is called after 'disable' for the last use of the patrol point 
   // Only relevant if you have given it a limited number of uses 
   trigger nomoreuses 
   { 
      wm_announce "Patrol point cannot be used any more!" 
   } 
   //////////////////////////////////////////////////////////////// 

   //////////////////////////// 
   // Non-modifiable scripts // 
   //////////////////////////// 

   // Called when object is spawned 
   spawn 
   { 
      //accum 1 set 0      // PP state: [0 = disabled, 1 = enabled] 
      accum 1 bitreset 1 // bit 1 (of accum 1) is set to 0
      trigger self enabletime   // (accum 2) Timer: 
               //   When PP state = 0 then is time remaining until PP is enabled 
               //   When PP state = 1 then is time remaining until PP is disabled 
      //accum 3 set 0      // PP trigger state: [0 = not used, 1 = used] 
      accum 1 bitreset 3 // bit 3 of (accum 1) is set to 0
      trigger self keepalive  // (accum 4) PP 'keep alive' option: [0 = disabled, 1 = enabled] 
      trigger self reusable   // (accum 5) Reusable option [-1 = infinite, 0 = never, >0 = number of times] 

   } 

   // Called when player is inside PP trigger 
   trigger in 
   { 
      //accum 3 set 1      // Mark as used this time 
      accum 1 bitset 3 // bit 3 (of accum 1) is set to 1
   } 

   // Called once a second to see if PP trigger is in use 
   // Used to control whether PP should be activated, deactivated, or kept alive 
   trigger check 
   { 
      // General PP control 
      trigger self incheck 
      trigger self outcheck 

      //accum 3 set 0         // Reset PP trigger flag 
      accum 1 bitreset 3 // bit 3 (of accum 1) is set to 0
   } 

   trigger incheck 
   { 
      //accum 3 abort_if_not_equal 1   // Only continue if inside trigger 
      accum 1 abort_if_not_bitset 3 // aborts if bit 3 (of accum 1) is not 1
      accum 2 inc -1         // Count down time remaining until something happens 

      // Process depending on whether PP is enabled or not? 
      trigger self inenabledcheck 
      trigger self indisabledcheck 
   } 

   trigger outcheck 
   { 
      //accum 3 abort_if_not_equal 0   // Only continue if inside trigger 
      accum 1 abort_if_bitset 3 //aborts if bit 3 (of accum 1) is 1 (<> 0)

      // Process depending on whether PP is enabled or not? 
      trigger self outenabledcheck 
      trigger self outdisabledcheck 
   } 

   trigger inenabledcheck 
   { 
      //accum 1 abort_if_not_equal 1      // Only continue if  PP is enabled 
      accum 1 abort_if_not_bitset 1 // aborts if bit 1 (of accum 1) is not 1
      trigger self inenabledkeepalive      // React if using keep alive 
      trigger self inenablednokeepalive   // React if not using keep alive 

   } 

   trigger inenabledkeepalive 
   { 
      //accum 4 abort_if_not_equal 1   // Only continue if using 'keep alive' 
      accum 1 abort_if_not_bitset 4 // aborts if bit 4 (of accum 1) is not 1
      trigger self disabletime   // Reset timer 
   } 

   trigger inenablednokeepalive 
   { 
      //accum 4 abort_if_not_equal 0   // Only continue if not using 'keep alive' 
      accum 1 abort_if_bitset 4 // aborts if bit 4 (of accum 1) is 1 (<> 0)
      accum 2 abort_if_greater_than 0   // Continue only if PP has been enabled for full time 
      trigger self disableevent   // Sets off the disabling of the PP 
   } 

   trigger indisabledcheck 
   { 
      //accum 1 abort_if_not_equal 0   // Only continue if PP is disabled 
      accum 1 abort_if_bitset 1 // aborts if bit 1 (of accum 1) is 1 (<> 0)
      accum 2 abort_if_greater_than 0   // Continue only if PP trigger has been used for long enough 
      accum 5 abort_if_equal 0   // Check whether this can be used any more times 
      //accum 1 set 1         // Mark PP as in use now 
      accum 1 bitset 1 // bit 1 (of accum 1) is set to  1
      trigger self disabletime   // Reset counter for time to disable 
      trigger self enable      // Enable whatever effect this PP has 
      accum 5 abort_if_less_than 1   // Only continue if there is a positive amount of uses left 
      accum 5 inc -1         // Count down number of times can be used 
   } 

   trigger outenabledcheck 
   { 
      //accum 1 abort_if_not_equal 1   // Only continue if PP is enabled 
      accum 1 abort_if_not_bitset 1 // aborts if bit 1 (of accum 1) is not 1
      accum 2 inc -1         // Decrement PP timer 
      accum 2 abort_if_greater_than 0   // Stop if timer is greater than 0 
      trigger self disableevent   // Sets off the disabling of the PP 
   } 

   trigger outdisabledcheck 
   { 
      //accum 1 abort_if_not_equal 0   // Only continue if PP is disabled 
      accum 1 abort_if_bitset 1 // aborts if bit 1 (of accum 1) is 1 (<> 0)
      trigger self enabletime      // Reset timer 
   } 

   trigger disableevent 
   { 
      //accum 1 set 0         // Mark PP as not in use now 
      accum 1 bitreset 1 // bit 1 (of accum 1) is set to 0
      trigger self enabletime      // Reset counter for time to enable 
      trigger self disable      // Disable whatever effect this PP has 
      accum 5 abort_if_not_equal 0   // Only continue if PP cannot be used any more times 
      trigger self nomoreuses      // Reacts to no more PP uses 
   } 
}
(Chruker) #17 
  accum 1 bitset 4 // bit 4 (of accum 1) is set to 1

hmm, that’s a very helping comment you got there :slight_smile:

A better one would be ‘Set Keep Alive as enabled’

(Chruker) #18

Ohh, BTW I saw another game where you should stay by the flagpole in order to secure the area - kind of the same as PP.

(nUllSkillZ) #19

I want to keep it similar to the line I’ve commented out:


// accum 4                 set    1
//   bit 4 (of accum 1) is set to 1
(G0-Gerbil) #20

Heh having fun eh? :slight_smile:
I didn’t see the point in using bits - they are less intuitive than straight accums and there’s no reason to be worried about using too many (IE running out of) accums in a single PP object instance anyway. But still, cool :slight_smile:
Oops - thought I’d posted the prefab bit, will do so now, and also llist the updated script. I’ll mirror it here when done.
The way they work is slightly more complicated now to allow for better notifications.