Animating text cycle in SwiftUI

I cannot fully reproduce your situation, but from what I can derive from your code, the following code could be helpful.

You are using a ZStack with opacities. Why not using a switch with an enum that contains all the views and switches between them as some time goes by?

Try the following sample code:

struct TestView: View {
    
    enum ViewState: CaseIterable {
        case splash1
        case splash2
        case splash3
        case home
        
        mutating func next() {
            let allCases = type(of: self).allCases
            self = allCases[(allCases.firstIndex(of: self)! + 1) % allCases.count]
        }
    }
    
    @State var currentSplashView: ViewState = .splash1
    
    var body: some View {
        
        VStack {
            switch self.currentSplashView {
            case .splash1:
                Text("1")
                // setupScreen1()
            case .splash2:
                Text("2")
                // setupScreen2()
            case .splash3:
                Text("3")
                // setupScreen3()
            case .home:
                Text("home")
                // homescreen()
            }
        }
        .onAppear {
            Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { timer in
                self.currentSplashView.next()
                if self.currentSplashView == .home {
                    timer.invalidate()
                }
            }
        }
    }
}

The enum holds the current View that is to de displayed. The .onAppear{} manages the state changes in the variable currentSplashView. The switch in the VStack finally switches between the different views. Once the Home view has been reached, the timer is invalidated and stays on the homeview. (You can change the amount of time to go by in the Timer)

Once this whole view is reloaded, the timer starts again and the views are all individually displayed again. When you 'reset' the app, you could destroy and instantiate this structure.

To animate the transitions between the views, wrap 'self.currentSplashView.next()' in a withAnimation{} block.

Added

Since you want some other structure and decouple the splash from the home, try the following structure for your app:

@main
struct YourAppName: App {

    var body: some Scene {
        WindowGroup {
            ViewRouter(currentView: .splash) // <---- you can determine if you want to show splash or go to home immediately
        }
    }
}

enum Views {
    case home
    case settings
    case splash
}

struct ViewRouter: View {
    
    @State var currentView: Views

    var body: some View {
        
        VStack {
            switch self.currentView {
            case .home:
                HomeView(currentView: self.$currentView)
            case .settings:
                Settings(currentView: self.$currentView) // <---- in this view reset the app
            case .splash:
                SplashView(currentView: self.$currentView) // <--- this is the view I created earlier. Remove the .home case from that view, we move home 1 level up in the hierarchy (watch the changes closely)
            }
        }
    }
}

struct HomeView: View {

    @Binding var currentView: Views

    var body: some View {
        
        VStack {
            
           Text("This is your home").font(.largeTitle)
            
            Button(action: {
                withAnimation {
                    self.currentView = .settings
                }
            }){
                Text("Go to settings")
            }

        }
    }
}

struct Settings: View {

    @Binding var currentView: Views

    var body: some View {
        
        VStack {
            
           Text("This is your settings").font(.largeTitle)
            
            Button(action: {
                withAnimation {
                    self.currentView = .splash
                }
            }){
                Text("Reset app") // go to start from app and star with splash
            }

        }
    }
}

struct SplashView: View {
    
    enum ViewState: CaseIterable {
        case splash1
        case splash2
        case splash3
        
        mutating func next() {
            let allCases = type(of: self).allCases
            self = allCases[(allCases.firstIndex(of: self)! + 1) % allCases.count]
        }
    }
    
    @Binding var currentView: Views
    @State var currentSplashView: ViewState = .splash1
    
    var body: some View {
        
        VStack {
            switch self.currentSplashView {
            case .splash1:
                Text("Splash 1").font(.largeTitle)
                // setupScreen1()
            case .splash2:
                Text("Splash 2").font(.largeTitle)
                // setupScreen2()
            case .splash3:
                Text("Splash 3").font(.largeTitle)
                // setupScreen3()
            }
        }
        .onAppear {
            Timer.scheduledTimer(withTimeInterval: 2, repeats: true) { timer in
                if self.currentSplashView == .splash3 {
                    timer.invalidate()
                    withAnimation {
                        self.currentView = .home // <---- when the last splash is reached, set the hierarchy to home
                    }
                }
                
                withAnimation {
                    self.currentSplashView.next()
                }
            }
        }
    }
}

In the future, if you have any other views that you want to reach without a NavigationView, just add these to the enum and the switch of the main hierarchy.