idiot | Idiot is an OS X tool for reminding you not to be

If I understand, here is one way to do it:

• Read in the two tables
• split the Export table state abbreviations into ROWS
• Join with the StateName Table
• Group by Name and Company
• Extract a delimited list of the state names from each subtable
• Expand that list

Please read the code comments and explore the Applied Steps to better understand what is going on

I think you should be able to leverage the .NET PhysicalAddress Class for this. You can create a function to parse the user's input:

Maybe you could try something like this

You can create different scriptable objects for different enemies and set values for them like this:

Think you're missing a using line:

Let's create an interface for service data structure:

Not sure if anyone else is ever likely to see this issue because it really was my own stupidity, but I fixed it. It turns out that the Z axis is also important when considering tiles; I modified my line of code that places each tile to read as follows:

To understand this, you best use a debugger. To use a debugger, you need an IDE that has one, e.g. PyCharm. The screenshots in this question are from PyCharm. Other IDEs (like Visual Studio Code) will differ in usability but the concept will be the same.

When debugging, you set breakpoints, typically by clicking on the left of the line of code, e.g. like so:

With breakpoints enabled, you use the Bug icon instead of the Play icon.

The flow of execution will stop whenever the code hits a line with a breakpoint. You can then choose how to go on using these icons:

• Step over this line of code
• Step into this line (if there's a method call)
• Step into (my code)
• Step out (run the function until the end)
• Run to cursor

In your case, let's set a breakpoint on line 24. In this case I chose it, because it's the beginning of a recursion. However, I doubt that you have heard that term before. Without knowing it, it'll be hard to find a good line. Finding a good line for a breakpoint is a skill that develops over time.

Next, enter whatever is needed to reproduce the problem. On my machine, it looks like this:

Now, the breakpoint is hit and interesting stuff will happen.

Before that interesing stuff happens, let's look at the state of your program. As we have the call stack frames and variables:

One important thing to notice: your code is currently running line 31 (the actual method call) and while running that line, it is now running line 24.

Now click the "Step into" button once. Note how the call stack changed and all variables seem to be lost.

We see that the same method ("question1") is called again. That's what programmers call a recursion.

Also: the variables are not lost, they are just "local" to that method. If you select the method from before, the variables will still be there:

Now, click "Step over" a few times, until you're asked for input again.

Enter "yes" as you did before.

Then, click "Step over" once. You are inside if guess == secret_word: at the print statement now.

Then, click "Step over" once. The text was printed and you are at the while loop.

In the next step, the condition guess != secret_word will no longer be met and the code will continue after the while loop, which is where the method ends.

Hitting "Step over" one more time will bring you back to where the method was before, your code has left the recursion:

Your code is back in line 24, within the while loop that asks you if you want to start over again.

Now that you understand what your code does, it should be possible to find a fix.

Typically it's not the computer who doesn't understand your code. It's you who doesn't understand your code :-)

A debugger will help you understanding what you told the computer. If there is a method on the call stack, then you called that method. Cool thing: you can look at each method and their variables and that'll allow you to make conclusions on how it arrived there.

Even cooler: you could change the values of these variables in order to play a "what-if" scenario.

IMHO, real debugging is more powerful than printf debugging (but still, a log file is an important concept of its own).

1. Go to Google Cloud Console

2. Go to IAM & Admin
   

3. Click on ADD, and in New principals add firebase-storage@system.gserviceaccount.com and set the Role as Storage Admin and click Save
   

4. Wait for few minutes, then problem should be solved