Architecture for a turn based game

Hello again. I would like your opinion on an issue that has been troubling me for about a week.

I'm building a turn based game for unity but I've been running into some problems trying to find the correct code architecture to implement it. It roughly works like this:

1. Player starts his turn

2. Pre-turn calculations get done

3. A unit is activated

4. the player chooses the skill for that unit to use

5. the game runs a simulation and figures out which enemy units will see the current unit (if he tells the unit to run around a corner, enemies might see it)

6. the enemy units react and choose what to do

7. the "order" is executed and it's effects are applied (enemies shoot the player's unit, etc)

8. Player continues selecting units until his turn ends

9. repeat for another player

This is meant to later be used for multi player so I can't combine 6 and 7 for instance (the opponent decides how his own units react)

Each skill has a different way to handle the GUI: move asks the player to click and setup the unit's path, shoot asks him to click an enemy unit and choose what to use against it, so I created a GameGUI class which calls a "ProcessSkill" method unique to every skill.

Here's where it gets complicated: since I have coroutines to handle the turn structure and GameGUI using it's OnGUI method to handle steps 3,4 and 6 it's a synchronization nightmare.

was actually a bug, ignore this-->(Not to mention I'm starting to experiment with step 5 and coroutine is really weird with movement speed for some reason compared to a regular Update method.)

Does the Unity answers community have any tips on this? I'm a lot more used to linear programming where this isn't an issue...

I could post code snippets but I feel this post is already too long.

Edit: here we go:

This is what I put in GameGUI. It handles all GUI drawing:

 public void OnGUI(){
         
         GUI.TextField(new Rect(Screen.width-80,Screen.height-60,80f,20f),"Orders: "+GameLogic.instance.currentPlayer.numOrders);
         
         
         //If no order is pending, do what we usually do
         if(!GameLogic.instance.currentPlayer.ProcessOrder() ) {
             //Handle unit selection, etc
             MousePosition();
             
             if (!GameLogic.instance.currentPlayer.turnComplete) {
                 if (GUI.Button(new Rect(Screen.width-100,Screen.height-40,100,40),"End turn"))
                     GameLogic.instance.currentPlayer.turnComplete=true;
             }
         }
         
         //Display a help message (placeholder)
         GUI.TextField(new Rect(0,Screen.height-40,500,40),"Message: "+msg);
 }

ProcessOrder() calls the skill-dependant gui code. Here's what I'm using for Movement for instance:

 public override bool ProcessingSkill(Order cont) {
         
         
         if (pathComplete==false && remainingDistance>0) {
             
             if (GUI.Button(new Rect(Screen.width-100,Screen.height-40,100,40),"Finish")) {
                 pathComplete=true;
             }
             
             GameLogic.instance.movementRadius.GetComponent<MovementRadius>().CreateSingleCircle(
                 path.lastWaypoint.marker,
                 remainingDistance
             );
             
             
             WaypointAdding();
             
             return true;
             
         }
         else {
             pathComplete=true;
             GameLogic.instance.movementRadius.GetComponent<MovementRadius>().Disable();
             return false;
         }
 }

And this is how I handle the rest of the game logic. ManageGame is a Coroutine which begins at the start of the game

     IEnumerator ManageGame () {
         
         for(;;) { //insert win condition here or something
             Debug.Log("Turn cycle loop");
 
             foreach(Player p in playerList) {
                 currentPlayer=p;
                 
                 //Start our player loop, and wait for it to finish
                 //Before we continue.
                 yield return StartCoroutine(PlayerTurn(p));
             }
             
             //restart loop
 
         }
     }
     
     
     IEnumerator PlayerTurn(Player player) {
         player.ResetAndRecalculate();
         
         while (!player.turnComplete) {
             
             while (true/*player.activeOrder.complete==false*/) {
                 yield return null;    
             }
             
             yield return null;
             
         }
         
         yield break;
     }