We The Brehs

import csv
import pandas

data = []
with open("weather_data.csv", "r") as file:
    data = file.readlines()


csv_data = []
with open("weather_data.csv", "r") as file:
    data = csv.reader(file)
    for row in data:
        print(row)

    temperatures = []
    for row in data:
        temperatures.append(temp[1])
   
    print(temperatures)

pandas_data = pandas.read_csv("weather_data.csv")
print(pandas_data)

print(pandas_data["temp"])

pd_to_dict = pandas_data.to_dict()
print(pd_to_dict)

print(pandas_data["temp"].to_list())

#challenge
avg = sum(pandas_data["temp"].to_list()) / len(pandas_data["temp"].to_list())
print(avg)

print(pandas_data["temp"].mean())

#challlenge
print(pandas_data["temp"].max())


print(pandas_data["condition"])
print(pandas_data.condition)
print(pandas_data[pandas_data.day == "Monday"])

#challenge
print(pandas_data[pandas_data.temp == pandas_data.temp.max()])

monday = pandas_data[pandas_data.day == "Monday"]
print(monday.condition)

#challenge
print(int(monday.temp) * (9/5) + 32)

data_dict = {
    "students": ["Amy", "James", "Angela"],
    "scores": [76, 56, 85]
}

scratch_data = pandas.DataFrame(data_dict)
scratch_data.to_csv("scratch_data.csv")

#challenge
squirrel_data = pandas.read_csv("2018_Central_Park_Squirrel_Census_-_Squirrel_Data.csv")
grey_squirrels = squirrel_data[squirrel_data["Primary Fur Color"] == "Gray"]
red_squirrels = squirrel_data[squirrel_data["Primary Fur Color"] == "Cinnamon"]
black_squirrels = squirrel_data[squirrel_data["Primary Fur Color"] == "Black"]
grey_count = len(grey_squirrels["Primary Fur Color"].to_list())
red_count = len(red_squirrels["Primary Fur Color"].to_list())
black_count = len(black_squirrels["Primary Fur Color"].to_list())

squirrel_dict = {
    "Fur Count": ["grey", "red", "black"],
    "Count": [grey_count, red_count, black_count]
}

squirrel_dataFrames = pandas.DataFrame(squirrel_dict)
squirrel_dataFrames.to_csv("squirrel_data.csv")

import turtle

screen = turtle.Screen()
screen.title("U.S. States Game")
image = "blank_states_img.gif"
screen.addshape(image)
turtle.shape(image)

#def get_mouse_click_coord(x, y):
#    print(x, y)

#turtle.onscreenclick(get_mouse_click_coord)

# Don't need screen.exitonclick() if you have this
#turtle.mainloop()

state_data = pandas.read_csv("50_states.csv")
states = state_data.state.to_list()
guessed_states = []

while len(guessed_states) < 50:
    guessed = len(guessed_states)
    answer_state = screen.textinput(str(guessed) + "/50 States Guessed Correct", "What's the another state's name?").title()
    if answer_state == "Exit":
        break

    state = state_data[state_data.state == answer_state]

    if answer_state in states:
        if answer_state not in guessed_states:
            guessed_states.append(answer_state)
       
        t = turtle.Turtle()
        t.hideturtle()
        t.penup()
        state = state_data[state_data.state == answer_state]
        print(state)
        x = state.x
        y = state.y
        t.goto(int(x), int(y))
        t.write(state.state.item())

screen.exitonclick()

missing_states = []
for missing_state in states:
    if missing_state not in guessed_states:
        missing_states.append(missing_state)
missing_csv = pandas.DataFrame(missing_states)
missing_csv.to_csv("states_to_learn.csv")

#folderpath = "/Users/Another One/source/repos/Day24/d24folder/TestText.txt"
folderpath = "./d24folder/TestText.txt"


file = open(folderpath)
contents = file.read()
print(contents)
file.close()

with open(folderpath) as file:
    contents = file.read()
    print(contents)


with open(folderpath, mode="a+") as file:
    file.write("\n3929")
    # move file pointer back to beginning
    file.seek(0)
    contents = file.read()
    print(contents)

#Main.py
from Game import Game

new_game = Game()
new_game.game_loop()
new_game.exit_game()

#Game.py

from turtle import Turtle, Screen
from Snake import Snake
from Food import Food
from Scoreboard import Scoreboard
import time

class Game:
   
    def __init__(self):
        self.snake = Snake()
        self.food = Food()
        self.scoreboard = Scoreboard()
        self.game_over = False
        self.screen = Screen()
        self.screen.listen()
        self.screen.tracer(0)

        self.screen.bgcolor("black")
        self.screen.title("My Snake Game")
        self.screen.setup(width=600, height=600)

        self.key_binding()
       
       

    def key_binding(self):
        self.screen.onkey(key="f", fun=self.snake.move_right)
        self.screen.onkey(key="s", fun=self.snake.move_left)
        self.screen.onkey(key="e", fun=self.snake.move_up)
        self.screen.onkey(key="d", fun=self.snake.move_down)


    def game_loop(self):
        while not self.game_over:
            self.screen.update()
            time.sleep(0.1)
            self.snake.move_snake()
       
            # add to score
            if self.snake.snake_parts[0].distance(self.food) < 15:
                self.food.refresh()
                self.snake.grow_snake()
                self.scoreboard.increase_score()
                self.scoreboard.show_score()

            # check collision with wall
            xcor = self.snake.head.xcor()
            ycor = self.snake.head.ycor()
            if xcor > 280 or xcor < -280 or ycor > 280 or ycor < -280:
                self.game_over = True
                self.scoreboard.show_gameover(doReset=True)

            # check collision with snake
            for part in self.snake.snake_parts:
                if part == self.snake.head:
                    pass
                elif self.snake.head.distance(part) < 10:
                    snake_dist = self.snake.head.distance(part)
                    self.game_over = True
                    self.scoreboard.show_gameover(doReset=True)
       

    def exit_game(self):
        self.screen.exitonclick()

#Snake.py

from turtle import Turtle

class Snake:

    def __init__(self):
        self.snake_parts = []
        self.create_snake()
        self.head = self.snake_parts[0]

    def create_snake(self):
        for _ in range(3):
            self.grow_snake()

    def grow_snake(self):
        x = len(self.snake_parts)
        part = Turtle("square")
        part.color("white")
        part.penup()
        xcor = part.xcor()
        part.goto(int(x + xcor), 0)
        x += 20
        self.snake_parts.append(part)
   

    def reset_snake(self):
        self.clear_snake()
        self.create_snake()
        self.head = self.snake_parts[0]

    def clear_snake(self):
        for part in self.snake_parts:
            part.clear()
        self.snake_parts.clear()


    def move_snake(self):
        snake_length = len(self.snake_parts) - 1
        for index in range(snake_length, 0, -1):
            if not index == 0:
                new_x = self.snake_parts[index - 1].xcor()
                new_y = self.snake_parts[index - 1].ycor()
                self.snake_parts[index].goto(new_x, new_y)
       
        self.snake_parts[0].forward(20)

    def move_up(self):
        self.snake_parts[0].setheading(90)

    def move_down(self):
        self.snake_parts[0].setheading(270)

    def move_left(self):
        self.snake_parts[0].setheading(180)

    def move_right(self):
        self.snake_parts[0].setheading(0)

from turtle import Turtle, Screen

class Scoreboard(Turtle):

    def __init__(self):
        super().__init__()
        self.title = "Score: "
        self.hstitle = "High Score: "
        self.score = 0
        self.highscore = 0
        self.get_last_highscore()
        self.penup()
        self.goto(0, 280)
        self.color("White")
        self.hideturtle()
        self.write_score()
       
    def set_highscore(self):
        if self.highscore <= self.score:
            self.highscore = self.score
            with open("HighScore.txt", mode="a+") as file:
                file.write(str(self.highscore))

    def increase_score(self):
        self.score += 1

    def show_score(self):
        self.clear()
        self.write_score()

    def write_score(self):
        score_str = self.title + str(self.score)
        highscore_str = self.hstitle + str(self.highscore)
        self.write(score_str + " " + highscore_str, False, "center", ("Arial", 12, "normal"))
   
    def reset_score(self):
        self.set_highscore()
        self.score = 0
        self.show_score()

    def show_gameover(self, doReset=False):
        if doReset:
            self.reset_score()
        else:
            self.penup()
            self.goto(0, 0)
            self.color("White")
            self.title = "Game Over"
            self.write(self.title, False, "center", ("Arial", 16, "normal"))

        self.set_highscore()

    def get_last_highscore(self):
        with open("HighScore.txt", mode="a+") as file:
            contents = file.read()
            if contents == '':
                self.highscore = 0
            else:
                self.highscore = int(contents)

letter_lines = []   
with open("./input/letters/starting_letter.txt") as file:
    letter_lines = file.readlines()

invited_names = []
with open("./input/names/invited_names.txt") as file:
    invited_names = file.readlines()

original_greeting = letter_lines[0]
for name in invited_names:
    greeting = letter_lines[0]
    named_greeting = greeting.replace("[name]", name.strip())
    letter_lines[0] = named_greeting

    with open("./output/readytosend/" + name.strip() + ".txt", "w") as file:
        file.writelines(letter_lines)

    letter_lines[0] = original_greeting