Hello there! Our adventure today takes us into the captivating realm of Kotlin programming — function scope. Think of Grandma's interspersed secret apple pie recipe in her diary. The recipe, akin to a function, guards a secret ingredient (a variable) that is confined within the recipe. Similarly, function scope refers to the specified section of the code where variables are defined and recognized. A variable declared inside a function, known as a local variable, exists only within that function.

Consider this example:

fun main() {
  fun printSecret() {
    val secretCode = "KOTLIN" // local variable
    println(secretCode) // This will work
  }
  printSecret()
  println(secretCode) // You'll get an error "Unresolved reference: secretCode"
}

In this scenario, secretCode is only defined within the printSecret function. This variable won't be recognized within the outer main function.

There are two types of scopes:

1. Local variable: This is akin to a green room for an actor, known only within the function where it is established.
2. Global Variable: This is equivalent to a celebrity recognized all over the world, declared outside all functions and visible to any function within the same program.

Here's an example showcasing both:

val globalCode = "GLOBAL_KOTLIN" // Global variable

fun main() {
  fun printCodes() {
    val localCode = "LOCAL_KOTLIN" // Local variable, can only be accessed inside the "printCodes" function
    println(localCode) // This works
    println(globalCode) // This works 
  }

  printCodes()
  println(localCode) // You'll get an error "Unresolved reference: localCode"
  println(globalCode) // This works 
}

This example shows that localCode can only be used inside printCodes function, whereas globalCode enjoys visibility throughout the program.

Variable shadowing in Kotlin occurs when a local variable in a more inner scope (like a function or a block) has the same name as a variable in an outer scope, effectively "hiding" the outer variable within the inner scope. This means that any reference to the variable name within the inner scope will refer to the inner variable, not the outer one. Shadowing allows for reuse of variable names but requires careful attention to avoid confusion and potential errors in the code's logic.

val playerName = "Alex" // Global variable

fun displayScore() {
    val playerName = "Jamie" // Local variable in displayScore, it's "hiding" the outer variable
    println("Score displayed for $playerName")
}

fun main() {
    displayScore()  // Outputs: Score displayed for Jamie
}