Acceptable level of obfuscation for App Review

New member here, please be gentle :) I am getting ready for App Review for my first iOS app, and I am curious if ANY level of obfuscation is allowed? Say I had a drone controller App, I might have something like this:

struct Drone{
    var name : String
    var forwardVelocity : Double
    var lateralVelocity : Double
    var verticalVelocity : Double
    var receivedSignalStrength : Int
    var rssThreshhold : Int
    var gpsCoordinates : Data
    func reverseCourse(){
        //do a 180
        //...
    }
}

func onUpdateReceivedSignalStength(drone:Drone){
    if drone.receivedSignalStrength < drone.rssThreshhold{
        drone.reverseCourse()
    }
}

But I don't really want to make it easy for someone to pull the strings from the binaries and try and copy my work. I realize it's pretty much inevitable, but it seems sensible to protect my IP as much as I can. Is something like this acceptable?

struct D{ //obfuscated Drone
    var parameter1 : String //name
    var parameter2 : Double //forwardVelocity
    var parameter3 : Double //lateralVelocity
    var parameter4 : Double //verticalVelocity
    var parameter5 : Int //receivedSignalStength
    var parameter6 : Int //rssThreshhold
    var parameter7 : Data //gpsCoordinates
    func funcSeven(){
        //do a 180
        //...
    }
}

func funcSix(d:D){ //check if signal strength requires a course reversal
    if d.parameter5 < d.parameter6{ // signal strength less than threshhold
        d.funcSeven() //reverse course
    }
}

The comments make it clear what the similarly-named parameters are doing, and what the functions do. I fully understand that something like the below is a no-no, just writing it made my eyes bleed:

struct DDF{
    var SXR : String
    var KYV : Double
    var GTC : Double
    var DKY : Double
    var ENY : Int
    var WKN : Int
    var DJV : Data
    func BDO(){
        //do a 180
        //...
    }
}

func PUL(KHY:DDF){
    if KHY.ENY < KHY.WKN{
        KHY.BDO()
    }
}

Is there any level of IP protection through obscurity that is acceptable? I realize that the more genericized the variable and function names are, the harder it is to debug, but that might be an acceptable trade-off against IP protection.

To be clear, my app isn't anything to do with drones, this was just a vehicle to ask the question with. My code isn't currently at all obfuscated, everything is in clear terms, but I am wondering if I could/should obfuscate the critical parts before App Review and release?

The reason for my concern is that a key feature of the app is something very novel, and I have filed a patent application for it. The patent (if granted) won't be granted for 18-24 months, so anything I can do to protect the IP seems like the right thing to do.

As a complete newcomer to releasing Apps, I have no experience at all, so I would be grateful for any help/steers from those that do have experience in trying to protect their IP while not making life difficult for the App Review team.

Thanks in advance!

6502A