Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class DaniellCellScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Introduce the scene
        title = Text("Daniell Cell: Basic Components").to_edge(UP, buff=0.5)

        # 2. Visual_Focus: Diagram of Daniell cell - Group of Rectangles, Lines, Circles - .shift(LEFT * 2.5)
        # Zinc electrode (anode) on left, copper electrode (cathode) on right,
        # solutions as rectangles, salt bridge as a connecting line.
        # Use BLUE for copper side, RED for zinc side, YELLOW for salt bridge.

        # Zinc electrode (anode)
        zinc_electrode = Rectangle(width=0.6, height=1.5, color=RED).shift(LEFT * 2.5)
        zinc_label = Text("Zn (Anode)").scale(0.5).next_to(zinc_electrode, DOWN, buff=0.2).set_color(RED)

        # Zinc solution container
        zinc_solution = Rectangle(width=1.2, height=1.8, color=RED).next_to(zinc_electrode, RIGHT, buff=0.1).shift(LEFT * 2.5)

        # Copper electrode (cathode)
        copper_electrode = Rectangle(width=0.6, height=1.5, color=BLUE).shift(RIGHT * 2.5)
        copper_label = Text("Cu (Cathode)").scale(0.5).next_to(copper_electrode, DOWN, buff=0.2).set_color(BLUE)

        # Copper solution container
        copper_solution = Rectangle(width=1.2, height=1.8, color=BLUE).next_to(copper_electrode, LEFT, buff=0.1).shift(RIGHT * 2.5)

        # Salt bridge - yellow line connecting the two solutions
        salt_bridge = Line(
            start=zinc_solution.get_right() + LEFT * 0.1,
            end=copper_solution.get_left() + RIGHT * 0.1,
            color=YELLOW,
            stroke_width=6
        ).shift(UP * 0.1)

        salt_label = Text("Salt Bridge").scale(0.4).set_color(YELLOW).next_to(salt_bridge, UP, buff=0.1)

        diagram_group = VGroup(
            zinc_electrode, zinc_label, zinc_solution,
            copper_electrode, copper_label, copper_solution,
            salt_bridge, salt_label
        )

        # 3. Main equation: simple_equation - MathTex - .shift(UP * 1.5)
        main_eq = MathTex(r"\text{Zn} \to \text{Zn}^{2+} + 2e^- \quad | \quad \text{Cu}^{2+} + 2e^- \to \text{Cu}").shift(UP * 1.5)

        # 4. Secondary text: explanation - Text - .shift(DOWN * 1.5)
        explanation = Text(
            "Daniell cell converts chemical energy into electrical energy.\n"
            "Zn electrode: Anode (oxidation)\n"
            "Cu electrode: Cathode (reduction)\n"
            "Salt bridge maintains electrical neutrality."
        ).scale(0.6).shift(DOWN * 1.5)

        # Animation Sequence:

        # 1. Write title
        self.play(Write(title), run_time=1.5)

        # 2. Create diagram on left and right sides
        self.play(Create(diagram_group), run_time=3)
        self.wait(1)

        # 3. Write main equation at upper center
        self.play(Write(main_eq), run_time=2)
        self.wait(1)

        # 4. Write explanation at lower center
        self.play(Write(explanation), run_time=3)
        self.wait(2)

        # Cleanup: FadeOut highlights (salt bridge label), fade out explanation but keep main equation and diagram
        self.play(FadeOut(salt_label), run_time=0.5)
        self.play(FadeOut(explanation), run_time=1)

        # Transition text (reuse secondary text area)
        transition = Text(
            "Having understood the physical setup,\n"
            "next we will explore the redox reactions\n"
            "and how they generate electrical potential."
        ).scale(0.6).shift(DOWN * 1.5)

        self.play(Write(transition), run_time=2)
        self.wait(2)

        # Final cleanup: FadeOut everything except main equation and title
        self.play(FadeOut(transition), FadeOut(diagram_group), run_time=1.5)

        # Keep title and main equation visible at end
        self.wait(2)
```

PATTERN: simple_equation

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title positioned at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Main equation in center-upper area
        equation = MathTex(r"{equation}").scale(1.2).shift(UP * 0.5)
        
        # Description below equation
        description = Text("{description}").scale(0.6).shift(DOWN * 1.5)
        
        # Simple highlight
        highlight = SurroundingRectangle(equation, color=YELLOW, buff=0.2)
        
        # Progressive animation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(equation))
        self.wait(1)
        self.play(Create(highlight))
        self.wait(1)
        self.play(Write(description))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code: