Error when trying to access another script?

Static makes it so a function can directly be called from the classReference without the need of an object for it to be called from (target).

A static function is common to all objects, just as is a static variable, hence there being no need for an object to call the function. You just use ClassName.FunctionName.

You could for example use a static variable for the time of day. Since everything in your game is at a specific time, and you can easily access it though let's say TimeClass.timeOfDay

In your example, if the attack function were static, all enemies from your world would go into attackmode, not just the one in that particular room. On top of that, since a static function does not belong to a specific object, you cannot just call animation and transform, as both get their respective components on an object the function belongs to (which again doesn't exist here, it being static). Hence your errors.

 public void Attack()
 {
 }

I recently started messing around with trying to find improved methods for activating functions from other scripts and how to call static functions.

Traditionally I would use something like this:

 //example of accessing another script to start boss battle music
 
 CameraScript otherObjectsScriptCamera = cameraObject.GetComponent<CameraScript>();
 otherObjectsScriptCamera.levelMusicFunction();
 

However this requires that you have a cameraObject declared for you script to access that object component, sort of annoying when you might have to do this kind of thing hundreds of times for various functions.

I recently discovered a new method which I'm considering replacing all the kind of stuff above with something like this instead:

 public class PlayerXPScript : MonoBehaviour 
 {
 
 //creates a script variable so that you can access static functions
 //I believe this is the exact type of thing you need to do for that error your posted
 public static PlayerXPScript XPInstance;
 
 //creates a function for other objects to access globally
 //this function just activates the real function but eliminates that error message you posted.
 public static void XPUpdateCall()
 {
 XPInstance.XPUpdateFunction();
 }
 
 //the actual function 
 void XPUpdateFunction()
 {
 //real function that can use non-static field, method, or properties 
 }
 
 }
 
 }

This set up allows you to bypass the errors "An object reference is required"

So in this example all enemies would be able to call the playerXPUpdateFunction with this:

 PlayerXPScript.XPUpdateCall();

Instead of:

 PlayerXPScript otherObjectsScriptXP = playerObject.GetComponent<PlayerXPScript>();
    
 otherObjectsScriptXP.XPUpdateFunction();
 

This also allows you to not use an object for each enemy to easily gather that component from the player.

I don't know why it took me so long to realize to try this, but from my understanding it should be a significant improvement allowing static functions to operate flawlessly by calling global static functions.

However, this is not really good for your specific problem because you want to call an individual monster not a global function.

For that I would suggest removing the static variable and accessing it like my first example. Although you could also set the trigger onto the enemy instead of the floor of the room. So when the the player is in a certain range of the enemy it calls the function. Not sure if that would work for your project though.

But hopefully this answer helps you a little, I'm still relatively new to programming so I am very interested to find better ways to handle this kind of stuff.

  //creates a script variable so that you can access static functions
     //I believe this is the exact type of thing you need to do for that error your posted
     public static PlayerXPScript XPInstance;
     
     //then you can do something like this to solve the XPInstance being null really sorry I forgot this info.
     
     void Start()
     {
         XPInstance = GetComponent<PlayerXPScript>();
     }

 PlayerXPScript.XPUpdateCall();
 

 //creates a function for other objects to access globally
 //this function just activates the real function but eli$$anonymous$$ates that error message you posted.
 public static void XPUpdateCall()
 {
 XPInstance.XPUpdateFunction();
 }
  
 //the actual function
 void XPUpdateFunction()
 {
 //allows you to use a wide variety of static variables even though called indirectly by another Objects Script.
 //calls other functions easily
 }