On the other hand there's a good reason why Perl has that many operators.

And, not, or won't bite you in Boolean expressions because they have the lowest precedence. (But I use brackets when combining them, I need a complicated mnemonic to remember that and has higher precedence than or)

And !~ is really underused.

# X is the "default action"

# do X with an exception that when A,B and C are all false
# then don't do X

unless (!A and !B and !C) {X}

# if anybody is true then they all can't be false
# so we do X unless anybody is true (meaning they
# can't all be false)

unless (A or B or C) {X}
-------

unless ( (!($args =~ /\-rs(\s+)(\S+)/)) && 
         (!($args =~ /\-p(\s+)(\S+)/))  && 
         (!($args =~ /\-P(\s+)(\S+)/))     ) 
   {.....

# I figure this is easier to understand:

unless ( $args =~ /\-rs(\s+)(\S+)/ or 
         $args =~ /\-p(\s+)(\S+)/  or 
         $args =~ /\-P(\s+)(\S+)/     ) 
   {....
[download]

If you break a condition like that over multiple lines (and for a complicated or long condition I recommend it) put the operators at the front of the lines so they don't get "lost" at the back:

if (  $args =~ /\-rs(\s+)(\S+)/
   || $args =~ /\-p(\s+)(\S+)/
   || $args =~ /\-P(\s+)(\S+)/
   )
[download]

Optimising for fewest key strokes only makes sense transmitting to Pluto or beyond

Actually, I like that better.
As I remember, a senior Monk yelled at me once when I posted something like that. But yes this is the way that I would do it in my code. I didn't want to get into an argument that detracts from the main point.
Update: As I remember the argument against this was like "injecting spacing like that is bad because it is manually done and IDE's don't do it that way". BS. The compiler doesn't give a darn about spaces. Whitespace is added to help the humans. If it helps the humans, it is a good idea.

Also you can waste one line of code for making first conditional to have the same line-format as others:

if( not 0
   || $args =~ /\-rs(\s+)(\S+)/x
#  || $args =~ /\-? (\s+)(\S+)/x
   || $args =~ /\-p (\s+)(\S+)/x
   || $args =~ /\-P (\s+)(\S+)/x
   ){ ... }
[download]

...or equivalently inside regex:

if( $args !~ / (*FAIL)
   | \-rs(\s+)(\S+) 
#  | \-? (\s+)(\S+)
   | \-P (\s+)(\S+)
   | \-p (\s+)(\S+)
   /x ){ ... }
[download]

edit: not equivalently, because there are 8 capturing groups instead of 2 :)

Of course regex can be simplyfied as AnomalousMonk have shown here Re: regex return true instead of false.