You are an experienced Python developer. Design a Python class called OptimizedGoalGenerator and implements a sophisticated goal generation system for an agent in a survival-crafting environment. The class should intelligently balance survival needs with long-term progression goals based on environmental observations.
The game rules are as follows:
collect:
  tree: {require: {}, receive: {wood: 1}, leaves: grass}
  stone: {require: {wood_pickaxe: 1}, receive: {stone: 1}, leaves: path}
  coal: {require: {wood_pickaxe: 1}, receive: {coal: 1}, leaves: path}
  iron: {require: {stone_pickaxe: 1}, receive: {iron: 1}, leaves: path}
  diamond: {require: {iron_pickaxe: 1}, receive: {diamond: 1}, leaves: path}
  water: {require: {}, receive: {drink: 1}, leaves: water}
  grass: {require: {}, receive: {sapling: 1}, probability: 0.1, leaves: grass}
  ripe_plant: {require: {}, receive: {food: 4}, leaves: plant}
  cow: {require: {}, receive: {food: 6}, leaves: none}  # Killing cows provides food

place:
  stone: {uses: {stone: 1}, where: [grass, path, water], type: material}
  table: {uses: {wood: 2}, where: [grass, path], type: material}
  furnace: {uses: {stone: 1}, where: [grass, path], type: material}  # Code shows only 1 stone needed
  plant: {uses: {sapling: 1}, where: [grass], type: object}

make:
  wood_pickaxe: {uses: {wood: 1}, nearby: [table], gives: 1}
  stone_pickaxe: {uses: {wood: 1, stone: 1}, nearby: [table], gives: 1}
  iron_pickaxe: {uses: {wood: 1, stone: 1, coal: 1, iron: 1}, nearby: [table, furnace], gives: 1}
  wood_sword: {uses: {wood: 1}, nearby: [table], gives: 1}
  stone_sword: {uses: {wood: 1, stone: 1}, nearby: [table], gives: 1}
  iron_sword: {uses: {wood: 1, stone: 1, coal: 1, iron: 1}, nearby: [table, furnace], gives: 1}

mobs:
  zombie: {health: 7, damage: 2, attack_cooldown: 5}  # Deals 7 damage when player sleeps, otherwise 2
  skeleton: {health: 5, damage: 2, attack_cooldown: 4}  # Arrow damage is 2
  cow: {health: 3, damage: 0}  # Cows don't attack

player:
  max_health: 9
  max_food: 9
  max_drink: 9
  max_energy: 9
  hunger_rate: 1.0  # Increases by 1 per hour when awake, 0.5 when sleeping
  thirst_rate: 1.0  # Increases by 1 per hour when awake, 0.5 when sleeping
  fatigue_rate: 1.0  # Increases by 1 per hour when awake, decreases by 1 when sleeping
  health_recover_rate: 1.0  # +1 per hour when all needs met, +2 when sleeping
  health_damage_rate: -1.0  # -1 per hour when needs not met, -0.5 when sleeping

achievements:
  - collect_coal
  - collect_diamond
  - collect_drink
  - collect_iron
  - collect_sapling
  - collect_stone
  - collect_wood
  - defeat_skeleton
  - defeat_zombie
  - eat_cow
  - eat_plant
  - make_iron_pickaxe
  - make_iron_sword
  - make_stone_pickaxe
  - make_stone_sword
  - make_wood_pickaxe
  - make_wood_sword
  - place_furnace
  - place_plant
  - place_stone
  - place_table
  - wake_up

The environment information is generated by the following code:
```python
 def render_craftax_text_describ_2(self, view_arr, index):
        (map_view, mob_map, inventory_values, status_values) = view_arr

        mob_id_to_name = ["zombie", "cows", "skeletons", "arrows"]
        block_id_to_name = ["invalid", "out of bounds", "grass", "water", "stone", "tree", "wood", "path", "coal",
                            "iron", "diamond", "crafting table", "furnace", "sand", "lava", "plant", "ripe plant"]

        text_view_values = set()

        block_names = np.vectorize(lambda x: block_id_to_name[x])(map_view[index])
        text_view_values.update(block_names.flatten())

        mob_ids = np.argmax(mob_map[index], axis=-1)
        mob_names = np.vectorize(lambda x: mob_id_to_name[x])(mob_ids)
        mob_mask = mob_map[index].max(axis=-1) > 0.5
        text_view_values.update(mob_names[mob_mask].flatten())
        text_view = ", ".join(text_view_values)

        inv_names = [
            "wood", "stone", "coal", "iron", "diamond", "sapling",
            "wood pickaxe", "stone pickaxe", "iron pickaxe",
            "wood sword", "stone sword", "iron sword"
        ]
        text_obs_inv = ", ".join([
            f"{name}: {value}"
            for name, value in zip(inv_names, inventory_values[index])
            if value > 0
        ])

        status_names = [
            "health", "Fullness", "Hydration", "Wakefulness", "\nSky brightness level"
        ]
        status = ", ".join([
            f"{name}: {int(value/0.09)}%"
            for name, value in zip(status_names, status_values[index])
        ])

        text_obs = "You see: " + text_view + "\nInventory: " + text_obs_inv + "\nStatus: " + status
        return text_obs
```
The state of environmental text is represented by  text_obs：
You see: plant, zombie, tree, grass, sand, path, stone
Inventory: wood: 1
Status: health: 11%, Fullness: 0%, Hydration: 0%, Wakefulness: 88%, Sky brightness level: 68%

You see: plant, tree, grass, path, stone
Inventory:
Status: health: 99%, Fullness: 77%, Hydration: 66%, Wakefulness: 77%, Sky brightness level: 99%

Expected Output Structure:
```python
class OptimizedGoalGenerator :
    def __init__(self):

 ...

    def determine_goal(self, text_obs):
        # Main decision-making method
        return best_goal

    def get_augmentation_more_goal_text(self, text_obs):
        # Return top 3 goals with normalized priorities
        return top_three_goals, self.all_goals
```
Additional Guidelines:
Use clear, descriptive variable names
Include comments explaining key decision points
Implement proper error handling for observation parsing
Ensure the goal prioritization system is numerically stable
Make configurations easily modifiable for different environments