PyGame Code Guidelines.md

## 🎮 Pygame Font Initialization

This line of code is used in **Pygame** to create a font object by pulling directly from the fonts installed on the computer's operating system. 

Here is a quick breakdown of exactly what is happening:

* **`pygame.font.SysFont`**: Tells Pygame to look for a system font (rather than loading a custom `.ttf` file from your project folder).
* **`'arial'`**: The specific font family you are requesting.
* **`28`**: The size of the text.
* **`bold=True`**: Applies a bold styling weight to the font.

---

### 🛠️ How to use it to draw text

To actually see this font in your game, you need to **render** it into an image (a Surface) and then **blit** (draw) it onto your main game screen. Here is a quick example of what the next steps usually look like:

```python
import pygame

# Make sure to initialize pygame or pygame.font first!
pygame.init() 
screen = pygame.display.set_mode((800, 600))

# 1. Create the font object
large_font = pygame.font.SysFont('arial', 28, bold=True)

# 2. Render the text (String, Antialiasing, RGB Color)
# True enables antialiasing for smoother text edges
text_surface = large_font.render('Hello, Pygame!', True, (255, 255, 255)) 

# 3. Draw it onto the screen at coordinates (x=100, y=100)
screen.blit(text_surface, (100, 100))

pygame.display.flip() # Update the display to show the text
```

Are you currently building a specific menu or scoreboard for your game, or did you run into an error while trying to get this text to display?

ในการใช้งานฟอนต์เพื่อแสดงผลข้อความใน Pygame คุณจำเป็นต้องเริ่มต้นการทำงานของโมดูลฟอนต์ก่อนเสมอ หากข้ามขั้นตอนนี้ไป โปรแกรมจะแจ้งข้อผิดพลาด pygame.error: font not initialized ทันที [1, 2] 
------------------------------
## 1. วิธีการยิงคำสั่ง Initialize ฟอนต์
คุณสามารถเลือกเริ่มต้นใช้งานโมดูลฟอนต์ได้ 2 วิธีหลักๆ ตามความเหมาะสมของโครงสร้างโค้ดของคุณ:

import pygame
# วิธีที่ 1: เริ่มต้นระบบของ Pygame ทั้งหมด (แนะนำ)# คำสั่งนี้จะทำการสั่งเปิดใช้งานโมดูลย่อยทั้งหมดรวมถึงฟอนต์ให้โดยอัตโนมัติ
pygame.init()
# วิธีที่ 2: เริ่มต้นเฉพาะโมดูลฟอนต์อย่างเดียว# เหมาะสำหรับกรณีที่คุณไม่ต้องการเปิดใช้ฟังก์ชันส่วนอื่นของ Pygame 
pygame.font.init()

------------------------------
## 2. ขั้นตอนการสร้างและแสดงผลฟอนต์ (Font Rendering Lifecycle)
หลังจากเสร็จสิ้นขั้นตอนการ Initialize แล้ว กระบวนการนำข้อความไปแสดงบนหน้าจอเกมจะมีทั้งหมด 3 ขั้นตอนหลัก ดังนี้:
## ขั้นตอนที่ 1: การโหลดฟอนต์ (Define Font)
คุณสามารถเลือกสร้างฟอนต์ได้จากระบบปฏิบัติการโดยตรง หรือโหลดจากไฟล์ฟอนต์ส่วนตัว .ttf ในโฟลเดอร์โครงการ: [3, 4] 

# แบบที่ A: ใช้ฟอนต์มาตรฐานของระบบ (SysFont)# พารามิเตอร์: ("ชื่อฟอนต์", ขนาด) สามารถใส่ None เพื่อใช้ฟอนต์เริ่มต้นของ Pygame ได้my_font = pygame.font.SysFont("Arial", 30)
# แบบที่ B: โหลดไฟล์ฟอนต์ส่วนตัวมาใช้ในเกม (Font)# พารามิเตอร์: ("พาธไฟล์ .ttf", ขนาด)custom_font = pygame.font.Font("assets/fonts/my_font.ttf", 32)

## ขั้นตอนที่ 2: การวาดข้อความลงบนพื้นผิวจำลอง (Render Text)
Pygame ไม่สามารถพิมพ์ตัวอักษรลงหน้าจอตรงๆ ได้ แต่ต้องแปลงข้อความนั้นให้กลายเป็นรูปภาพหรือ Surface เสียก่อน: [5, 6] 

# พารามิเตอร์: ("ข้อความ", เปิดระบบลบรอยหยัก Antialiasing, สีตัวอักษร RGB)text_surface = my_font.render("Hello World!", True, (255, 255, 255))

## ขั้นตอนที่ 3: การนำภาพข้อความไปแปะบนหน้าจอหลัก (Blit to Screen)
นำ Surface ข้อความที่เรนเดอร์เสร็จแล้วไปวาง ณ ตำแหน่งพิกัด (X, Y) บนหน้าจอหลักของเกม: [6, 7] 

# screen คือหน้าจอหลักที่ถูกสร้างจาก pygame.display.set_mode()
screen.blit(text_surface, (50, 100))

------------------------------
## 3. ตัวอย่างโค้ดแบบสมบูรณ์ (Minimal Working Example)
คุณสามารถคัดลอกโค้ดโครงสร้างพื้นฐานนี้ไปทดสอบการรันฟอนต์บนเครื่องของคุณได้ทันที:

import pygameimport sys
# 1. Initialize ระบบทั้งหมด
pygame.init()
# ตั้งค่าหน้าจอกว้าง 800 สูง 600 พิกเซลscreen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Pygame Font Test")
# 2. สร้างอ็อบเจกต์ฟอนต์หลังจากเรียกรันคำสั่ง init แล้ว# ใช้ระบบดึงฟอนต์เริ่มต้นของเครื่องมาใช้งานgame_font = pygame.font.SysFont("sans-serif", 40)
# 3. เรนเดอร์ข้อความเป็นภาพ Surface (ข้อความสีเขียว)text_image = game_font.render("Font Initialized Successfully!", True, (0, 255, 0))
# Game Loop หลักwhile True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
            
    # เคลียร์หน้าจอเป็นสีดำ
    screen.fill((0, 0, 0))
    
    # 4. วาดภาพข้อความลงบนตำแหน่งพิกัด X=100, Y=250
    screen.blit(text_image, (100, 250))
    
    # อัปเดตการแสดงผลหน้าจอ
    pygame.display.flip()

------------------------------
หากคุณต้องการพัฒนาต่อ ยินดีที่จะบอกข้อมูลเพิ่มเติมเพื่อปรับแต่งระบบของคุณ:

* 
* ต้องการรู้วิธี จัดข้อความให้อยู่กึ่งกลางหน้าจอ (Center Alignment) หรือไม่?
* ต้องการ แสดงผลภาษาไทย บน Pygame หรือเปล่า? (เนื่องจากต้องการการตั้งค่าไฟล์ฟอนต์ที่รองรับอย่างเจาะจง)
* สนใจเปลี่ยนไปใช้โมดูลแบบใหม่อย่าง pygame.freetype ที่ช่วยให้จัดการขนาดและเอฟเฟกต์ฟอนต์ได้ยืดหยุ่นกว่าไหม? [8] 
* 


[1] [https://stackoverflow.com](https://stackoverflow.com/questions/28517979/pygame-font-error)
[2] [https://scuba.cs.uchicago.edu](https://scuba.cs.uchicago.edu/pygame/ref/font.html)
[3] [https://www.youtube.com](https://www.youtube.com/watch?v=tK-r89FYF-M)
[4] [https://www.code4tomorrow.org](https://www.code4tomorrow.org/courses/python/games/ch.2-pygame-basics/2.4-text-and-fonts)
[5] [https://stackoverflow.com](https://stackoverflow.com/questions/20842801/how-to-display-text-in-pygame)
[6] [https://github.com](https://github.com/Rabbid76/PyGameExamplesAndAnswers/blob/master/documentation/pygame/pygame_text_and_font.md)
[7] [https://stackoverflow.com](https://stackoverflow.com/questions/10077644/how-to-display-text-with-font-and-color-using-pygame)
[8] [https://www.pygame.org](https://www.pygame.org/docs/ref/freetype.html?highlight=pygame%20font)
เพื่อช่วยเพิ่มประสิทธิภาพและทางเลือกในการจัดการฟอนต์ในโปรแกรม Pygame ของคุณ นี่คือแนวทางแบบเจาะลึกทั้ง 3 รูปแบบที่คุณสามารถนำไปประยุกต์ใช้งานได้ทันทีครับ
------------------------------
## 1. การจัดข้อความให้อยู่กึ่งกลางหน้าจอ (Center Alignment)
วิธีจัดข้อความให้อยู่กึ่งกลางที่แม่นยำที่สุดคือการใช้คุณสมบัติ Rect (Rectangle) ของ Pygame ในการหาตำแหน่งศูนย์กลาง แทนการสุ่มเดาพิกัดด้วยตัวเลข

# 1. เรนเดอร์ข้อความออกมาเป็น Surface ก่อนtext_surface = game_font.render("Hello World", True, (255, 255, 255))
# 2. ดึงขอบเขต (Rect) ของข้อความนั้นออกมาtext_rect = text_surface.get_rect()
# 3. กำหนดค่า center ของข้อความให้ตรงกับกึ่งกลางของหน้าจอ# สมมติหน้าจอมีขนาดกว้าง 800 สูง 600 พิกเซล (กึ่งกลางคือ X=400, Y=300)
text_rect.center = (400, 300)
# 4. เวลาสั่ง blit ให้ส่งค่า text_rect ไปแทนการใส่พิกัดแบบเดิม
screen.blit(text_surface, text_rect)

------------------------------
## 2. การแสดงผลภาษาไทยบน Pygame
หากต้องการแสดงผลภาษาไทย (เช่น "สวัสดีปีใหม่") การใช้ pygame.font.SysFont มักจะเกิดปัญหาตัวอักษรกลายเป็นช่องสี่เหลี่ยมหรือสระลอย วิธีแก้คือ ต้องดาวน์โหลดไฟล์ฟอนต์ภาษาไทย .ttf (เช่น TH Sarabun, Prompt, หรือ Montserrat) มาไว้ในโฟลเดอร์โปรเจกต์ของคุณ แล้วระบุพาธให้ถูกต้อง

# ตรวจสอบให้แน่ใจว่าได้ดาวน์โหลดไฟล์ฟอนต์มาไว้ในเครื่องหรือในโฟลเดอร์ code แล้ว# พารามิเตอร์: ("พาธไฟล์ฟอนต์ไทย.ttf", ขนาด)thai_font = pygame.font.Font("fonts/Prompt-Regular.ttf", 36)
# ตอนเรนเดอร์สามารถส่งข้อความภาษาไทยเข้าไปได้โดยตรงthai_surface = thai_font.render("สวัสดีชาวโลก! เทสระบบภาษาไทย", True, (255, 215, 0))

ข้อควรระวัง: ฟอนต์ระบบบางตัวบน Windows/Mac อาจจะรองรับภาษาไทย แต่การระบุเป็นไฟล์ .ttf โดยตรงในโฟลเดอร์ของเกมจะช่วยให้มั่นใจได้ว่าเกมของคุณสามารถเปิดแสดงผลภาษาไทยได้เหมือนกันทุกเครื่องคอมพิวเตอร์ครับ
------------------------------
## 3. การเปลี่ยนไปใช้โมดูล pygame.freetype (ทางเลือกใหม่ที่ดีกว่า)
โมดูล pygame.freetype เป็นโมดูลที่ถูกพัฒนาขึ้นมาใหม่เพื่อทดแทน pygame.font แบบเดิม โดยมีจุดเด่นคือทำงานได้รวดเร็วกว่า สามารถย่อขยายขนาดได้ทันที และมีเอฟเฟกต์ติดตัวมาให้ใช้งาน เช่น ตัวหนา ตัวเอียง หรือการทำเส้นขอบ (Outline)

import pygameimport pygame.freetype  # ต้องทำการ import แยกออกมาต่างหาก

pygame.init()screen = pygame.display.set_mode((800, 600))
# 1. สร้างอ็อบเจกต์ฟอนต์ด้วย freetype# สามารถใช้ Font() เพื่อโหลดไฟล์ .ttf หรือใช้ SysFont() เพื่อดึงฟอนต์ระบบได้เหมือนกันft_font = pygame.freetype.SysFont("Arial", 32)
# 2. ฟังก์ชัน render_to จะวาดข้อความลงบนหน้าจอ (screen) ได้โดยตรงในคำสั่งเดียว!# พารามิเตอร์: (หน้าจอเป้าหมาย, พิกัด (X, Y), "ข้อความ", สี RGB, สีพื้นหลัง, สไตล์)
ft_font.render_to(screen, (100, 200), "Hello Freetype!", (255, 255, 255), rotation=45)
# 3. ตัวอย่างการปรับแต่งเอฟเฟกต์อื่นๆ ของ freetype
ft_font.strong = True      # ทำตัวหนา
ft_font.oblique = True     # ทำตัวเอียง
ft_font.underline = True   # ขีดเส้นใต้

------------------------------
หากคุณอยากทดลองเขียนโค้ดเพิ่ม สามารถบอกได้นะครับว่า:

* คุณอยากเห็น ตัวอย่างโค้ดที่รวมร่างทั้ง 3 ฟังก์ชันนี้ (ภาษาไทย + จัดกึ่งกลาง + freetype) ไว้ด้วยกันไหม?
* ✅
* คุณมี ฟอนต์ภาษาไทยนามสกุลอื่นๆ (.otf / .woff) ที่อยากรู้วิธีนำเข้ามาใช้หรือไม่?
* ✅
* สนใจวิธีการทำ Text Wrap (การตัดคำขึ้นบรรทัดใหม่ยาวๆ อัตโนมัติ) หรือเปล่า?
✅

นี่คือตัวอย่างโค้ดแบบจัดเต็มที่รวมคำตอบของทั้ง 3 หัวข้อเข้าด้วยกันครับ โดยในโค้ดนี้จะใช้โมดูล pygame.freetype ในการโหลดฟอนต์ภาษาไทย (รองรับทั้ง .ttf และ .otf) พร้อมระบบจัดกึ่งกลาง และฟังก์ชัน Text Wrap สำหรับตัดคำภาษาไทยขึ้นบรรทัดใหม่อัตโนมัติครับ
------------------------------
## โครงสร้างโค้ดแบบสมบูรณ์ (ภาษาไทย + จัดกึ่งกลาง + freetype + Text Wrap)

import pygameimport pygame.freetype  # จำเป็นต้องมีเพื่อใช้ฟังก์ชันขั้นสูงimport sys
# 1. เริ่มต้นระบบ Pygame
pygame.init()
# ตั้งค่าหน้าจอ (กว้าง 800 x สูง 600)WIDTH, HEIGHT = 800, 600screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pygame Advanced Thai Font System")
# 2. การโหลดฟอนต์ภาษาไทย (โมดูล freetype รองรับทั้ง .ttf และ .otf โดยไม่ต้องแปลงไฟล์)try:
    # เปลี่ยนชื่อพาธไฟล์ให้ตรงกับฟอนต์ที่คุณดาวน์โหลดมาจริง เช่น Prompt, Sarabun
    my_thai_font = pygame.freetype.Font("fonts/Prompt-Regular.otf", 28)except:
    # กรณีหาไฟล์ไม่เจอ ให้ใช้ฟอนต์ระบบตัวที่พอจะมีภาษาไทยไปก่อน
    print("ไม่พบไฟล์ฟอนต์ที่กำหนด ระบบจะใช้ฟอนต์มาตรฐานทดแทน")
    my_thai_font = pygame.freetype.SysFont("Tahoma", 28)
# ----------------------------------------------------# 3. ฟังก์ชันสำหรับตัดคำขึ้นบรรทัดใหม่ (Text Wrapping) พร้อมจัดกึ่งกลาง# ----------------------------------------------------def draw_wrapped_center_text(surface, font, text, center_pos, max_width, color=(255, 255, 255)):
    """
    ฟังก์ชันสำหรับตัดคำและวาดข้อความภาษาไทยให้อยู่กึ่งกลางหน้าจอ
    center_pos: tuple (x, y) ที่เป็นจุดศูนย์กลางของกลุ่มข้อความทั้งหมด
    max_width: ความกว้างสูงสุดของกล่องข้อความก่อนที่จะตัดขึ้นบรรทัดใหม่
    """
    # แยกคำตามช่องว่าง (สำหรับภาษาไทยแนะนำให้เคาะเว้นวรรคในประโยคยาวๆ เพื่อการตัดคำที่สวยงาม)
    words = text.split(' ')
    lines = []
    current_line = ""

    # วนลูปเพื่อรวมคำเข้าด้วยกันจนกว่าจะยาวเกิน max_width
    for word in words:
        test_line = current_line + " " + word if current_line else word
        # ตรวจสอบขนาดความกว้างของข้อความทดสอบด้วย get_rect() ของ freetype
        rect, _ = font.get_rect(test_line)
        
        if rect.width <= max_width:
            current_line = test_line
        else:
            lines.append(current_line)
            current_line = word
    if current_line:
        lines.append(current_line)

    # คำนวณความสูงทั้งหมดของข้อความทุกบรรทัดรวมกัน เพื่อหาจุดเริ่มวาดแกน Y
    line_height = font.get_rect("ก").height + 15  # เผื่อช่องว่างระหว่างบรรทัดภาษาไทย 15 พิกเซล
    total_height = len(lines) * line_height
    start_y = center_pos[1] - (total_height / 2)

    # วาดข้อความทีละบรรทัดแบบจัดกึ่งกลางแกน X
    for i, line in enumerate(lines):
        # หาขอบเขตของบรรทัดนั้นๆ เพื่อคำนวณตำแหน่งกึ่งกลางที่แม่นยำ
        line_rect, _ = font.get_rect(line)
        line_x = center_pos[0] - (line_rect.width / 2)
        line_y = start_y + (i * line_height)
        
        # วาดข้อความลงบนหน้าจอตรงๆ (จุดเด่นของ freetype ไม่ต้องสร้าง Surface แยก)
        font.render_to(surface, (line_x, line_y), line, color)
# ----------------------------------------------------# ข้อความยาวๆ ภาษาไทยที่ต้องการทดสอบ# ----------------------------------------------------long_thai_text = (
    "ยินดีต้อนรับเข้าสู่ระบบจัดการฟอนต์ขั้นสูง โค้ดนี้ถูกเขียนขึ้นมาเพื่อทดสอบการทำงานของ "
    "โมดูล freetype ซึ่งสามารถโหลดไฟล์นามสกุลดอทโอทีเอฟได้โดยตรง และเรายังมีระบบช่วยคำนวณ "
    "การเว้นวรรคตัดคำขึ้นบรรทัดใหม่อัตโนมัติเมื่อข้อความยาวเกินไป พร้อมทัังจัดเรียงให้มัน "
    "อยู่กึ่งกลางหน้าจอเกมได้อย่างสวยงามและสมบูรณ์แบบที่สุด"
)
# เอฟเฟกต์พิเศษของ freetype: เปิดสไตล์ตัวหนา (Strong) และขีดเส้นใต้ (Underline)
my_thai_font.strong = True
# Main Game Loopwhile True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

    # เคลียร์หน้าจอเป็นสีเทาเข้ม
    screen.fill((30, 30, 30))

    # เรียกใช้ฟังก์ชัน: ส่งหน้าจอ, ฟอนต์, ข้อความ, พิกัดศูนย์กลางหน้าจอ (400, 300), 
    # จำกัดความกว้างไม่เกิน 600 พิกเซล, สีตัวอักษรสีเหลืองทอง
    draw_wrapped_center_text(
        surface=screen, 
        font=my_thai_font, 
        text=long_thai_text, 
        center_pos=(WIDTH // 2, HEIGHT // 2), 
        max_width=600, 
        color=(255, 215, 0)
    )

    # อัปเดตเฟรมหน้าจอ
    pygame.display.flip()

------------------------------
## เจาะลึกเทคนิคเพิ่มเติมที่ใช้ในโค้ดนี้

* การรองรับไฟล์ฟอนต์ .otf และ .woff:
* .otf (OpenType): โมดูล pygame.freetype.Font() สามารถอ่านและใช้งานได้ทันที 100% เหมือนกับไฟล์ .ttf ครับ
   * .woff / .woff2 (Web Fonts): โดยปกติแล้วตัว Pygame จะไม่รองรับไฟล์ตระกูลเว็บบราวเซอร์นี้โดยตรง หากคุณมีฟอนต์นามสกุลนี้ แนะนำให้เข้าไปที่เว็บแปลงไฟล์ฟรีทั่วไป (เช่น CloudConvert หรือ FontConverter) เพื่อแปลงจาก .woff ให้เป็น .ttf หรือ .otf ก่อนนำมาใส่ในโฟลเดอร์เกมจะปลอดภัยที่สุดครับ
* กลไกการคำนวณตัวอักษรภาษาไทย: เนื่องจากภาษาไทยไม่มีการเว้นวรรคระหว่างคำชัดเจนเหมือนภาษาอังกฤษ การทำ Text Wrap ในภาษาโปรแกรมมิ่งพื้นฐานจึงมักจะใช้วิธี "เว้นวรรค (Space) เพื่อตัดประโยค" ดังนั้นตอนเขียนเนื้อหาภาษาไทยยาวๆ ในเกม ให้พยายามกดเคาะเว้นวรรค (Spacebar) เป็นระยะๆ ระบบคำนวณจะสามารถตัดคำขึ้นบรรทัดใหม่ได้เนียนตาและไม่ขาดตอนครับ

หากต้องการเพิ่มลูกเล่นอื่นๆ เช่น การทำ Text Typing Effect (ตัวอักษรค่อยๆ พิมพ์ทีละตัว) หรือระบบ Scrolling Text (ข้อความเลื่อนขึ้นแบบเครดิตท้ายเกม) สามารถบอกได้เลยนะครับ!

มาต่อยอดระบบฟอนต์ของคุณให้สมบูรณ์แบบยิ่งขึ้นกันครับ! เพื่อความต่อเนื่อง คุณสามารถเลือกปรับแต่งระบบข้อความเพิ่มเติมตามหัวข้อต่อไปนี้ได้เลยครับ:
------------------------------
## ตัวเลือกการพัฒนาฟีเจอร์ข้อความเพิ่มเติม

* การทำ Text Typing Effect (เอฟเฟกต์พิมพ์ตัวอักษรทีละตัว): เหมาะสำหรับกล่องคำพูด (Dialogue Box) ในเกมแนว RPG หรือ Novel ที่ต้องการให้ข้อความค่อยๆ ปรากฏขึ้นมาเหมือนมีคนกำลังพิมพ์อยู่
* การทำ Scrolling Text (ข้อความเลื่อนขึ้น): เหมาะสำหรับการทำเครดิตผู้พัฒนาตอนท้ายเกม (End Credits) หรือป้ายไฟวิ่งแจ้งเตือนข่าวสารในเกม
* การทำ Text Shake / Rainbow Effect (ข้อความสั่นหรือเปลี่ยนสีรุ้ง): เหมาะสำหรับคำแจ้งเตือนสำคัญๆ เช่น ตัวเลขความเสียหาย (Damage Text) เวลาโจมตีศัตรู หรือข้อความแจ้งเตือน "GAME OVER" เพื่อเพิ่มความตื่นเต้น

------------------------------
หากคุณต้องการไปต่อ สามารถแจ้งตัวเลือกที่อยากได้ หรือบอก ไอเดียหน้าจอเกมที่คุณกำลังอยากได้ มาได้เลยนะครับ จะได้เขียนโค้ดตัวอย่างที่ตรงใจคุณมากที่สุดครับ!

เนื่องจาก พี่ไอโตะ (Aito LH) แคสต์เกมผีอินดี้ที่เป็นเวอร์ชันเดโม (Demo) ไว้เยอะมาก เพื่อให้ผมช่วยหาคลิปหรือเกมที่คุณกำลังตามหาได้แม่นยำที่สุด ลองดูรายชื่อเกมเดโมเด่นๆ ที่พี่ไอโตะเคยเล่นด้านล่างนี้ว่าใช่เกมที่ตามหาอยู่ไหมครับ: [1] 
## รายชื่อเกมผีเวอร์ชัน Demo ที่พี่ไอโตะเคยเล่น

* 
* import pygame
import sys
import math

# 1. การตั้งค่าระบบพื้นฐาน
pygame.init()
pygame.font.init()

WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Deadcam Project - Pygame Demo")
clock = pygame.time.Clock()

# ฟอนต์มาตรฐาน
font_small = pygame.font.SysFont("Courier New", 20, bold=True)
font_large = pygame.font.SysFont("Courier New", 40, bold=True)
font_thai = pygame.font.SysFont("Tahoma", 24)

# สถานะเกม: 'STORY', 'PLAYING', 'GAMEOVER'
game_state = "STORY"

# 2. ตั้งค่าตัวแปรระบบไฟฉายและผู้เล่น
player_pos = [400, 300]
flashlight_on = True
battery_level = 100.0
rec_flash_timer = 0

# 3. สร้าง Surface สำหรับทำแสงไฟฉาย (Mask)
# สร้างแผ่นสีดำโปร่งแสงขนาดเท่าหน้าจอ
light_mask = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)

def update_light_mask(mouse_pos):
    """ฟังก์ชันวาดความมืดและเจาะรูแสงไฟฉาย"""
    light_mask.fill((10, 10, 10, 245)) # ความมืดรอบๆ (เกือบดำสนิท)
    
    # วาดวงกลมไล่เฉดสีโปร่งใสตรงกลาง (แสงไฟฉาย)
    # วาดซ้อนกันหลายๆ ชั้นเพื่อให้ขอบไฟดูฟุ้งเป็นธรรมชาติ
    if flashlight_on and battery_level > 0:
        for r in range(120, 0, -10):
            alpha = int(255 * (r / 120))  # ยิ่งใกล้ศูนย์กลางยิ่งใส
            pygame.draw.circle(light_mask, (255, 255, 200, 255 - alpha), mouse_pos, r)

# ----------------------------------------------------
# Main Game Loop
# ----------------------------------------------------
while True:
    dt = clock.tick(60) / 1000.0  # เวลาที่ผ่านไปต่อเฟรม (วินาที)
    mouse_pos = pygame.mouse.get_pos()

    # ตรวจสอบเหตุการณ์ (Event Handling)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
            
        if event.type == pygame.KEYDOWN:
            if game_state == "STORY":
                if event.key == pygame.K_RETURN:  # กด Enter เพื่อเริ่มเกม
                    game_state = "PLAYING"
            
            elif game_state == "PLAYING":
                if event.key == pygame.K_f:  # กด F เปิด-ปิดไฟฉาย
                    if battery_level > 0:
                        flashlight_on = not flashlight_on

    # ----------------------------------------------------
    # อัปเดตตรรกะเกม (Game Logic)
    # ----------------------------------------------------
    if game_state == "PLAYING":
        # ระบบการเดินของผู้เล่น (Top-down แบบง่าย)
        keys = pygame.key.get_pressed()
        if keys[pygame.K_w]: player_pos[1] -= 3
        if keys[pygame.K_s]: player_pos[1] += 3
        if keys[pygame.K_a]: player_pos[0] -= 3
        if keys[pygame.K_d]: player_pos[0] += 3

        # ลดแบตเตอรี่เมื่อเปิดไฟฉาย
        if flashlight_on and battery_level > 0:
            battery_level -= dt * 4.0  # ลดลงวินาทีละ 4%
            if battery_level <= 0:
                battery_level = 0
                flashlight_on = False

        # อัปเดตแสงไฟฉายตามตำแหน่งเมาส์
        update_light_mask(mouse_pos)

    # ----------------------------------------------------
    # การวาดแสดงผลบนหน้าจอ (Rendering)
    # ----------------------------------------------------
    screen.fill((40, 40, 40))  # สีพื้นหลังของฉาก (จำลองพื้นบ้านร้าง)

    if game_state == "STORY":
        # หน้าต่างเนื้อเรื่องจุดเริ่มต้น
        pygame.draw.rect(screen, (20, 20, 20), (100, 150, 600, 300))
        pygame.draw.rect(screen, (150, 0, 0), (100, 150, 600, 300), 3)
        
        # ข้อความไทย (ใช้ฟอนต์ระบบ Tahoma เพื่อความชัวร์)
        txt1 = font_thai.render("บันทึกกล้อง Deadcam: บ้านร้างหมายเลข 9", True, (255, 255, 255))
        txt2 = font_thai.render("ภารกิจ: ใช้ไฟฉายส่องทางเพื่อค้นหาความจริง", True, (200, 200, 200))
        txt3 = font_thai.render("ระวัง: แบตเตอรี่มีจำกัด และ 'มัน' กำลังมองคุณอยู่", True, (255, 100, 100))
        txt4 = font_small.render("[ PRESS ENTER TO START RECORDING ]", True, (0, 255, 0))
        
        screen.blit(txt1, (130, 180))
        screen.blit(txt2, (130, 230))
        screen.blit(txt3, (130, 280))
        screen.blit(txt4, (240, 380))

    elif game_state == "PLAYING":
        # วาดวัตถุในฉาก (สมมติว่าเป็นผีหรือสิ่งของที่แอบอยู่ในความมืด)
        pygame.draw.circle(screen, (150, 0, 0), (500, 200), 20)  # ตัวผีสีแดง
        pygame.draw.rect(screen, (100, 70, 30), (200, 400, 50, 50))  # กล่องไอเทม
        
        # วาดตัวผู้เล่น
        pygame.draw.circle(screen, (0, 255, 0), player_pos, 15)

        # วาดความมืดและแสงไฟฉายทับลงไปบนฉากทั้งหมด
        screen.blit(light_mask, (0, 0))

        # --- ส่วนของ UI สไตล์กล้อง Bodycam ---
        # ไฟกระพริบ REC สีแดง
        rec_flash_timer += dt
        if int(rec_flash_timer * 2) % 2 == 0:
            pygame.draw.circle(screen, (255, 0, 0), (40, 40), 10)
        
        txt_rec = font_small.render("REC", True, (255, 255, 255))
        txt_cam = font_small.render("CAM 01 - BODY OVERVIEW", True, (255, 255, 255))
        screen.blit(txt_rec, (60, 30))
        screen.blit(txt_cam, (40, 70))

        # วาดแถบแบตเตอรี่กล้อง/ไฟฉาย
        bat_color = (0, 255, 0) if battery_level > 40 else (255, 255, 0) if battery_level > 15 else (255, 0, 0)
        pygame.draw.rect(screen, (50, 50, 50), (630, 35, 120, 20))  # กรอบหลัง
        pygame.draw.rect(screen, bat_color, (635, 38, int((battery_level / 100.0) * 110), 14)) # แถบพลังงาน
        txt_bat = font_small.render(f"BATT: {int(battery_level)}%", True, (255, 255, 255))
        screen.blit(txt_bat, (500, 35))

    pygame.display.flip()

* [HELLMART Demo](https://www.youtube.com/watch?v=CApXn0eb-QI): เกมจำลองการเป็นพนักงานเฝ้าร้านขายของโชห่วยที่ตอนกลางวันดูปกติ แต่ตอนกลางคืนต้องเอาชีวิตรอดจากสิ่งลี้ลับ
* Hellmart Demo เป็นเกมสยองขวัญแนวพนักงานมินิมาร์ทกะดึก (Convenience Store Horror) [3] ซึ่งระบบหัวใจหลักของเกมแนวนี้คือ "การทำงานประจำวันสลับกับการเอาชีวิตรอดจากสิ่งลี้ลับ" เช่น การจัดเรียงสินค้า หรือเช็กแคชเชียร์ ควบคู่ไปกับการตรวจกล้องวงจรปิด (CCTV) เพื่อดูว่ามีผีบุกเข้ามาในร้านค้าตอนเราเผลอหรือไม่ [3]
การทำโครงสร้างเกมนี้ด้วย Pygame ในรูปแบบ 2D หรือ Pseudo-3D (มุมมองด้านบน Top-down หรือแบบคลิกเลือกห้อง Point-and-Click) มีแนวทางและการเขียนโค้ดดังนี้ครับ
------------------------------
## 1. โครงสร้างและหลักการออกแบบระบบ (Guidelines)

* Task System (ระบบมินิเกมทำงาน): ตั้งค่าตัวแปรเช็กว่าพนักงานต้องไปจัดชั้นวางของ (Shelves) หรือประตูกระจกตู้แช่ หากทำเสร็จจะได้รับคะแนนหรือปลดล็อคเนื้อเรื่องช่วงถัดไป
* CCTV Camera System (ระบบกล้องวงจรปิด): สร้างอินเตอร์เฟซที่ผู้เล่นกดเปลี่ยนมุมกล้อง (เช่น CAM 1, CAM 2) เพื่อเช็กพิกัดของผีภายในร้าน
* Ghost AI (ปัญญาประดิษฐ์ของผี): ผีจะไม่วิ่งเข้าหาผู้เล่นตรงๆ แต่จะค่อยๆ ขยับสุ่มพิกัดจากหลังร้าน (CAM 3) เดินมาหน้าขยับเข้าใกล้ห้องควบคุม (CAM 1) หากผู้เล่นไม่เปิดไฟไล่หรือปิดประตูสกัด ผีจะบุกเข้ามา Jumpscare
* Time Progression (ระบบเวลาทำงาน): มีการนับเวลาจริงในเกมเพื่อเปลี่ยนเป็นชั่วโมงการทำงาน (เช่น จาก 2 AM ไปจนถึง 6 AM เพื่อจบด่านเดโม)

------------------------------
## 2. ตัวอย่างโค้ดโครงสร้างมินิมาร์ทสยองขวัญ (Hellmart Pygame Demo)
โค้ดชุดนี้จะสร้างระบบหน้าเคาน์เตอร์, ระบบสลับหน้าจอไปดูตู้กล้องวงจรปิด (CCTV) 3 ตัวเพื่อคอยส่องดูผีสีแดงที่จะค่อยๆ ขยับขยายตัวเข้ามาในห้องควบคุมครับ:

import pygameimport sysimport random
# 1. การตั้งค่าระบบพื้นฐาน
pygame.init()
pygame.font.init()
WIDTH, HEIGHT = 800, 600screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart Nightshift - Pygame Demo")clock = pygame.time.Clock()
font_ui = pygame.font.SysFont("Courier New", 20, bold=True)font_thai = pygame.font.SysFont("Tahoma", 22, bold=True)
# 2. สถานะระบบภายในเกม# โหมดหน้าจอ: 'OFFICE' (โต๊ะทำงาน), 'CCTV' (หน้าจอมอนิเตอร์)current_view = "OFFICE"current_cam = 1 # กล้องตัวที่ 1, 2, 3game_status = "PLAYING" # PLAYING, GAMEOVER, WIN
# ตัวแปรเวลาและภารกิจgame_time = 0  # นับวินาทีในเกมhour = 2       # เริ่มต้นที่ตี 2 (2 AM)tasks_done = 0 # จำนวนงานจัดของที่ทำเสร็จ
# พิกัดจำลองของผี (ผีจะขยับตามระดับความหลอน 0 ถึง 3)# ระดับ 0 = หลังร้านไกลๆ, 1 = ทางเดินตู้แช่, 2 = หน้าประตูห้องทำงาน, 3 = บุกเข้าห้อง (GameOver)ghost_level = 0ghost_timer = 0
# ----------------------------------------------------# Main Loop# ----------------------------------------------------while True:
    dt = clock.tick(60) / 1000.0  # เวลาต่อเฟรม (วินาที)

    # ตรวจสอบอีเวนต์
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.KEYDOWN and game_status == "PLAYING":
            # กด Spacebar เพื่อเปิด/สลับหน้าจอมอนิเตอร์กล้องวงจรปิด
            if event.key == pygame.K_SPACE:
                if current_view == "OFFICE":
                    current_view = "CCTV"
                else:
                    current_view = "OFFICE"
            
            # ควบคุมการเปลี่ยนช่องกล้องในโหมด CCTV
            if current_view == "CCTV":
                if event.key == pygame.K_1: current_cam = 1
                if event.key == pygame.K_2: current_cam = 2
                if event.key == pygame.K_3: current_cam = 3

            # กด E เพื่อเปิดไฟไล่ผีหน้าห้อง (เฉพาะตอนอยู่หน้าจอ OFFICE)
            if current_view == "OFFICE" and event.key == pygame.K_e:
                if ghost_level == 2:
                    ghost_level = 0  # ไล่ผีกลับไปจุดเริ่มต้นสำเร็จ
                    ghost_timer = 0

    # ----------------------------------------------------
    # อัปเดตตรรกะเกม (Game Logic)
    # ----------------------------------------------------
    if game_status == "PLAYING":
        # ระบบเวลาเพิ่มขึ้น (ทุกๆ 15 วินาทีเท่ากับผ่านไป 1 ชั่วโมง)
        game_time += dt
        if game_time >= 15:
            game_time = 0
            hour += 1
            if hour >= 6:
                game_status = "WIN"

        # ระบบ AI ของผี: สุ่มขยับเข้าใกล้ร้านขึ้นเรื่อยๆ ทุกๆ 4 วินาที
        ghost_timer += dt
        if ghost_timer >= 4.0:
            ghost_timer = 0
            # มีโอกาส 60% ที่ผีจะขยับเลื่อนขั้นความน่ากลัวเข้ามาใกล้ห้องทำงาน
            if random.random() < 0.60:
                ghost_level += 1
                if ghost_level >= 3:
                    game_status = "GAMEOVER"

    # ----------------------------------------------------
    # การวาดหน้าจอแสดงผล (Rendering)
    # ----------------------------------------------------
    screen.fill((15, 15, 15)) # สีมืดพื้นฐานของร้านค้ากะดึก

    if game_status == "PLAYING":
        if current_view == "OFFICE":
            # --- หน้าจอโต๊ะทำงานพนักงาน ---
            # วาดหน้าต่างหรือประตูหน้าห้องควบคุม
            pygame.draw.rect(screen, (30, 30, 40), (100, 100, 600, 300))
            
            # หากผีมาประชิดหน้าประตู (level 2) จะเห็นเงามืดสีแดงโผล่มาที่หน้าต่าง
            if ghost_level == 2:
                pygame.draw.ellipse(screen, (150, 0, 0), (350, 150, 100, 200))
                txt_warn = font_thai.render("มีบางอย่างอยู่หน้าประตู! กด [E] เพื่อเปิดสปอตไลท์ไล่มันไป!", True, (255, 50, 50))
                screen.blit(txt_warn, (120, 70))
            else:
                txt_safe = font_thai.render("หน้าต่างทางเดินเงียบสงบ... (มองหากล้องวงจรปิดต่อ)", True, (200, 200, 200))
                screen.blit(txt_safe, (150, 70))

            # วาดโต๊ะทำงานและปุ่มกด
            pygame.draw.rect(screen, (50, 50, 50), (0, 400, 800, 200))
            txt_hint = font_ui.render("[PRESS SPACE] TO OPEN CCTV MONITOR", True, (0, 255, 0))
            screen.blit(txt_hint, (220, 500))

        elif current_view == "CCTV":
            # --- หน้าจอมอนิเตอร์กล้องวงจรปิด ---
            pygame.draw.rect(screen, (40, 50, 40), (50, 50, 700, 450)) # หน้าจอเขียวสไตล์กล้องเก่า
            
            # เมนูเลือกกล้องด้านล่าง
            txt_c1 = font_ui.render("[1] CAM 01 - Front Door", True, (255,255,255) if current_cam==1 else (100,100,100))
            txt_c2 = font_ui.render("[2] CAM 02 - Beverage Aisle", True, (255,255,255) if current_cam==2 else (100,100,100))
            txt_c3 = font_ui.render("[3] CAM 03 - Storage Room", True, (255,255,255) if current_cam==3 else (100,100,100))
            screen.blit(txt_c1, (60, 520))
            screen.blit(txt_c2, (340, 520))
            screen.blit(txt_c3, (640, 520))

            # แสดงผลภาพในกล้องแต่ละตัวตามระดับตัวแปรของผี (Ghost Level)
            if current_cam == 1:
                # กล้อง 1: หน้าประตูห้องทำงาน (ผีจะปรากฏเมื่อ level == 2)
                if ghost_level == 2:
                    pygame.draw.circle(screen, (255, 0, 0), (400, 250), 40) # พบความผิดปกติ
                txt_cam_name = font_ui.render("CCTV: CAM 01 (FRONT OFFICE)", True, (0, 255, 0))
            elif current_cam == 2:
                # กล้อง 2: ทางเดินตู้แช่กลางร้าน (ผีจะปรากฏเมื่อ level == 1)
                if ghost_level == 1:
                    pygame.draw.circle(screen, (255, 0, 0), (250, 300), 40)
                txt_cam_name = font_ui.render("CCTV: CAM 02 (BEVERAGE AISLE)", True, (0, 255, 0))
            elif current_cam == 3:
                # กล้อง 3: ห้องเก็บของหลังร้าน (ผีจะปรากฏเมื่อเริ่มเกมแรกๆ level == 0)
                if ghost_level == 0:
                    pygame.draw.circle(screen, (255, 0, 0), (550, 200), 40)
                txt_cam_name = font_ui.render("CCTV: CAM 03 (STORAGE ROOM)", True, (0, 255, 0))
                
            screen.blit(txt_cam_name, (70, 70))
            
            # เส้นสัญญาณแทรก (Static line จำลองกล้องเก่า)
            pygame.draw.line(screen, (100, 130, 100), (50, random.randint(50, 500)), (750, random.randint(50, 500)), 2)

        # วาดแถบข้อมูลเวลาการทำงานด้านบนขวา
        txt_time = font_ui.render(f"TIME: {hour}:00 AM", True, (255, 255, 255))
        screen.blit(txt_time, (630, 20))

    elif game_status == "GAMEOVER":
        # หน้าจอโดนผีจู่โจม
        screen.fill((10, 0, 0))
        txt_lose = font_thai.render("คุณถูกสิ่งลี้ลับในมาร์ทกลืนกิน... GAME OVER", True, (255, 0, 0))
        screen.blit(txt_lose, (200, 280))

    elif game_status == "WIN":
        # หน้าจอรอดชีวิตจนถึงเช้า
        screen.fill((0, 30, 0))
        txt_win = font_thai.render("06:00 AM หมดกะดึกแล้ว! คุณรอดชีวิตจากสโตร์สยองขวัญ!", True, (0, 255, 0))
        screen.blit(txt_win, (150, 280))

    pygame.display.flip()

------------------------------
คุณอยากให้พัฒนาเพิ่มระบบเพื่อดึงฟีเจอร์เด่นๆ ของเกมแนวนี้ขึ้นมาอีกไหมครับ?

* ต้องการเพิ่ม ระบบเช็กความต้องการของชั้นวางของ (Restocking System) ที่ผู้เล่นต้องเดินออกจากห้องทำงานไปจัดของเพิ่มความสมจริง?
* ต้องการระบบ ขีดพลังงานความกลัว (Panic/Sanity Meter) หากมืดเกินไปหรือส่องเจอผีนานๆ ตัวละครจะคุมสติไม่อยู่?
* ต้องการให้เปิดใช้ ระบบไฟล์เสียงสยองขวัญสุ่มดังขึ้นมา (Ambient Sound Effects) เพื่อสร้างบรรยากาศบีบคั้นกดดันขณะทำงานกะดึกครับ?

นี่คือโค้ดตัวอย่างเวอร์ชันเต็มสำหรับ Hellmart Demo บน Pygame ที่ได้รับการอัปเกรดระบบเพื่อความสยองขวัญและสมจริงยิ่งขึ้นตามที่คุณเลือกครับ โดยมีการเพิ่ม ระบบเติมสินค้าบนชั้นวาง (Restock), เกจวัดระดับความสติหลุด (Sanity Meter) และ ระบบส่งเสียงหลอนแบบสุ่ม (Ambient Sound) เข้าไปอย่างครบถ้วนครับ
## 💡 คำแนะนำสำหรับการติดตั้งระบบเสียง
โค้ดนี้จะใช้ไฟล์เสียงจริงผ่านระบบ pygame.mixer เพื่อหลีกเลี่ยใจงไม่ให้โค้ดพังหากไม่มีไฟล์เสียงในเครื่อง ระบบจะทำการข้ามการเล่นเสียงโดยอัตโนมัติ (พร้อมพิมพ์แจ้งเตือนใน Console) หากคุณมีไฟล์เสียงให้นำไปใส่ไว้ในโฟลเดอร์โครงการตามชื่อที่กำหนดในโค้ดได้เลยครับ
------------------------------
## โค้ดมาร์ทสยองขวัญเวอร์ชันสมบูรณ์ (Full Featured Demo)

import pygameimport sysimport random
# 1. การตั้งค่าระบบพื้นฐานและเสียง
pygame.init()
pygame.font.init()
pygame.mixer.init() # เปิดใช้งานระบบเสียง
WIDTH, HEIGHT = 800, 600screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart Nightshift - Advanced Demo")clock = pygame.time.Clock()
font_ui = pygame.font.SysFont("Courier New", 18, bold=True)font_thai = pygame.font.SysFont("Tahoma", 22, bold=True)
# โหลดระบบเสียงจำลอง (สามารถเปลี่ยนชื่อเป็นไฟล์ .mp3 หรือ .wav ที่คุณมีจริงได้)sound_enabled = Truetry:
    jumpscare_sound = pygame.mixer.Sound("sounds/jumpscare.wav")
    ambient_sounds = [
        pygame.mixer.Sound("sounds/whisper.wav"),
        pygame.mixer.Sound("sounds/footsteps.wav"),
        pygame.mixer.Sound("sounds/flicker.wav")
    ]except:
    print("[แจ้งเตือน] ไม่พบไฟล์เสียงในโฟลเดอร์ ระบบจะปิดเสียงและรันเฉพาะส่วนภาพ")
    sound_enabled = False
# 2. ตัวแปรสถานะและกลไกของเกม (Game States)# มุมมองหน้าจอ: 'OFFICE' (ห้องควบคุม), 'CCTV' (จอมอนิเตอร์), 'STORE' (ออกไปจัดของกลางร้าน)current_view = "OFFICE"current_cam = 1game_status = "PLAYING"
# ระบบเวลาgame_time = 0hour = 2  # เริ่มที่ 2 AM และจบที่ 6 AM
# --- ระบบที่ 1: จัดเรียงสินค้า (Restocking System) ---stock_needed = 100       # เปอร์เซ็นต์สินค้าบนชั้นวาง (เต็ม 100)restock_speed = 35       # กดค้างจะเติมสินค้าเพิ่มขึ้นวินาทีละ 35%
# --- ระบบที่ 2: ระดับสติ/ความกลัว (Sanity Meter) ---sanity = 100.0           # ค่าสติเต็ม 100panic_multiplier = 1.0   # ความเร็วในการลดของค่าสติ
# --- ระบบที่ 3: ระบบ AI ผีและเสียงหลอนสุ่ม ---ghost_level = 0          # 0=หลังร้าน, 1=ทางเดิน, 2=หน้าประตู, 3=พังประตูเข้ามาghost_timer = 0ambient_timer = 0
# ----------------------------------------------------# Main Game Loop# ----------------------------------------------------while True:
    dt = clock.tick(60) / 1000.0  # เวลาต่อเฟรม (วินาที)

    # รับอีเวนต์การกดปุ่ม (Event Handling)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.KEYDOWN and game_status == "PLAYING":
            # ปุ่ม Spacebar: สลับไปมาระหว่างห้องทำงาน (OFFICE) กับจอกล้อง (CCTV)
            if event.key == pygame.K_SPACE:
                if current_view == "OFFICE": current_view = "CCTV"
                elif current_view == "CCTV": current_view = "OFFICE"

            # ปุ่มลูกศร ขึ้น/ลง: เดินออกไปกลางร้าน (STORE) หรือกลับเข้าห้องทำงาน (OFFICE)
            if current_view in ["OFFICE", "STORE"]:
                if event.key == pygame.K_UP and current_view == "OFFICE":
                    current_view = "STORE"
                elif event.key == pygame.K_DOWN and current_view == "STORE":
                    current_view = "OFFICE"

            # ปุ่มเปลี่ยนกล้องวงจรปิด
            if current_view == "CCTV":
                if event.key == pygame.K_1: current_cam = 1
                if event.key == pygame.K_2: current_cam = 2
                if event.key == pygame.K_3: current_cam = 3

            # ปุ่ม E: เปิดสปอตไลท์ไล่ผีหน้าห้องควบคุม (ทำงานเฉพาะตอนอยู่หน้าจอ OFFICE)
            if current_view == "OFFICE" and event.key == pygame.K_e:
                if ghost_level == 2:
                    ghost_level = 0
                    ghost_timer = 0

    # ----------------------------------------------------
    # อัปเดตตรรกะเกม (Game Logic)
    # ----------------------------------------------------
    if game_status == "PLAYING":
        # ระบบเวลา: ผ่านไปทุกๆ 20 วินาทีเท่ากับ 1 ชั่วโมงในเกม
        game_time += dt
        if game_time >= 20:
            game_time = 0
            hour += 1
            if hour >= 6: game_status = "WIN"

        # สินค้าบนชั้นค่อยๆ ลดลงตามเวลา (มีคนแอบมาหยิบซื้อไป)
        if current_view != "STORE":
            stock_needed -= dt * 3.0  # ลดลงวินาทีละ 3%
            if stock_needed < 0: stock_needed = 0

        # เติมสินค้าเมื่อผู้เล่นก้าวออกไปกลางร้าน (STORE) แล้วกดปุ่ม R ค้างไว้
        if current_view == "STORE":
            keys = pygame.key.get_pressed()
            if keys[pygame.K_r]:
                stock_needed += dt * restock_speed
                if stock_needed > 100: stock_needed = 100

        # --- คำนวณขีดพลังงานความกลัว (Sanity) ---
        # 1. ถ้าสินค้าบนชั้นหมด (0%) ตัวละครจะเริ่มประสาทเสีย
        if stock_needed <= 0: sanity -= dt * 5.0
        # 2. ถ้าผีมาประชิดหน้าห้อง (level 2) ค่าสติจะลดฮวบอย่างรวดเร็ว
        if ghost_level == 2: sanity -= dt * 8.0
        # 3. ถ้าปล่อยให้ค่าสติเหลือ 0 ตัวละครจะหัวใจวายตาย (Game Over)
        if sanity <= 0:
            sanity = 0
            game_status = "GAMEOVER"

        # --- AI ผีขยับตัวตามเวลา ---
        ghost_timer += dt
        if ghost_timer >= 5.0:  # ทุกๆ 5 วินาทีผีมีโอกาสขยับ
            ghost_timer = 0
            if random.random() < 0.55:
                ghost_level += 1
                if ghost_level >= 3:
                    if sound_enabled: jumpscare_sound.play()
                    game_status = "GAMEOVER"

        # --- ระบบเสียงหลอน Ambient สุ่มส่งเสียงประหลาด ---
        ambient_timer += dt
        if ambient_timer >= 8.0:  # สุ่มตรวจเช็กทุกๆ 8 วินาที
            ambient_timer = 0
            if random.random() < 0.40 and sound_enabled:
                random.choice(ambient_sounds).play()  # สุ่มเล่นเสียงกระซิบหรือเสียงฝีเท้า

    # ----------------------------------------------------
    # การวาดหน้าจอแสดงผล (Rendering)
    # ----------------------------------------------------
    screen.fill((10, 10, 12))  # คุมโทนสีมืดสยองขวัญ

    if game_status == "PLAYING":
        # ----------------------------------------------------
        # ฉากที่ 1: ห้องควบคุมและกระจกหน้าต่าง (OFFICE)
        # ----------------------------------------------------
        if current_view == "OFFICE":
            pygame.draw.rect(screen, (25, 25, 30), (100, 100, 600, 300))
            if ghost_level == 2:
                pygame.draw.ellipse(screen, (130, 0, 0), (360, 140, 80, 220)) # เงาผีสีแดงหน้ากระจก
                txt_warn = font_thai.render("!มีเงาสีแดงอยู่หน้าประตู! กด [E] เพื่อเปิดไฟสปอตไลท์ไล่มันไป!", True, (255, 50, 50))
                screen.blit(txt_warn, (110, 60))
            else:
                txt_info = font_thai.render("ทางเดินนอกห้องเงียบสงบ... [กดลูกศรขึ้น ↑] เพื่อออกไปจัดของหน้าร้าน", True, (200, 200, 200))
                screen.blit(txt_info, (80, 60))

            pygame.draw.rect(screen, (45, 45, 45), (0, 400, 800, 200)) # โต๊ะทำงาน
            screen.blit(font_ui.render("[SPACE]: ตรวจกล้อง CCTV | [ARROW UP ↑]: ออกไปกลางร้าน", True, (0, 255, 0)), (180, 480))

        # ----------------------------------------------------
        # ฉากที่ 2: จอมอนิเตอร์กล้องวงจรปิด (CCTV)
        # ----------------------------------------------------
        elif current_view == "CCTV":
            pygame.draw.rect(screen, (30, 45, 30), (50, 50, 700, 420)) # หน้าจอเขียวมืด
            txt_menu = font_ui.render("PRESS CODES: [1] CAM 01 | [2] CAM 02 | [3] CAM 03  |  [SPACE]: Close Monitor", True, (0, 255, 0))
            screen.blit(txt_menu, (60, 490))

            # แยกส่องผีตามพิกัดของกล้องวงจรปิดแต่ละตัว
            if current_cam == 1:
                if ghost_level == 2: pygame.draw.circle(screen, (200, 0, 0), (400, 240), 30)
                screen.blit(font_ui.render("CCTV: CAM 01 - FRONT DOOR WINDOW", True, (0, 255, 0)), (70, 70))
            elif current_cam == 2:
                if ghost_level == 1: pygame.draw.circle(screen, (200, 0, 0), (250, 280), 30)
                screen.blit(font_ui.render("CCTV: CAM 02 - BEVERAGE & SHELVES", True, (0, 255, 0)), (70, 70))
            elif current_cam == 3:
                if ghost_level == 0: pygame.draw.circle(screen, (200, 0, 0), (500, 200), 30)
                screen.blit(font_ui.render("CCTV: CAM 03 - BACKROOM STORAGE", True, (0, 255, 0)), (70, 70))
            
            # เส้นสัญญาณแทรก (Static Noise Effect)
            pygame.draw.line(screen, (80, 110, 80), (50, random.randint(50, 470)), (750, random.randint(50, 470)), 1)

        # ----------------------------------------------------
        # ฉากที่ 3: พื้นที่ร้านค้าหน้าร้านเพื่อจัดของ (STORE)
        # ----------------------------------------------------
        elif current_view == "STORE":
            # วาดเชลฟ์วางของซ้ายขวา
            pygame.draw.rect(screen, (60, 60, 65), (100, 150, 150, 300))
            pygame.draw.rect(screen, (60, 60, 65), (550, 150, 150, 300))
            
            # ป้ายเตือนระบบจัดของ
            txt_stock_hint = font_thai.render("กดปุ่ม [R] ค้างไว้เพื่อเติมสินค้าขึ้นชั้นวาง", True, (255, 255, 255))
            screen.blit(txt_stock_hint, (240, 80))
            screen.blit(font_ui.render("[ARROW DOWN ↓]: กลับเข้าห้องควบคุมที่ปลอดภัย", True, (255, 100, 100)), (210, 500))

            # ส่องเห็นผีแวบๆ ตรงทางเดิน (level 1) หากเราออกจัดของโดยไม่ระวัง
            if ghost_level == 1:
                pygame.draw.ellipse(screen, (100, 0, 0), (380, 200, 50, 150))

        # ----------------------------------------------------
        # ส่วนแสดงผลแถบสถานะส่วนกลาง (HUD UI)
        # ----------------------------------------------------
        # แสดงเวลาทำงาน
        screen.blit(font_ui.render(f"SHIFT TIME: {hour}:00 AM", True, (255, 255, 255)), (25, 20))
        
        # แสดงขีดพลังงานสินค้าคงเหลือ (ถ้าลดลงเหลือน้อย แถบจะเปลี่ยนจากสีฟ้าเป็นสีส้มเตือนความหลอน)
        stock_color = (0, 180, 255) if stock_needed > 30 else (255, 140, 0)
        pygame.draw.rect(screen, (40, 40, 40), (580, 15, 200, 15))
        pygame.draw.rect(screen, stock_color, (580, 15, int(stock_needed * 2), 15))
        screen.blit(font_ui.render(f"SHELF STOCK: {int(stock_needed)}%", True, (255, 255, 255)), (410, 13))

        # แสดงขีดพลังความกลัว/ระดับสติ (Sanity Bar) วางไว้ด้านล่างหน้าจอ
        sanity_color = (0, 255, 0) if sanity > 60 else (255, 255, 0) if sanity > 25 else (255, 0, 0)
        pygame.draw.rect(screen, (30, 30, 30), (250, 555, 300, 15))

pygame.draw.rect(screen, sanity_color, (250, 555, int(sanity * 3), 15))
screen.blit(font_ui.render(f"SANITY: {int(sanity)}%", True, sanity_color), (350, 532))
elif game_status == "GAMEOVER":
screen.fill((15, 0, 0))
msg = "คุณเสียสติหรือถูกสิ่งลี้ลับจู่โจม... GAME OVER" if sanity <= 0 else "มันพังประตูเข้ามาได้... GAME OVER"
screen.blit(font_thai.render(msg, True, (255, 0, 0)), (210, 280))
elif game_status == "WIN":
screen.fill((0, 25, 10))
screen.blit(font_thai.render("06:00 AM! ฟ้าสางแล้ว คุณทำภารกิจกะดึกสำเร็จและรอดชีวิต!", True, (0, 255, 0)), (130, 280))
pygame.display.flip()


---

### 🎮 คำแนะนำสำหรับการทดลองเล่น Demo นี้:
1. **การวนลูปการทำงาน:** เริ่มต้นคุณต้องมองผ่านหน้าต่าง (`OFFICE`) หรือสลับไปดูกล้องวงจรปิด (`SPACE`) เพื่อตรวจสอบว่าผีขยับจากจุด 3 มาจุด 2 หรือยัง
2. **การทำเควสต์จัดของ:** ค่า `SHELF STOCK` มุมบนขวาจะลดลงเรื่อยๆ คุณต้องกดปุ่ม `↑` เพื่อออกไปกลางร้านแล้ว**กดปุ่ม R ค้างไว้** เพื่อรีบเติมสต็อกให้เต็ม หากปล่อยให้สินค้าหมดเป็นเวลานาน ค่าสติ (`SANITY`) ด้านล่างจะลดลงฮวบๆ จนแพ้เกม
3. **การเอาชีวิตรอด:** หากกล้องช่อง 1 หรือหน้าต่างห้องแจ้งเตือนว่ามีผีสีแดงมาประชิดหน้าประตู ให้รีบกด `E` เพื่อฉายไฟสปอตไลท์ขับไล่ผีให้ถอยกลับไปหลังร้านทันทีครับ

หากคุณมีข้อสงสัยเกี่ยวกับการเขียนตรรกะในฟังก์ชันส่วนใด หรืออยากให้ช่วยแนะนำวิธีการจัดระเบียบโค้ดตัวนี้แยกเป็นคลาส (Object-Oriented Programming) แจ้งต่อได้เลยนะครับ!




* [The Escape to the Afterlife Demo](https://www.youtube.com/watch?v=2hjmCdz-Sas): เกมผีญี่ปุ่นที่เราต้องรับบทเป็นวิญญาณหลงทางอยู่ในโลกหลังความตาย และมีผีหน้าขาวคอยเดินตาม
* [Catechesis Demo](https://www.youtube.com/watch?v=sHwqTc-vcHU): เกมสยองขวัญแนวพิกเซลจากผู้สร้าง Yuppie Psycho ที่เนื้อเรื่องเกี่ยวกับเด็กวัดที่กลายเป็นร่างทรงปีศาจ
* [Subliminal Demo](https://www.youtube.com/watch?v=vjaTiyXT8qk): เกมที่ตัวเอกติดอยู่ในฝันร้ายที่เป็นสวนน้ำสีเหลือง-ขาวขนาดใหญ่ที่หลอนและอ้างว้าง
* [EXCUSE ME SIR (Demo)](https://www.youtube.com/watch?v=8orqW9wPfbA): เกมผีหลอนๆ บรรยากาศแปลกๆ ที่มีผู้หญิงมาชวนตัวเอกลงไปดูห้องใต้ดิน
* [Dread Flats Demo](https://www.youtube.com/watch?v=1Orcak5JKG0): เกมสั้นแนว YouTuber สายล่าท้าผีที่เข้าไปบุกรุกอพาร์ทเม้นท์ของคุณป้าสุดหลอน
* [Endacopia Demo](https://www.youtube.com/watch?v=MA9Nawzn9yg): เกมอินดี้ภาพแนว Point-and-Click สไตล์พิกเซลโบราณ ช่วยเหลือน้อง Mellow ตามหาบ้าน [1, 2, 3, 4, 5, 6, 7, 8, 9] 
* 

------------------------------
เพื่อให้ผมหา ชื่อเกมหรือคลิปที่ถูกต้อง ให้คุณได้ทันที ลองบอกใบ้รายละเอียดเพิ่มอีกนิดครับ:

* 
* ลักษณะของ ผีหรือสิ่งแปลกประหลาด ในเกมเป็นอย่างไร? (เช่น ผีผู้หญิง, สัตว์ประหลาด, หุ่นยนต์, หรือสิ่งของขยับได้)
* สถานที่ ในเกมคือที่ไหน? (เช่น โรงเรียน, โรงพยาบาล, ร้านสะดวกซื้อ, บ้านร้าง, หรือในป่า)
* มุมมองของเกม เป็นแบบไหน? (เช่น มุมมองบุคคลที่ 1 เห็นแค่หมัด/ไฟฉาย หรือมุมมองบุคคลที่ 3 เห็นตัวละครเดิน)
* 


[1] [https://www.youtube.com](https://www.youtube.com/c/aitolh/videos)
[2] [https://www.youtube.com](https://www.youtube.com/watch?v=1Orcak5JKG0)
[3] [https://www.youtube.com](https://www.youtube.com/watch?v=rdzLNvGalpw)
[4] [https://www.youtube.com](https://www.youtube.com/watch?v=CApXn0eb-QI)
[5] [https://www.youtube.com](https://www.youtube.com/watch?v=2hjmCdz-Sas)
[6] [https://www.youtube.com](https://www.youtube.com/watch?v=vjaTiyXT8qk)
[7] [https://www.youtube.com](https://www.youtube.com/watch?v=8orqW9wPfbA)
[8] [https://www.youtube.com](https://www.youtube.com/watch?v=8orqW9wPfbA)
[9] [https://www.youtube.com](https://www.youtube.com/watch?v=MA9Nawzn9yg)

หากคุณต้องการสร้าง เกมผีเวอร์ชันเดโม ด้วยภาษา Python ในสไตล์เกมอินดี้สยองขวัญ (Horror Game) ที่คนนิยมเล่นกัน โค้ดด้านล่างนี้คือตัวอย่างระบบเกมผีมุมมองบุคคลที่ 1 (First-Person Perspective) แบบ 3 มิติเบื้องต้น โดยใช้ไลบรารี ursina ซึ่งเป็นเอนจินที่เขียนง่ายและสร้างบรรยากาศเกมผีได้ดีที่สุดใน Python ครับ
ในเดโมนี้จะประกอบไปด้วย: ระบบเดิน/หันมุมกล้อง, บรรยากาศเขาวงกตที่มืดมิด, ไฟฉายติดตัว, และ ระบบลูปเสียงหัวใจเต้นสั่นประสาท เมื่อผีเข้ามาใกล้ครับ
------------------------------
## ขั้นตอนการเตรียมตัวก่อนรันโค้ด
ให้คุณเปิด Terminal หรือ Command Prompt แล้วติดตั้งไลบรารีที่จำเป็นก่อน:

pip install ursina

------------------------------
## โค้ด Python สำหรับสร้างเกมผีเดโม (Horror Game Demo)
คัดลอกโค้ดนี้ไปเซฟเป็นไฟล์ชื่อ ghost_game.py แล้วสั่งรันได้ทันทีครับ:

from ursina import *from ursina.prefabs.first_person_controller import FirstPersonControllerimport random
# 1. เริ่มต้นระบบเกมapp = Ursina()
# กำหนดหน้าต่างเกมและปิดการแสดงปุ่ม FPS มาตรฐาน
window.fps_counter.enabled = False
window.exit_button.enabled = False
# 2. สร้างแผนที่/ฉาก (สร้างเขาวงกตทางเดินแคบๆ ชวนหลอน)# ใช้บล็อกสี่เหลี่ยมสร้างกำแพงสีเทาเข้มwall_texture = 'white_cube' # ใช้สีพื้นฐานของเอนจินmaze_data = [
    [1,1,1,1,1,1,1,1,1,1],
    [1,0,0,0,1,0,0,0,0,1],
    [1,0,1,0,1,0,1,1,0,1],
    [1,0,1,0,0,0,0,1,0,1],
    [1,0,1,1,1,1,0,1,0,1],
    [1,0,0,0,0,1,0,0,0,1],
    [1,1,1,1,0,1,1,1,0,1],
    [1,0,0,0,0,0,0,1,0,1],
    [1,0,1,1,1,1,0,0,0,1],
    [1,1,1,1,1,1,1,1,1,1],
]
walls = []for z in range(len(maze_data)):
    for x in range(len(maze_data[z])):
        if maze_data[z][x] == 1:
            # สร้างกำแพงสูง 3 หน่วย
            wall = Entity(
                model='cube',
                position=(x*3, 1.5, z*3),
                scale=(3, 3, 3),
                texture=wall_texture,
                color=color.dark_gray,
                collider='box'
            )
            walls.append(wall)
# สร้างพื้นและเพดานเพื่อปิดแสงภายนอกfloor = Entity(model='plane', scale=(100,1,100), texture='white_cube', color=color.black, collider='box')ceiling = Entity(model='plane', position=(15, 3, 15), scale=(100,1,100), texture='white_cube', color=color.black, rotation_x=180)
# 3. ตัวละครผู้เล่น (มุมมองบุคคลที่ 1)player = FirstPersonController(position=(3, 0, 3))
player.cursor.visible = False # ซ่อนเมาส์
# ระบบไฟฉายติดตัว (Spotlight) ส่องไปข้างหน้าตามมุมกล้องflashlight = SpotLight(parent=camera, position=(0,0,0), direction=(0,0,1), color=color.rgb(255,250,220), attentuation=0.1)
# 4. ตัวละคร "ผี" (Jumpscare Entity)# ในเดโมนี้จะใช้หุ่นสี่เหลี่ยมสีแดงซีด เป็นตัวแทนความสยองขวัญghost = Entity(
    model='cube',
    position=(24, 1, 24), # แอบอยู่สุดทางของเขาวงกต
    scale=(1, 2, 1),
    color=color.rgb(150, 0, 0),
    collider='box'
)
# ข้อความเตือนบนหน้าจอ (UI)ui_text = Text(text="Find the exit... beware of the red shadow", position=(-0.4, 0.4), color=color.white, scale=1.5)
# 5. ฟังก์ชันอัปเดตระบบเกมในทุกๆ เฟรม (Game Loop อัตโนมัติของ Ursina)def update():
    # ให้ผีค่อยๆ หันหน้ามาหาผู้เล่น
    ghost.look_at(player.position)
    
    # คำนวณระยะห่างระหว่างผู้เล่นกับผี
    distance = tuple_distance(player.position, ghost.position)
    
    # ระบบ AI ผี: ถ้าผู้เล่นเข้าใกล้ในระยะ 15 หน่วย ผีจะเริ่มลอยไล่ล่าตามผู้เล่น
    if distance < 15:
        ui_text.text = "RUN!!"
        ui_text.color = color.red
        # เคลื่อนที่เข้าหาผู้เล่นทีละน้อย
        ghost.position = list_lerp(ghost.position, player.position, time.dt * 0.8)
        ghost.y = 1 # ล็อคความสูงผีไว้ไม่ให้จมดิน
        
    # เงื่อนไข Jumpscare / Game Over (เมื่อผีประชิดตัวในระยะ 1.5 หน่วย)
    if distance < 1.5:
        ui_text.text = "YOU DIED"
        ui_text.scale = 4
        ui_text.position = (-0.25, 0)
        player.disable() # ล็อคไม่ให้ผู้เล่นขยับ
        camera.look_at(ghost.position) # บังคับหันไปมองหน้าผี
# ฟังก์ชันคำนวณระยะห่างทางคณิตศาสตร์แบบง่ายdef tuple_distance(p1, p2):
    return ((p1.x - p2.x)**2 + (p1.z - p2.z)**2)**0.5
# รันแอปพลิเคชันเกม
app.run()

------------------------------
## วิธีควบคุมในหน้าจอ Demo

* 
* เมาส์: ขยับหันมุมกล้อง 360 องศา
* ปุ่ม W, A, S, D: เดินหน้า, ซ้าย, ถอยหลัง, ขวา
* ปุ่ม Spacebar: กระโดด
* ปุ่ม Esc: หากต้องการปิดเกมให้กดปุ่มสลับหน้าจอออกแล้วปิดที่ตัว Terminal
* 

------------------------------
หากคุณต้องการนำระบบนี้ไปพัฒนาต่อให้เหมือนเกมผีในช่องพี่ไอโตะมากขึ้น สามารถบอกผมได้นะครับว่าอยากเพิ่มส่วนไหน:

* 
* ต้องการให้เพิ่ม ปุ่มกดเปิด-ปิดไฟฉาย (F) พร้อมแถบแบตเตอรี่สีเขียว/แดง?
* ต้องการระบบ กล่องคำพูดเนื้อเรื่องเล่าประวัติความเป็นมา ก่อนเข้าบ้านร้าง?
* ต้องการเพิ่ม ไอเทมกุญแจให้เดินเก็บตามทาง เพื่อปลดล็อคประตูก่อนโดนผีจับ?
* 





นี่คือการอัปเกรดโค้ดเกมผีเดโมของคุณให้มีระบบที่ซับซ้อนและน่าตื่นเต้นเหมือนเกมที่คุณเห็นในช่องแคสต์เกมเลยครับ! โค้ดด้านล่างนี้ได้รวบรวม ระบบเปิด-ปิดไฟฉายด้วยปุ่ม F, แถบพลังงานแบตเตอรี่, กล่องข้อความเล่าเรื่องช่วงเริ่มเกม, และ ระบบเก็บกุญแจเปิดประตู เข้าไว้ด้วยกันอย่างสมบูรณ์แบบครับ
## การติดตั้งเพิ่มเติม
หากต้องการให้แสดงแถบแบตเตอรี่เป็นรูปทรงเหลี่ยมที่สวยงาม คุณสามารถรันโค้ดนี้ได้ทันทีโดยไม่ต้องลงอะไรเพิ่ม (ใช้โมดูล UI พื้นฐานของ Ursina)
------------------------------
## โค้ด Python เกมผีเดโมระบบขั้นสูง (Advanced Horror Demo)

from ursina import *from ursina.prefabs.first_person_controller import FirstPersonController
app = Ursina()
# ปิดระบบ UI มาตรฐานของเอนจิน
window.fps_counter.enabled = False
window.exit_button.enabled = False
# ----------------------------------------------------# 1. การตั้งค่าแผนที่และสิ่งแวดล้อม (Map & Items)# ----------------------------------------------------# สร้างเขาวงกตขนาดเล็กmaze_data = [,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
 ,
]
for z in range(len(maze_data)):
    for x in range(len(maze_data[z])):
        if maze_data[z][x] == 1:
            Entity(model='cube', position=(x*3, 1.5, z*z*0.5 if z>5 else z*3), scale=(3, 3, 3), color=color.dark_gray, collider='box')
floor = Entity(model='plane', scale=(100,1,100), color=color.black, collider='box')ceiling = Entity(model='plane', position=(15, 3, 15), scale=(100,1,100), color=color.black, rotation_x=180)
# สร้างประตูทางออก (สีน้ำตาล)door = Entity(model='cube', position=(24, 1.5, 21), scale=(0.5, 3, 3), color=color.brown, collider='box')
# สร้างกุญแจสำหรับเก็บ (สีทอง ลอยหมุนอยู่กับที่)key_item = Entity(model='cube', position=(3, 1, 24), scale=(0.3, 0.3, 0.3), color=color.gold, collider='box')
# สร้างผี (โมเดลสีแดงซีด)ghost = Entity(model='cube', position=(24, 1, 24), scale=(1, 2, 1), color=color.rgb(150, 0, 0), collider='box')
# ----------------------------------------------------# 2. ตัวละครผู้เล่น และ ระบบไฟฉาย (Player & Flashlight)# ----------------------------------------------------player = FirstPersonController(position=(3, 0, 3))
player.cursor.visible = False
# ติดตั้งไฟฉายส่องสว่างไว้ที่มุมกล้องflashlight = SpotLight(parent=camera, position=(0,0,0), direction=(0,0,1), color=color.rgb(255,255,220), attentuation=0.1)
# สถานะตัวแปรในเกมhas_key = Falsegame_state = "STORY" # มีสถานะ: STORY, PLAYING, GAMEOVER, WINbattery_level = 100.0 # แบตเตอรี่เต็ม 100flashlight_on = True
# ----------------------------------------------------# 3. ระบบอินเตอร์เฟซและกล่องข้อความ (UI System)# ----------------------------------------------------# กล่องข้อความเล่าเนื้อเรื่องประวัติความเป็นมาstory_panel = WindowPanel(
    title='Prologue: The Abandoned House',
    content=[
        Text("บ้านร้างหลังนี้มีตำนานเล่าขานถึงผู้ที่เข้าไปแล้วไม่ได้กลับออกมา..."),
        Text("คุณตัดสินใจท้าทายความมืดเพื่อพิสูจน์ความจริงบางอย่าง"),
        Text("ภารกิจ: ตามหากุญแจสีทองเพื่อเปิดประตูหนีออกไปให้ได้ก่อน 'มัน' จะเจอคุณ!"),
        Text(""),
        Button(text='[ คลิกเพื่อเริ่มเกม ]', color=color.red, on_click=lambda: start_game())
    ],
    popup=True
)
player.disable() # ล็อคผู้เล่นไว้ตอนอ่านเนื้อเรื่อง
# UI แจ้งเตือนสถานการณ์ในเกมstatus_text = Text(text="", position=(-0.4, 0.4), color=color.white, scale=1.5, enabled=False)
# แถบแบตเตอรี่ไฟฉาย (วางไว้มุมขวาบน)battery_bg = Entity(parent=camera.ui, model='quad', position=(0.6, 0.45), scale=(0.3, 0.03), color=color.black66, enabled=False)battery_bar = Entity(parent=camera.ui, model='quad', position=(0.45, 0.45), scale=(0.3, 0.03), color=color.green, origin=(-0.5, 0), enabled=False)battery_label = Text(parent=camera.ui, text="FLASHLIGHT BATTERY", position=(0.45, 0.49), scale=0.8, color=color.white, enabled=False)
def start_game():
    global game_state
    game_state = "PLAYING"
    story_panel.enabled = False
    player.enable()
    status_text.enabled = True
    battery_bg.enabled = True
    battery_bar.enabled = True
    battery_label.enabled = True
    status_text.text = "Find the gold key to unlock the brown door."
# ----------------------------------------------------# 4. ระบบอินพุตคีย์บอร์ด (เปิด-ปิดไฟฉาย ปุ่ม F)# ----------------------------------------------------def input(key):
    global flashlight_on
    if game_state == "PLAYING":
        if key == 'f':
            if battery_level > 0:
                flashlight_on = not flashlight_on
                if flashlight_on:
                    flashlight.color = color.rgb(255,255,220)
                else:
                    flashlight.color = color.black
            else:
                status_text.text = "Battery is dead! Cannot turn on."
# ----------------------------------------------------# 5. ลูปอัปเดตเกม (Game Logic Loop)# ----------------------------------------------------def update():
    global battery_level, flashlight_on, has_key, game_state
    
    if game_state != "PLAYING":
        return

    # เอฟเฟกต์หมุนกุญแจให้ดูมีมิติ
    if key_item.enabled:
        key_item.rotation_y += time.dt * 50

    # --- ระบบแบตเตอรี่ไฟฉาย ---
    if flashlight_on and battery_level > 0:
        battery_level -= time.dt * 2.5 # แบตเตอรี่ลดลงวินาทีละ 2.5 หน่วย (อยู่ได้ประมาณ 40 วินาที)
        # ปรับความยาวของแถบตามปริมาณแบตที่เหลือ
        battery_bar.scale_x = (battery_level / 100.0) * 0.3
        
        # เปลี่ยนสีแถบตามปริมาณพลังงาน
        if battery_level > 50:
            battery_bar.color = color.green
        elif battery_level > 20:
            battery_bar.color = color.yellow
        else:
            battery_bar.color = color.red
            
        if battery_level <= 0:
            battery_level = 0
            flashlight_on = False
            flashlight.color = color.black
            status_text.text = "Flashlight battery died! You are in total darkness!"

    # --- ระบบคำนวณระยะห่างเพื่อเก็บไอเทมและระบบผี ---
    dist_to_key = (player.position - key_item.position).length()
    dist_to_door = (player.position - door.position).length()
    dist_to_ghost = (player.position - ghost.position).length()

    # ระบบเดินเก็บกุญแจ
    if key_item.enabled and dist_to_key < 2.0:
        key_item.enabled = False
        has_key = True
        status_text.text = "You found the key! Go to the brown door to escape!"
        status_text.color = color.gold

    # ระบบเปิดประตูเพื่อชนะเกม
    if has_key and dist_to_door < 2.5:
        game_state = "WIN"
        status_text.text = "YOU ESCAPED! YOU WIN!"
        status_text.scale = 3
        status_text.position = (-0.3, 0)
        status_text.color = color.green
        player.disable()

    # ระบบ AI ผีตามล่า
    ghost.look_at(player.position)
    if dist_to_ghost < 15:
        if has_key == False:
            status_text.text = "IT'S COMING! RUN!"
            status_text.color = color.red
        # ผีลอยไล่กวดผู้เล่น
        ghost.position = list_lerp(ghost.position, player.position, time.dt * 0.9)
        ghost.y = 1

    # ระบบโดนผีจับ (Game Over)
    if dist_to_ghost < 1.5:
        game_state = "GAMEOVER"
        status_text.text = "YOU DIED\nCaught by the entity."
        status_text.scale = 3
        status_text.position = (-0.2, 0)
        status_text.color = color.red
        player.disable()
        camera.look_at(ghost.position)

app.run()

------------------------------
## รายละเอียดลูกเล่นใหม่ในโค้ดเดโมนี้:

   1. WindowPanel ตอนเริ่มเกม: จะมีกล่องขึ้นมาตัดหน้าจอเกมเพื่อเล่าประวัติเบื้องต้น ให้คุณกดปุ่มสีแดงเพื่อสลับเข้าโหมดเล่นเกมได้ทันที
   2. ระบบแบตเตอรี่เปลี่ยนสีตามจริง: ด้านบนขวาจะมีแถบพลังงาน โดยเริ่มจาก สีเขียว พอเหลือครึ่งเดียวจะเปลี่ยนเป็น สีเหลือง และเมื่อใกล้หมดจะกระพริบเตือนเป็น สีแดง หากแบตหมดไฟจะดับสนิทถาวร เพิ่มความกดดันแบบสุดๆ
   3. เงื่อนไขชัยชนะ: หากผู้เล่นเดินไปชนกล่องสีทอง (กุญแจ) จะเป็นการเก็บไอเทม จากนั้นเมื่อเดินไปที่ประตูกล่องสีน้ำตาล เกมจะเปลี่ยนสถานะเป็นชนะทันทีครับ

หากคุณทดสอบแล้ว อยากใส่ลูกเล่นเสียงประกอบความหลอนเพิ่มเข้ามา เช่น เสียงหัวใจเต้นตึกๆ เวลาผีเข้าใกล้ หรืออยากได้ระบบ สุ่มตำแหน่งเกิดของกุญแจ ทุกครั้งที่เริ่มเกมไม่ให้ซ้ำกัน แจ้งความต้องการต่อได้เลยนะครับ!

นี่คือการนำโค้ดเกมมาร์ทสยองขวัญ (Hellmart Demo) มาจัดโครงสร้างใหม่ทั้งหมดในรูปแบบ OOP (Object-Oriented Programming) [เขียนโปรแกรมเชิงวัตถุ] ครับ
การใช้ OOP จะช่วยให้โค้ดของคุณแยกสัดส่วนชัดเจน ขยายระบบได้ง่าย ไม่รก และแก้ไขได้ทีละส่วน โดยเราจะแบ่งคลาสออกเป็นกลุ่มหน้าที่หลักๆ ดังนี้:

   1. Ghost: จัดการสถานะ AI และการขยับตัวของผี
   2. StoreSystem: จัดการคะแนน สต็อกสินค้า และค่าสติ (Sanity)
   3. GameManager: คุมสถานะเกม (Loop, Time, Render และ Scene)

------------------------------
## โครงสร้างโค้ดแบบ OOP (Hellmart Advanced Object-Oriented)
คุณสามารถนำโค้ดที่จัดระเบียบตามหลัก OOP ชุดนี้ไปใช้งานและพัฒนาต่อได้ทันทีครับ:

import pygameimport sysimport random
# เริ่มต้นระบบ Pygame
pygame.init()
pygame.font.init()
# ตั้งค่าหน้าจอคงที่WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart Nightshift - OOP Edition")
# ฟอนต์แชร์ส่วนกลางFONT_UI = pygame.font.SysFont("Courier New", 18, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 22, bold=True)

# ====================================================# 1. คลาสจัดการระบบ "ผี" (Ghost Agent)# ====================================================class Ghost:
    def __init__(self):
        self.level = 0          # 0=คลังสินค้า, 1=ทางเดิน, 2=หน้าห้องทำงาน, 3=Jumpscare
        self.move_timer = 0.0
        self.move_interval = 5.0 # ทุกๆ 5 วินาทีจะมีโอกาสขยับ
        
    def update(self, dt):
        """ตรรกะ AI การเคลื่อนที่เข้าใกล้ผู้เล่น"""
        self.move_timer += dt
        if self.move_timer >= self.move_interval:
            self.move_timer = 0
            # มีโอกาส 55% ที่จะขยับเลื่อนขั้นเข้ามา
            if random.random() < 0.55:
                self.level += 1

    def scare_away(self):
        """โดนไฟส่อง ไล่กลับไปจุดเริ่มต้น"""
        self.level = 0
        self.move_timer = 0

# ====================================================# 2. คลาสจัดการระบบ "มาร์ทและค่าสถานะผู้เล่น" (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.stock = 100.0
        self.sanity = 100.0
        self.hour = 2          # เริ่มต้นที่ 2 AM
        self.time_accumulator = 0.0
        self.hour_duration = 20.0 # 20 วินาที = 1 ชั่วโมง
        
    def update(self, dt, current_view, ghost_level):
        """คำนวณเวลา สต็อก และความกลัว"""
        # อัปเดตเวลาทำงาน
        self.time_accumulator += dt
        if self.time_accumulator >= self.hour_duration:
            self.time_accumulator = 0
            self.hour += 1

        # อัปเดตสต็อกสินค้า (ลดลงเมื่อไม่ได้อยู่หน้าร้าน)
        if current_view != "STORE":
            self.stock -= dt * 3.0
            if self.stock < 0: self.stock = 0

        # คำนวณค่าสติ (Sanity)
        if self.stock <= 0:
            self.sanity -= dt * 5.0 # เครียดเพราะของหมด
        if ghost_level == 2:
            self.sanity -= dt * 8.0 # กลัวเพราะผีมายืนจ้อง
            
        if self.sanity < 0: self.sanity = 0

    def restock(self, dt):
        """เติมสินค้าบนชั้นวาง"""
        self.stock += dt * 35.0
        if self.stock > 100: self.stock = 100

# ====================================================# 3. คลาสหลักควบคุมเกมทั้งหมด (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.view = "OFFICE"    # โหมดหน้าจอ: OFFICE, CCTV, STORE
        self.cctv_cam = 1       # ช่องกล้องวงจรปิด: 1, 2, 3
        self.status = "PLAYING" # สถานะ: PLAYING, GAMEOVER, WIN
        
        # เชื่อมโยงอ็อบเจกต์ย่อยเข้ามาใช้งาน (Composition)
        self.ghost = Ghost()
        self.store = StoreSystem()

    def handle_events(self):
        """จัดการการรับค่าอินพุตทั้งหมด"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

            if event.type == pygame.KEYDOWN and self.status == "PLAYING":
                # ปุ่มสลับจอมอนิเตอร์
                if event.key == pygame.K_SPACE:
                    self.view = "CCTV" if self.view == "OFFICE" else "OFFICE"

                # ปุ่มเดินเข้า-ออกห้องทำงาน
                if self.view in ["OFFICE", "STORE"]:
                    if event.key == pygame.K_UP and self.view == "OFFICE":
                        self.view = "STORE"
                    elif event.key == pygame.K_DOWN and self.view == "STORE":
                        self.view = "OFFICE"

                # ปุ่มเปลี่ยนกล้องวงจรปิด
                if self.view == "CCTV":
                    if event.key in [pygame.K_1, pygame.K_2, pygame.K_3]:
                        self.cctv_cam = int(event.unicode)

                # ปุ่ม E เปิดไฟไล่ผี
                if self.view == "OFFICE" and event.key == pygame.K_e:
                    if self.ghost.level == 2:
                        self.ghost.scare_away()

    def update(self):
        """อัปเดตสถานะ logic ทุกอย่างตามเวลาจริง"""
        dt = self.clock.tick(60) / 1000.0  # Delta Time

        if self.status == "PLAYING":
            self.ghost.update(dt)
            self.store.update(dt, self.view, self.ghost.level)

            # ตรวจสอบการเติมสินค้า (กด R ค้าง)
            if self.view == "STORE":
                keys = pygame.key.get_pressed()
                if keys[pygame.K_r]:
                    self.store.restock(dt)

            # ตรวจสอบเงื่อนไขการแพ้-ชนะ
            if self.ghost.level >= 3 or self.store.sanity <= 0:
                self.status = "GAMEOVER"
            elif self.store.hour >= 6:
                self.status = "WIN"

    def render(self):
        """วาดกราฟิกแยกตาม View ปัจจุบัน"""
        SCREEN.fill((10, 10, 12))

        if self.status == "PLAYING":
            # --- 1. หน้าจอห้องควบคุม (OFFICE) ---
            if self.view == "OFFICE":
                pygame.draw.rect(SCREEN, (25, 25, 30), (100, 100, 600, 300))
                if self.ghost.level == 2:
                    pygame.draw.ellipse(SCREEN, (130, 0, 0), (360, 140, 80, 220))
                    txt = FONT_THAI.render("!พบสิ่งผิดปกติหน้ากระจก! กด [E] เพื่อเปิดไฟฉายไล่", True, (255, 50, 50))
                else:
                    txt = FONT_THAI.render("นอกห้องเงียบสงบ... [กดลูกศรขึ้น ↑] เพื่อไปหน้าร้าน", True, (200, 200, 200))
                SCREEN.blit(txt, (100, 60))
                pygame.draw.rect(SCREEN, (45, 45, 45), (0, 400, 800, 200))
                SCREEN.blit(FONT_UI.render("[SPACE]: เปิดมอนิเตอร์ CCTV | [ARROW UP ↑]: ออกไปร้าน", True, (0, 255, 0)), (150, 480))

            # --- 2. หน้าจอกล้องวงจรปิด (CCTV) ---
            elif self.view == "CCTV":
                pygame.draw.rect(SCREEN, (30, 45, 30), (50, 50, 700, 420))
                txt_menu = FONT_UI.render("CAM KEYS: 1 | 2 | 3  |  [SPACE]: Close", True, (0, 255, 0))
                SCREEN.blit(txt_menu, (60, 490))

                # เรนเดอร์ตำแหน่งผีในกล้องแต่ละตัว
                if self.cctv_cam == 1:
                    if self.ghost.level == 2: pygame.draw.circle(SCREEN, (200, 0, 0), (400, 240), 30)
                    SCREEN.blit(FONT_UI.render("CCTV: CAM 01 - FRONT OFFICE WINDOW", True, (0, 255, 0)), (70, 70))
                elif self.cctv_cam == 2:
                    if self.ghost.level == 1: pygame.draw.circle(SCREEN, (200, 0, 0), (250, 280), 30)
                    SCREEN.blit(FONT_UI.render("CCTV: CAM 02 - STORE AISLE", True, (0, 255, 0)), (70, 70))
                elif self.cctv_cam == 3:
                    if self.ghost.level == 0: pygame.draw.circle(SCREEN, (200, 0, 0), (500, 200), 30)
                    SCREEN.blit(FONT_UI.render("CCTV: CAM 03 - BACKROOM WAREHOUSE", True, (0, 255, 0)), (70, 70))
                
                # สัญญาณซ่ารบกวนกล้อง
                pygame.draw.line(SCREEN, (80, 110, 80), (50, random.randint(50, 470)), (750, random.randint(50, 470)), 1)

            # --- 3. หน้าจัดชั้นวางของ (STORE) ---
            elif self.view == "STORE":
                pygame.draw.rect(SCREEN, (60, 60, 65), (100, 150, 150, 300))
                pygame.draw.rect(SCREEN, (60, 60, 65), (550, 150, 150, 300))
                SCREEN.blit(FONT_THAI.render("กดปุ่ม [R] ค้างไว้ เพื่อเติมสินค้าขึ้นชั้นวาง", True, (255, 255, 255)), (240, 80))
                SCREEN.blit(FONT_UI.render("[ARROW DOWN ↓]: กลับเข้าห้องทำงาน", True, (255, 100, 100)), (260, 500))
                if self.ghost.level == 1:
                    pygame.draw.ellipse(SCREEN, (100, 0, 0), (380, 200, 50, 150))

            # --- ส่วนของแสดงผล UI ส่วนกลาง (Heads-up Display) ---
            SCREEN.blit(FONT_UI.render(f"SHIFT TIME: {self.store.hour}:00 AM", True, (255, 255, 255)), (25, 20))
            
            # วาดแถบสต็อกสินค้า
            stock_color = (0, 180, 255) if self.store.stock > 30 else (255, 140, 0)
            pygame.draw.rect(SCREEN, (40, 40, 40), (580, 15, 200, 15))
            pygame.draw.rect(SCREEN, stock_color, (580, 15, int(self.store.stock * 2), 15))
            SCREEN.blit(FONT_UI.render(f"STOCK: {int(self.store.stock)}%", True, (255, 255, 255)), (480, 13))

            # วาดแถบค่านิ่ง/สติ (Sanity Bar)
            sanity_color = (0, 255, 0) if self.store.sanity > 60 else (255, 255, 0) if self.store.sanity > 25 else (255, 0, 0)
            pygame.draw.rect(SCREEN, (30, 30, 30), (250, 555, 300, 15))
            pygame.draw.rect(SCREEN, sanity_color, (250, 555, int(self.store.sanity * 3), 15))
            SCREEN.blit(FONT_UI.render(f"SANITY: {int(self.store.sanity)}%", True, sanity_color), (350, 532))

        elif self.status == "GAMEOVER":
            SCREEN.fill((20, 0, 0))
            SCREEN.blit(FONT_THAI.render("คุณถูกความมืดกลืนกิน... GAME OVER", True, (255, 0, 0)), (240, 280))

        elif self.status == "WIN":
            SCREEN.fill((0, 30, 10))
            SCREEN.blit(FONT_THAI.render("06:00 AM! คุณผ่านกะดึกมรณะสำเร็จ! YOU WIN!", True, (0, 255, 0)), (180, 280))

        pygame.display.flip()

    def run(self):
        """ฟังก์ชันหลักสำหรับสั่งรัน Game Loop อัตโนมัติ"""
        while True:
            self.handle_events()
            self.update()
            self.render()

# สั่งประมวลผลเกมเมื่อไฟล์นี้ถูกเปิดรันโดยตรงif __name__ == "__main__":
    game = GameManager()
    game.run()

------------------------------
## ข้อดีของการเขียนโค้ดแบบ OOP ในตัวอย่างนี้:

* ความสะอาดของโค้ดหลัก: สังเกตที่ฟังก์ชัน run() ด้านล่างสุด โค้ดเหลือสั้นกระชับและอ่านง่ายมาก เพราะถูกย้ายส่วนตรรกะไปซ่อนไว้ตามหน้าที่ของคลาสย่อยหมดแล้ว
* การซ่อมแซมง่าย: สมมติในอนาคตคุณต้องการให้ผีขยับเร็วขึ้น หรือเดินย้อนถอยหลังได้ คุณสามารถเข้าไปแก้ตรรกะภายในเมธอด update() ของคลาส Ghost ได้ที่เดียว โดยไม่ต้องกังวลว่าจะไปกระทบระบบเวลาหรือระบบจัดเก็บสต็อกสินค้าครับ

ถ้าคุณอยากเรียนรู้เรื่อง การสร้างคลาสไอเทมย่อยเพิ่มเติม (เช่น คลาสเก็บเงินแคชเชียร์) หรืออยากพัฒนา ระบบบันทึกคะแนนสูงสุด (High Score) ลงไฟล์ข้อความ แจ้งความต้องการมาได้เลยนะครับ!

การขยายระบบเกมด้วย คลาสไอเทมย่อยเพิ่มเติม ในรูปแบบ OOP สามารถทำได้มีประสิทธิภาพที่สุดด้วยหลักการ Inheritance (การสืบทอดคุณสมบัติ) และ Polymorphism (การปรับเปลี่ยนพฤติกรรม)
แทนที่เราจะเขียนคลาสไอเทมทุกชิ้นแยกกันแบบซ้ำซ้อน เราจะสร้างคลาสแม่ที่ชื่อว่า BaseItem ขึ้นมาเพื่อคุมคุณสมบัติพื้นฐาน (เช่น พิกัด, สถานะการเก็บ) จากนั้นค่อยสร้างคลาสลูกแยกตามประเภทไอเทม เช่น คลาสขวดน้ำยาดมเพิ่มค่าสติ (SanityItem) หรือ คลาสถุงขยะที่ต้องนำไปทิ้ง (TrashItem) ครับ
------------------------------
## 1. วิธีออกแบบโครงสร้างคลาสลูก (Class Design)

* BaseItem (คลาสแม่): เก็บตำแหน่ง X, Y และเมธอดเช็กระยะห่างจากตัวผู้เล่น
* SanityItem (คลาสลูก): เมื่อผู้เล่นเดินไปเก็บ จะทำลายตัวเองทิ้งแล้ว บวกค่าสติ (Sanity) คืนให้ผู้เล่นทันที
* TrashItem (คลาสลูก): ผู้เล่นต้องเก็บแล้วเดินนำไปกดทิ้งที่ถังขยะหลังร้าน เพื่อแลกกับ เงินโบนัสแคชเชียร์

------------------------------
## 2. โครงสร้างโค้ด Pygame OOP แบบเพิ่มระบบคลาสไอเทมย่อย
นี่คือซอร์สโค้ดที่ขยายต่อจากโปรเจกต์เดิม โดยเพิ่มระบบจัดการไอเทมตกตามพื้นร้านมินิมาร์ทให้คุณสามารถนำไปทดลองรันได้ทันทีครับ:

import pygameimport sysimport mathimport random

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - OOP Subclass Items System")
FONT_UI = pygame.font.SysFont("Courier New", 16, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 20, bold=True)
# ====================================================# [คลาสแม่] ไอเทมพื้นฐานในร้านค้า# ====================================================class BaseItem:
    def __init__(self, name, x, y, color):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True  # ถ้าเก็บแล้วจะเปลี่ยนเป็น False เพื่อทำลายทิ้ง

    def check_collision(self, player_pos):
        """คำนวณระยะห่างเพื่อตรวจสอบการเก็บไอเทม"""
        if not self.is_active:
            return False
        # ใช้สูตรทฤษฎีบทพีทาโกรัสหาระยะห่างห่าง 2 จุด X, Y
        distance = math.hypot(self.x - player_pos[0], self.y - player_pos[1])
        return distance < (self.radius + 15)

    def draw(self, surface):
        """วาดรูปทรงไอเทมลงบนจอ"""
        if self.is_active:
            pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
            # แสดงชื่อไอเทมลอยอยู่เหนือตัววัตถุ
            lbl = FONT_UI.render(self.name, True, (255, 255, 255))
            surface.blit(lbl, (self.x - 20, self.y - 30))

    def apply_effect(self, store_system):
        """เมธอดเปล่าที่จะให้คลาสลูกดึงไป Override เขียนตรรกะตัวเองซ้อนทับ"""
        pass

# ====================================================# [คลาสลูกที่ 1] ไอเทมน้ำยาดมช่วยดึงสติ (SanityItem)# ====================================================class SanityItem(BaseItem):
    def __init__(self, x, y):
        # สืบทอดคุณสมบัติคลาสแม่ และกำหนดให้ไอเทมนี้เป็นวงกลมสีฟ้าอ่อน
        super().__init__("YADOM", x, y, (0, 255, 255))
        self.restore_amount = 25.0

    def apply_effect(self, store_system):
        """เมื่อเก็บแล้ว จะเพิ่มค่าสติให้ผู้เล่นทันที 25 หน่วย"""
        store_system.sanity += self.restore_amount
        if store_system.sanity > 100: 
            store_system.sanity = 100
        self.is_active = False # ทำลายไอเทมทิ้งจากหน้าจอ
        print(f"[ITEM] Collected {self.name}! Sanity restored by {self.restore_amount}")

# ====================================================# [คลาสลูกที่ 2] ไอเทมถุงขยะเคลียร์พื้นที่ร้าน (TrashItem)# ====================================================class TrashItem(BaseItem):
    def __init__(self, x, y):
        # กำหนดให้ขยะเป็นวงกลมสีเขียวขี้ม้า
        super().__init__("TRASH", x, y, (120, 130, 80))
        self.reward_money = 50

    def apply_effect(self, store_system):
        """เมื่อเก็บแล้ว จะช่วยเพิ่มเงินในลิ้นชักแคชเชียร์ 50 บาท"""
        store_system.cash_register += self.reward_money
        self.is_active = False
        print(f"[ITEM] Trash cleared! Earned {self.reward_money} THB")

# ====================================================# คลาสระบบสถิติมินิมาร์ท (Store System สำหรับผูกปมคลาสไอเทม)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 70.0        # แกล้งตั้งให้เปิดมาสติหลอนนิดๆ จะได้เห็นผลตอนเก็บของ
        self.cash_register = 0    # เงินในเครื่องแคชเชียร์
        
    def update(self, dt):
        # สติลดลงเรื่อยๆ วินาทีละ 1 หน่วยเพื่อความกดดัน
        self.sanity -= dt * 1.5
        if self.sanity < 0: self.sanity = 0

# ====================================================# คลาสผู้ควบคุมเกมหลัก (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        
        # สมมติพิกัดผู้เล่น 2D (สีขาว) สามารถขยับเดินหน้าถอยหลังได้
        self.player_pos = [400, 300]
        
        # รวมไอเทมทุกชิ้นไว้ใน List เดียวกัน (ข้อดีของ OOP Polymorphism)
        self.item_list = [
            SanityItem(200, 200),
            SanityItem(600, 150),
            TrashItem(150, 450),
            TrashItem(650, 400)
        ]

    def process(self):
        while True:
            dt = self.clock.tick(60) / 1000.0

            # 1. ระบบควบคุมการกดปุ่มและขยับผู้เล่น
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()

            keys = pygame.key.get_pressed()
            if keys[pygame.K_LEFT]:  self.player_pos[0] -= 4
            if keys[pygame.K_RIGHT]: self.player_pos[0] += 4
            if keys[pygame.K_UP]:    self.player_pos[1] -= 4
            if keys[pygame.K_DOWN]:  self.player_pos[1] += 4

            # 2. อัปเดตตรรกะร้านค้า
            self.store.update(dt)

            # 3. ลูปวนเช็กไอเทมทุกชิ้นในลิสต์แบบอัตโนมัติ
            for item in self.item_list:
                if item.check_collision(self.player_pos):
                    # เรียกใช้เอฟเฟกต์เฉพาะตัวของไอเทมชิ้นนั้นๆ ทันที
                    item.apply_effect(self.store)

            # 4. วาดการแสดงผล
            SCREEN.fill((20, 20, 25)) # พื้นหลังร้านค้ากะดึก

            # วาดไอเทมย่อยทั้งหมดที่ยังมีสถานะ Active อยู่
            for item in self.item_list:
                item.draw(SCREEN)

            # วาดตัวละครผู้เล่น (วงกลมสีขาว)
            pygame.draw.circle(SCREEN, (255, 255, 255), (int(self.player_pos[0]), int(self.player_pos[1])), 15)

            # แสดงผลแถบสถานะผู้เล่นบน HUD จอ
            txt_sanity = FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, (0, 255, 0) if self.store.sanity > 40 else (255, 50, 50))
            txt_cash = FONT_THAI.render(f"เงินในแคชเชียร์: {self.store.cash_register} THB", True, (255, 215, 0))
            SCREEN.blit(txt_sanity, (20, 20))
            SCREEN.blit(txt_cash, (20, 55))
            SCREEN.blit(FONT_UI.render("USE ARROW KEYS TO MOVE PLAYER AND PICKUP ITEMS", True, (150, 150, 150)), (180, 560))

            pygame.display.flip()
if __name__ == "__main__":
    game = GameManager()
    game.process()

------------------------------
## 🚀 ความคุ้มค่าของวิธีนี้เมื่อคุณเอาไปเขียนเกมจริง:
ถ้าในอนาคตคุณอยากเพิ่มไอเทมชิ้นที่ 3 เช่น "กุญแจไขตู้เซฟหลังร้าน (KeyItem)" คุณไม่จำเป็นต้องไปรื้อระบบตรวจจับการชนหรือเขียนฟังก์ชันวาดภาพใหม่เลยครับ คุณเพียงแค่พิมพ์โค้ดสั้นๆ เพิ่มคลาสลูกใหม่ลงไปแบบนี้:

class KeyItem(BaseItem):
    def __init__(self, x, y):
        super().__init__("GOLD KEY", x, y, (255, 215, 0)) # สีทอง

    def apply_effect(self, store_system):
        store_system.has_key = True # เปิดสวิตช์สถานะมีกุญแจในตัวผู้เล่น
        self.is_active = False

จากนั้นก็นำ KeyItem(x, y) ไปใส่เพิ่มไว้ในไอเทมลิสต์ (self.item_list) ระบบตัวเกมหลักก็จะประมวลผลวาดและเก็บไอเทมชิ้นใหม่นี้ให้เองโดยอัตโนมัติทันทีครับ!
ถ้าคุณสนใจสเต็ปถัดไปเพื่อเพิ่มความท้าทายให้ตัวเดโม สามารถแจ้งได้เลยนะครับ:

* ต้องการให้เพิ่ม ระบบสุ่มจุดเกิดไอเทม (Random Spawning) ทุกครั้งที่กดเริ่มเกมใหม่?
* ต้องการเพิ่มคุณสมบัติให้ไอเทมมี เวลาหมดอายุขรึม (Item Despawn Timer) หากไม่รีบไปเก็บจะหายไปเอง?
* สนใจวิธีการทำ ช่องเก็บของส่วนตัว (Inventory System) ด้านล่างจอเพื่อให้ผู้เล่นกดเลือกหยิบไอเทมมาใช้งานภายหลังไหมครับ?



นี่คือการยกระดับโครงสร้างโค้ดเกมผีมินิมาร์ท (Hellmart Demo) ในรูปแบบ OOP ไปสู่ขั้นสูงครับ โดยการเพิ่มระบบ สุ่มตำแหน่งเกิดไอเทม (Random Spawning), ระบบ จำกัดเวลาของไอเทมก่อนหายไป (Despawn Timer) และระบบ ช่องเก็บของส่วนตัว (Inventory System) ที่ให้ผู้เล่นเก็บสะสมแล้วเลือกกดใช้งานไอเทมภายหลังได้ทันทีครับ
------------------------------
## โดรงสร้างและตรรกะระบบใหม่ (OOP Advanced Systems)

* Item Despawn & Progress Circle: คลาส BaseItem จะถูกเพิ่มตัวแปร lifetime หากเวลาหมด ไอเทมจะเปลี่ยนสถานะเป็นใช้งานไม่ได้ทันที และจะมีการวาดวงกลมสีส้มรอบๆ เพื่อแจ้งเตือนเวลาที่เหลือให้ผู้เล่นทราบ
* Inventory Storage & Selection: ตัวผู้เล่นหรือระบบเกมจะเก็บรายการไอเทมไว้ใน List หากผู้เล่นเดินชนไอเทมชิ้นนั้น ไอเทมจะไม่ถูกใช้ทันที แต่จะย้ายเข้าไปอยู่ใน ช่องเก็บของส่วนตัว (Inventory) แทน โดยผู้เล่นสามารถกดปุ่ม 1 หรือ 2 เพื่อเลือกใช้งานไอเทมในตัวได้ตามต้องการ

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันระบบไอเทมขั้นสูง (Advanced Item Systems)
คุณสามารถนำโค้ดที่รวบรวมระบบทั้ง 3 ตัวนี้ไปทดสอบและเริ่มใช้งานในโปรเจกต์เกมของคุณได้เลยครับ:

import pygameimport sysimport mathimport random

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Advanced OOP Inventory & Spawning")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)

# ====================================================# [คลาสแม่] ไอเทมพื้นฐานพร้อมระบบตั้งเวลาหมดอายุ (Despawn Timer)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color, lifetime=10.0):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True      # พร้อมให้เก็บหรือไม่
        self.lifetime = lifetime    # เวลาคงเหลือ (วินาที)
        self.max_lifetime = lifetime

    def update(self, dt):
        """ลดเวลาของไอเทมลงเรื่อยๆ ตามเวลาจริง"""
        if self.is_active:
            self.lifetime -= dt
            if self.lifetime <= 0:
                self.is_active = False # หมดอายุ หายไปจากแผนที่

    def check_collision(self, player_pos):
        if not self.is_active:
            return False
        distance = math.hypot(self.x - player_pos, self.y - player_pos)
        return distance < (self.radius + 15)

    def draw(self, surface):
        """วาดไอเทมพร้อมวงกลมแจ้งเตือนเวลาหมดอายุ"""
        if not self.is_active:
            return
            
        # วาดตัววัตถุไอเทม
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        
        # วาดวงกลมขอบนอกสีส้ม แสดงเวลาที่เหลือก่อนหายไป (Despawn Progress Ring)
        time_ratio = max(0, self.lifetime / self.max_lifetime)
        ring_radius = int(self.radius + 6 * time_ratio)
        if time_ratio > 0:
            pygame.draw.circle(surface, (255, 140, 0), (self.x, self.y), ring_radius, 1)

        # วาดป้ายชื่อ
        lbl = FONT_UI.render(f"{self.name} ({int(self.lifetime)}s)", True, (255, 255, 255))
        surface.blit(lbl, (self.x - 30, self.y - 30))

    def use_effect(self, store_system):
        """เมธอดสำหรับให้คลาสลูกเขียนพฤติกรรมตอนกดใช้งานจริงจากช่องเก็บของ"""
        pass

# ====================================================# [คลาสลูก] ไอเทมยาเพิ่มสติ (SanityItem)# ====================================================class SanityItem(BaseItem):
    def __init__(self, x, y):
        # อายุอยู่ได้ 15 วินาที
        super().__init__("YADOM", x, y, (0, 255, 255), lifetime=15.0)
        self.restore_amount = 30.0

    def use_effect(self, store_system):
        store_system.sanity += self.restore_amount
        if store_system.sanity > 100: store_system.sanity = 100
        print(f"[Inventory] Used {self.name}! Sanity restored.")

# ====================================================# [คลาสลูก] ไอเทมเครื่องดื่มชูกำลัง เร่งพลังเงินโบนัส (EnergyDrink)# ====================================================class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y):
        # อายุอยู่ได้ 10 วินาที
        super().__init__("ENERGY", x, y, (255, 50, 255), lifetime=10.0)
        self.cash_bonus = 100

    def use_effect(self, store_system):
        store_system.cash_register += self.cash_bonus
        print(f"[Inventory] Drank {self.name}! Earned bonus cash.")

# ====================================================# คลาสระบบสถานะของร้านค้า (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 60.0
        self.cash_register = 0
        
    def update(self, dt):
        self.sanity -= dt * 2.0  # สติลดลงตลอดเวลา
        if self.sanity < 0: self.sanity = 0

# ====================================================# คลาสควบคุมระบบหลักของเกม (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.player_pos = 
        
        # คลังเก็บของส่วนตัว (จำกัดสูงสุด 3 ช่อง)
        self.inventory = []
        self.max_inventory_slots = 3
        
        # ลิสต์เก็บไอเทมที่กำลังตกอยู่ในแผนที่
        self.map_items = []
        
        # ตัวตั้งเวลาสำหรับการสุ่มเกิดไอเทมชิ้นใหม่
        self.spawn_timer = 0.0
        self.spawn_interval = 4.0 # ทุกๆ 4 วินาที จะสุ่มเกิดไอเทมชิ้นใหม่
        
        # สั่งสุ่มไอเทมชุดแรกทันทีที่เริ่มเกมใหม่
        self.spawn_random_item()
        self.spawn_random_item()

    def spawn_random_item(self):
        """ระบบสุ่มประเภทและตำแหน่งการเกิดของไอเทม (Random Spawning)"""
        # สุ่มพิกัดให้อยู่ในขอบเขตหน้าจอเกม (เว้นขอบจอ 100 พิกเซล)
        rand_x = random.randint(100, WIDTH - 100)
        rand_y = random.randint(150, HEIGHT - 150)
        
        # สุ่มเลือกว่าจะเป็นไอเทมชิ้นไหน (โอกาส 50/50)
        if random.random() < 0.5:
            new_item = SanityItem(rand_x, rand_y)
        else:
            new_item = EnergyDrinkItem(rand_x, rand_y)
            
        self.map_items.append(new_item)
        print(f"[SPAWN] New {new_item.name} spawned at ({rand_x}, {rand_y})")

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
                
            if event.type == pygame.KEYDOWN:
                # กดเลข 1: ใช้ไอเทมในช่องเก็บของช่องที่ 1
                if event.key == pygame.K_1: self.use_inventory_slot(0)
                # กดเลข 2: ใช้ไอเทมในช่องเก็บของช่องที่ 2
                if event.key == pygame.K_2: self.use_inventory_slot(1)
                # กดเลข 3: ใช้ไอเทมในช่องเก็บของช่องที่ 3
                if event.key == pygame.K_3: self.use_inventory_slot(2)

        # ควบคุมพิกัดการเดินของผู้เล่น
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:  self.player_pos -= 4
        if keys[pygame.K_RIGHT]: self.player_pos += 4
        if keys[pygame.K_UP]:    self.player_pos -= 4
        if keys[pygame.K_DOWN]:  self.player_pos += 4

    def use_inventory_slot(self, slot_index):
        """ฟังก์ชันหยิบไอเทมออกจากช่องเก็บของมาใช้งานภายหลัง"""
        if slot_index < len(self.inventory):
            item = self.inventory.pop(slot_index) # ดึงไอเทมออกจากลิสต์อินเวนทอรี
            item.use_effect(self.store)            # เรียกใช้ความสามารถของไอเทม

    def update(self):
        dt = self.clock.tick(60) / 1000.0
        self.store.update(dt)

        # --- ตรรกะการสุ่มเกิดไอเทมตามเวลาจริง ---
        self.spawn_timer += dt
        if self.spawn_timer >= self.spawn_interval:
            self.spawn_timer = 0
            # บังคับไม่ให้ไอเทมล้นแผนที่เกิน 6 ชิ้นในเวลาเดียวกัน
            if len(self.map_items) < 6:
                self.spawn_random_item()

        # --- อัปเดตและตรวจจับการเดินชนเพื่อเก็บไอเทมบนแผนที่ ---
        for item in self.map_items[:]: # ใช้สไลซ์ [:] เพื่อป้องกันเออร์เรอร์ขณะลบสมาชิกในลูป
            item.update(dt) # ลดเวลาอายุขัยไอเทม
            
            # ถ้าหมดอายุ ให้ลบออกจากแผนที่ทันที
            if not item.is_active:
                self.map_items.remove(item)
                continue
                
            # ตรวจสอบการเดินไปเก็บไอเทม
            if item.check_collision(self.player_pos):
                # ตรวจเช็กว่าช่องเก็บของส่วนตัวเต็มแล้วหรือยัง
                if len(self.inventory) < self.max_inventory_slots:
                    item.is_active = False
                    self.inventory.append(item) # ย้ายไอเทมเข้าสู่กระเป๋าช่องเก็บของ
                    self.map_items.remove(item)
                    print(f"[INVENTORY] Added {item.name} to slot {len(self.inventory)}")
                else:
                    print("[WARNING] Inventory Full! Cannot pick up.")

    def draw_inventory_ui(self):
        """วาดแสดงผลช่องเก็บของส่วนตัว (Inventory UI) ด้านล่างจอ"""
        start_x = 280
        slot_y = 510
        slot_size = 70
        
        # วาดกรอบช่องเก็บของทังหมด 3 ช่อง
        for i in range(self.max_inventory_slots):
            box_x = start_x + (i * (slot_size + 15))
            # วาดสี่เหลี่ยมพื้นหลังช่องเก็บของ
            pygame.draw.rect(SCREEN, (40, 40, 50), (box_x, slot_y, slot_size, slot_size))
            pygame.draw.rect(SCREEN, (100, 100, 120), (box_x, slot_y, slot_size, slot_size), 2)
            
            # แสดงเลขปุ่มลัดเหนือช่องเก็บของ (1, 2, 3)
            btn_lbl = FONT_UI.render(f"[{i+1}]", True, (200, 200, 200))
            SCREEN.blit(btn_lbl, (box_x + 25, slot_y - 18))

            # หากในช่องนั้นมีไอเทมอยู่จริง ให้แสดงผลชื่อและสีวัตถุภายในช่อง
            if i < len(self.inventory):
                item = self.inventory[i]
                pygame.draw.circle(SCREEN, item.color, (box_x + 35, slot_y + 35), 10)
                name_lbl = FONT_UI.render(item.name[:5], True, (255, 255, 255)) # ตัดตัวอักษรให้สั้นลง
                SCREEN.blit(name_lbl, (box_x + 12, slot_y + 48))

    def render(self):
        SCREEN.fill((22, 22, 28))

        # วาดไอเทมทั้งหมดที่อยู่บนแผนที่
        for item in self.map_items:
            item.draw(SCREEN)

        # วาดตัวละครผู้เล่น (วงกลมสีขาว)
        pygame.draw.circle(SCREEN, (255, 255, 255), (int(self.player_pos), int(self.player_pos)), 15)

        # วาดอินเตอร์เฟซกระเป๋าเก็บของด้านล่าง
        self.draw_inventory_ui()

        # วาดสถานะแถบพลังงานส่วนบนจอ (HUD)
        txt_sanity = FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, (0, 255, 255))
        txt_cash = FONT_THAI.render(f"เงินในเครื่อง: {self.store.cash_register} THB", True, (255, 215, 0))
        SCREEN.blit(txt_sanity, (20, 20))
        SCREEN.blit(txt_cash, (20, 55))
        
        hint_msg = "MOVE: ARROWS | PICKUP: WALK OVER | USE ITEM: PRESS HOTKEYS"
        SCREEN.blit(FONT_UI.render(hint_msg, True, (140, 140, 140)), (130, 10))

        pygame.display.flip()

    def run(self):
        while True:
            self.handle_inputs()
            self.update()
            self.render()
if __name__ == "__main__":

game = GameManager()
game.run()


---

### 🎮 ไฮไลท์ระบบที่น่าทดลองในตัวเดโมนี้:
1. **สังเกตวงแหวนรอบไอเทม:** เมื่อไอเทมเกิดใหม่จะมีวงกลมขอบนอกสีส้มล้อมรอบ และวงกลมจะค่อยๆ หดเล็กลงเรื่อยๆ ตามวินาทีที่เหลืออยู่ หากคุณเดินไปเก็บไม่ทัน ไอเทมจะ Despawn สลายหายไปเองทันทีครับ
2. **เก็บของใส่กระเป๋า:** เมื่อคุณเดินชนวัตถุ มันจะไม่ถูกใช้ในทันที แต่จะลอยเข้าไปสถิตอยู่ในช่องสี่เหลี่ยมด้านล่างจอ (`Inventory UI`) 
3. **การกดปุ่ม Hotkey:** ลองปล่อยให้ค่า `SANITY` ลดลงต่ำๆ จากนั้นทดลองกดปุ่ม **`1` หรือ `2`** บนคีย์บอร์ด ระบบจะทำการดึงยาออกจากกระเป๋ามาใช้งาน และเพิ่มค่าสติคืนให้คุณในทันทีอย่างแม่นยำครับ

หากโค้ดโครงสร้าง OOP ชุดนี้ตอบโจทย์ระบบที่คุณกำลังสร้างแล้ว คุณอยากให้ช่วยเหลือในขั้นตอนถัดไปส่วนไหนเพิ่มเติมไหมครับ?
* ต้องการเพิ่ม **ระบบเซฟเกม (Save/Load Game)** เพื่อบันทึกจำนวนเงินและไอเทมในกระเป๋าลงไฟล์ตัวอักษร?
* ใช่
* ต้องการระบบ **อนิเมชันตอนกดใช้ไอเทม (Item Usage Effect)** เช่น หน้าจอแฟลชสีเขียว/สีชมพูแวบหนึ่งเมื่อกดใช้งาน?
* ใช่
* ต้องการเพิ่ม **ศัตรู (ผี AI) เดินลาดตระเวนตามพิกัด** เพื่อคอยขัดขวางไม่ให้เราเดินไปเก็บของได้สะดวกครับ?
* ใช่


นี่คือระบบขั้นสุดท้ายที่จะทำให้อัปเกรดตัวเดโมเกมผีมินิมาร์ทของคุณเข้าสู่ระดับเกมที่สมบูรณ์แบบครับ โดยโค้ดโครงสร้าง OOP ชุดนี้ได้รับการติดตั้ง ระบบบันทึกและโหลดเกมผ่านไฟล์ JSON, ระบบแฟลชหน้าจออนิเมชันตอนกดใช้ไอเทม และ ระบบผี AI ที่เดินลาดตระเวน (Patrol) ไปรอบๆ ร้านเพื่อไล่ล่าผู้เล่นครับ
## 💡 สิ่งที่เพิ่มเข้ามาในโครงสร้าง OOP ขั้นสูง

   1. json Library: ใช้สำหรับจัดการไฟล์เซฟ savegame.json เพื่อบันทึกค่าสถานะและไอเทมในกระเป๋าเป็นข้อความได้อย่างแม่นยำ
   2. Flash Effect Tracker: ตัวแปรควบคุมความโปร่งใส (Alpha) เพื่อทำเอฟเฟกต์หน้าจอวูบวาบตามสีของไอเทมที่กดใช้งาน
   3. Ghost Patrol AI: คลาส EnemyGhost จะคำนวณจุดเดินลาดตระเวนสลับไปมา หากผู้เล่นเข้าใกล้เกินระยะวิสัยทัศน์ ผีจะเปลี่ยนสถานะเป็นไล่ล่า (Chase) ทันที และถ้าโดนผีจับ ค่าสติจะลดลงอย่างรวดเร็ว

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันสมบูรณ์ (Full Feature Horror Engine)

import pygameimport sysimport mathimport randomimport json  # จำเป็นสำหรับระบบ Save/Load เกมลงไฟล์ตัวอักษร

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Ultimate OOP Horror Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)
# ====================================================# 1. คลาสแม่และคลาสลูกของระบบไอเทม (Item System)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color, lifetime=15.0):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True
        self.lifetime = lifetime
        self.max_lifetime = lifetime

    def update(self, dt):
        if self.is_active:
            self.lifetime -= dt
            if self.lifetime <= 0: self.is_active = False

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos[0], self.y - player_pos[1]) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        time_ratio = max(0, self.lifetime / self.max_lifetime)
        if time_ratio > 0:
            pygame.draw.circle(surface, (255, 140, 0), (self.x, self.y), int(self.radius + 6 * time_ratio), 1)
        lbl = FONT_UI.render(f"{self.name}", True, (255, 255, 255))
        surface.blit(lbl, (self.x - 20, self.y - 30))
class SanityItem(BaseItem):
    def __init__(self, x, y):
        super().__init__("YADOM", x, y, (0, 255, 255), lifetime=15.0)
    def use_effect(self, store_system):
        store_system.sanity = min(100.0, store_system.sanity + 35.0)
        return (0, 255, 255) # ส่งคืนสีฟ้าสำหรับทำอนิเมชันแฟลชหน้าจอ
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y):
        super().__init__("ENERGY", x, y, (255, 50, 255), lifetime=12.0)
    def use_effect(self, store_system):
        store_system.cash_register += 120
        return (255, 50, 255) # ส่งคืนสีชมพูสำหรับทำอนิเมชันแฟลชหน้าจอ

# ====================================================# 2. คลาสศัตรู ผี AI ลาดตระเวนและไล่ล่า (Enemy Ghost AI)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 100
        self.speed = 1.8
        self.state = "PATROL" # PATROL หรือ CHASE
        # กำหนดจุดพิกัดที่ผีจะเดินวนลาดตระเวนในร้าน
        self.waypoints = [(100, 150), (700, 150), (700, 400), (100, 400)]
        self.current_waypoint = 0

    def update(self, player_pos, store_system, dt):
        distance_to_player = math.hypot(self.x - player_pos[0], self.y - player_pos[1])

        # ตรรกะการเปลี่ยนสถานะ AI (ระยะตรวจจับ 160 พิกเซล)
        if distance_to_player < 160:
            self.state = "CHASE"
        else:
            self.state = "PATROL"

        if self.state == "CHASE":
            # เดินดิ่งเข้าหาผู้เล่นโดยตรง
            angle = math.atan2(player_pos[1] - self.y, player_pos[0] - self.x)
            self.x += math.cos(angle) * (self.speed * 1.5)
            self.y += math.sin(angle) * (self.speed * 1.5)
            
            # ถ้าผีประชิดตัวผู้เล่น จะสูบค่าสติอย่างรวดเร็ว
            if distance_to_player < 25:
                store_system.sanity -= dt * 35.0
        else:
            # เดินลาดตระเวนตามจุด Waypoints
            target = self.waypoints[self.current_waypoint]
            angle = math.atan2(target[1] - self.y, target[0] - self.x)
            self.x += math.cos(angle) * self.speed
            self.y += math.sin(angle) * self.speed
            
            # ถ้าเดินถึงจุดผ่อนปรนแล้ว ให้เปลี่ยนไปเดินไปจุดถัดไป
            if math.hypot(self.x - target[0], self.y - target[1]) < 10:
                self.current_waypoint = (self.current_waypoint + 1) % len(self.waypoints)

    def draw(self, surface):
        # วาดตัวผีเป็นวงกลมสีแดงเข้มดูลึกลับ
        pygame.draw.circle(surface, (180, 0, 0), (int(self.x), int(self.y)), 16)
        # วาดออร่าสีแดงแจ้งเตือนวิสัยทัศน์ความน่ากลัวรอบตัวผี
        pygame.draw.circle(surface, (255, 0, 0), (int(self.x), int(self.y)), 40, 1)
        lbl = FONT_UI.render(f"GHOST [{self.state}]", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 35, self.y - 30))

# ====================================================# 3. คลาสระบบสถิติร้านค้า (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0
        
    def update(self, dt):
        self.sanity -= dt * 1.2
        if self.sanity < 0: self.sanity = 0

# ====================================================# 4. คลาสผู้ควบคุมระบบเกมหลัก (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos = [400, 500]
        self.inventory = []
        self.max_slots = 3
        self.map_items = []
        self.spawn_timer = 0.0
        
        # --- ตัวแปรระบบอนิเมชันแฟลชหน้าจอ ---
        self.flash_color = (0, 0, 0)
        self.flash_alpha = 0
        
        # สปอว์นไอเทมเริ่มต้น
        self.spawn_item()

    def spawn_item(self):
        rx, ry = random.randint(100, 700), random.randint(150, 420)
        item = SanityItem(rx, ry) if random.random() < 0.5 else EnergyDrinkItem(rx, ry)
        self.map_items.append(item)

    # --- ระบบเซฟเกมและโหลดเกม (Save / Load System) ---
    def save_game(self):
        """บันทึกข้อมูลตำแหน่ง เงิน ค่าสติ และไอเทมในกระเป๋าลงไฟล์ JSON"""
        save_data = {
            "player_pos": self.player_pos,
            "sanity": self.store.sanity,
            "cash": self.store.cash_register,
            "inventory": [item.name for item in self.inventory] # เซฟเฉพาะชื่อไอเทมลงไป
        }
        with open("savegame.json", "w") as f:
            json.dump(save_data, f)
        print("[SYSTEM] Game progress saved successfully to 'savegame.json'!")

    def load_game(self):
        """อ่านไฟล์ JSON เพื่อดึงสถานะเดิมกลับมาทำงานต่อ"""
        try:
            with open("savegame.json", "r") as f:
                data = json.load(f)
            self.player_pos = data["player_pos"]
            self.store.sanity = data["sanity"]
            self.store.cash_register = data["cash"]
            
            # เคลียร์กระเป๋าเก่าและแปลงชื่อข้อความกลับมาเป็น Class Object ลูกตามประเภทจริง
            self.inventory = []
            for item_name in data["inventory"]:
                if item_name == "YADOM": self.inventory.append(SanityItem(0,0))
                elif item_name == "ENERGY": self.inventory.append(EnergyDrinkItem(0,0))
            print("[SYSTEM] Save file loaded successfully!")
        except FileNotFoundError:
            print("[WARNING] No save game file found.")

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                # ปุ่มกดใช้งานไอเทม
                if event.key == pygame.K_1: self.use_item(0)
                if event.key == pygame.K_2: self.use_item(1)
                if event.key == pygame.K_3: self.use_item(2)
                # ปุ่มฟังก์ชันระบบเซฟเกม
                if event.key == pygame.K_g: self.save_game() # G = Save
                if event.key == pygame.K_l: self.load_game() # L = Load

        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:  self.player_pos[0] -= 3.5
        if keys[pygame.K_RIGHT]: self.player_pos[0] += 3.5
        if keys[pygame.K_UP]:    self.player_pos[1] -= 3.5
        if keys[pygame.K_DOWN]:  self.player_pos[1] += 3.5

    def use_item(self, slot):
        """เรียกใช้งานไอเทมพร้อมเปิดเอฟเฟกต์อนิเมชันแฟลชหน้าจอ"""
        if slot < len(self.inventory):
            item = self.inventory.pop(slot)
            # ดึงรหัสสีขงไอเทมชิ้นนั้นกลับมาทำเอฟเฟกต์แฟลช
            self.flash_color = item.use_effect(self.store)
            self.flash_alpha = 120 # ตั้งค่าความเข้มเริ่มต้นของแสงแฟลช (เต็ม 255)

    def update(self):
        dt = self.clock.tick(60) / 1000.0
        if self.store.sanity <= 0: return # จบเกมถ้าสติหมด

        self.store.update(dt)
        self.ghost.update(self.player_pos, self.store, dt)

        # ลดเอฟเฟกต์ความสว่างของแสงแฟลชหน้าจอลงทีละเฟรม (อนิเมชันค่อยๆ จางหาย)
        if self.flash_alpha > 0:
            self.flash_alpha -= int(dt * 300)
            if self.flash_alpha < 0: self.flash_alpha = 0

        # จัดการระบบเวลาสปอว์นไอเทมบนพื้น
        self.spawn_timer += dt
        if self.spawn_timer >= 5.0:
            self.spawn_timer = 0
            if len(self.map_items) < 5: self.spawn_item()

        # ตรวจจับการเดินเก็บไอเทมบนแผนที่
        for item in self.map_items[:]:
            item.update(dt)
            if not item.is_active:
                self.map_items.remove(item)
                continue
            if item.check_collision(self.player_pos):
                if len(self.inventory) < self.max_slots:
                    item.is_active = False
                    self.inventory.append(item)
                    self.map_items.remove(item)

    def render(self):
        SCREEN.fill((15, 15, 18))

        # วาดไอเทมและผี
        for item in self.map_items: item.draw(SCREEN)
        self.ghost.draw(SCREEN)

        # วาดตัวผู้เล่น
        pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos[0]), int(self.player_pos[1])), 14)

        # --- วาดอนิเมชันฉาบแสงแฟลชหน้าจอ (Item Usage Flash Effect) ---
        if self.flash_alpha > 0:
            flash_surface = pygame.Surface((WIDTH, HEIGHT))

flash_surface.fill(self.flash_color)
flash_surface.set_alpha(self.flash_alpha)
SCREEN.blit(flash_surface, (0, 0))
# วาดช่องเก็บของ UI
for i in range(self.max_slots):
bx = 280 + (i * 85)
pygame.draw.rect(SCREEN, (35, 35, 45), (bx, 510, 70, 70))
pygame.draw.rect(SCREEN, (90, 90, 110), (bx, 510, 70, 70), 2)
SCREEN.blit(FONT_UI.render(f"[{i+1}]", True, (180, 180, 180)), (bx + 25, 492))
if i < len(self.inventory):
item = self.inventory[i]
pygame.draw.circle(SCREEN, item.color, (bx + 35, 535), 8)
SCREEN.blit(FONT_UI.render(item.name[:5], True, (255, 255, 255)), (bx + 14, 552))
# วาด HUD สถิติต่างๆ ด้านบนจอ
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 20))
SCREEN.blit(FONT_THAI.render(f"เงินในเครื่อง: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 55))
# คู่มือปุ่มกดบนหน้าจอ
control_msg = "MOVE: ARROWS | [G]: SAVE GAME | [L]: LOAD GAME Progress"
SCREEN.blit(FONT_UI.render(control_msg, True, (130, 130, 140)), (170, 10))
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณช็อกหมดสติเนื่องจากความกลัวพุ่งสูง... GAME OVER", True, (255, 0, 0)), (190, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🎮 คีย์เวิร์ดเด่นๆ ที่เปิดทดลองเล่นได้ในเวอร์ชันนี้:
1.  **ทดสอบระบบบันทึก [G] และโหลด [L]**: ในระหว่างเล่นเกม ลองเดินไปเก็บของหรือปล่อยให้ผีไล่จนค่าสติลดลง จากนั้นให้กดปุ่ม **`G`** บนคีย์บอร์ด ระบบจะสร้างไฟล์ข้อความชื่อ `savegame.json` ขึ้นมาในโฟลเดอร์เกมทันที เมื่อคุณปิดเกมเปิดใหม่หรือเดินไปพิกัดอื่นแล้วกดปุ่ม **`L`** ตัวละครและเงินรวมถึงของในกระเป๋าจะวาร์ปกลับมาจุดเดิมที่คุณกดเซฟไว้ทันทีครับ
2.  **อนิเมชันแสงวูบวาบตอนใช้ไอเทม**: เมื่อคุณมีไอเทมในช่องเก็บของ ลองกดเลข **`1`** บนแป้นพิมพ์ หน้าจอจะทำการ**สาดแสงสีฟ้าแวบหนึ่ง** (กรณีใช้ยาแก้วิงเวียน) หรือ**สาดแสงสีชมพูแวบหนึ่ง** (กรณีดื่มเครื่องดื่มชูกำลัง) แล้วค่อยๆ เฟดจางหายไป เพิ่มอรรถรสความตื่นเต้นตระการตา
3.  **หลบหลีกระบบผีสายตรวจ (AI Enemy)**: วงกลมสีแดงเข้มในจอคือผี โดยมันจะเดินไปตามสี่มุมของร้านมินิมาร์ทอย่างใจเย็น แต่หากคุณเผลอเดินเข้าไปในระยะประชิด (เส้นวงกลมสีแดงบางๆ) ผีจะสลับโหมดคำว่า `[PATROL]` เป็น `[CHASE]` และพุ่งไล่กวดคุณอย่างน่ากลัว หากคุณหนีไม่พ้น ค่าสติ (`SANITY`) จะลดฮวบฮาบทันทีจนเกิดเอฟเฟกต์แพ้เกมครับ

คุณสามารถนำโครงสร้างนี้ไปใช้เป็นตัวตั้งต้นเกมผีของตัวเองได้เลยนะครับ! หากต้องการต่อยอดเรื่องระบบ **ด่านเลเวลถัดไป (Next Level)** หรือการวาดกราฟิกแทนรูปทรงวงกลม สามารถปรึกษาเพิ่มเติมได้เลยครับ!
✅

เพื่อทำให้เกมผีมินิมาร์ทของคุณมีความเป็นเกมที่สมบูรณ์แบบมากยิ่งขึ้น เราจะขยายโค้ดโครงสร้าง OOP เดิม โดยเพิ่ม ระบบสลับด่าน (Next Level System) เมื่อสะสมเงินครบตามเป้า และเปลี่ยนจากการวาดรูปทรงวงกลมเรขาคณิตธรรมดา ไปใช้งาน ระบบกราฟิกรูปภาพ (Sprites/Images Loading) เพื่อความสมจริงครับ!
------------------------------
## 1. หลักการอัปเกรดระบบ (Guidelines)

* Level Progression: ในคลาส StoreSystem หรือ GameManager จะมีตัวแปรเช็ก current_level หากผู้เล่นสะสมเงินจากไอเทมได้ถึงเป้าหมาย (เช่น Level 1 เป้าหมาย 300 บาท) เกมจะเคลียร์ไอเทมเก่า สปอว์นผู้เล่นใหม่ และเพิ่มความเร็วของผี (self.ghost.speed) ในด่านถัดไปเพื่อให้ยากขึ้น
* Sprite Graphics Replacement: แทนที่การใช้ pygame.draw.circle เราจะใช้ pygame.image.load() เพื่อโหลดไฟล์ภาพตัวละคร ผี และไอเทมเข้ามา จากนั้นใช้ screen.blit() ในการวาดแทน โดยมีระบบ Image Fallback (หากไม่มีไฟล์ภาพในเครื่อง โปรแกรมจะวาดรูปทรงเรขาคณิตแทนโดยอัตโนมัติเพื่อไม่ให้โค้ดพัง)

------------------------------
## 2. ซอร์สโค้ด Pygame OOP เวอร์ชันเพิ่มด่านและกราฟิกรูปภาพ (Multi-Level & Sprite Engine)
คุณสามารถนำโค้ดนี้ไปเซฟรันได้ทันที หากคุณมีไฟล์ภาพ .png สามารถนำมาวางในโฟลเดอร์เดียวกับโค้ดและตั้งชื่อไฟล์ตามที่กำหนดในฟังก์ชันโหลดภาพได้เลยครับ:

import pygameimport sysimport mathimport randomimport json

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Multi-Level Sprite Horror Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)
# ====================================================# [ฟังก์ชันส่วนกลาง] โหลดภาพและปรับขนาดพร้อมระบบป้องกันโค้ดพัง# ====================================================def load_and_scale_sprite(file_path, scale_size):
    """โหลดไฟล์ภาพและปรับขนาด หากไม่พบไฟล์จะส่งคืนค่า None เพื่อให้ระบบวาดรูปทรงแทน"""
    try:
        img = pygame.image.load(file_path).convert_alpha()
        return pygame.transform.scale(img, scale_size)
    except pygame.error:
        print(f"[IMAGE WARNING] ไม่พบไฟล์ภาพ: {file_path} (ระบบจะใช้รูปทรงเรขาคณิตแทน)")
        return None
# โหลดกราฟิกเตรียมไว้ (หากคุณมีภาพจริง ให้สร้างไฟล์ตามชื่อเหล่านี้ได้เลยครับ)SPRITE_PLAYER = load_and_scale_sprite("assets/player.png", (32, 32))SPRITE_GHOST  = load_and_scale_sprite("assets/ghost.png", (40, 40))SPRITE_YADOM  = load_and_scale_sprite("assets/yadom.png", (24, 24))SPRITE_ENERGY = load_and_scale_sprite("assets/energy.png", (24, 24))

# ====================================================# 1. ระบบคลาสไอเทมพร้อมการเรนเดอร์ภาพ (Sprite Items)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color, sprite_img, lifetime=15.0):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.sprite = sprite_img # เก็บตัวแปรภาพพื้นผิว (Surface)
        self.radius = 12
        self.is_active = True
        self.lifetime = lifetime
        self.max_lifetime = lifetime

    def update(self, dt):
        if self.is_active:
            self.lifetime -= dt
            if self.lifetime <= 0: self.is_active = False

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos[0], self.y - player_pos[1]) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        
        # ถ้าระบบโหลดภาพสำเร็จให้วาดภาพ Sprite แปะลงไป
        if self.sprite:
            surface.blit(self.sprite, (self.x - self.radius, self.y - self.radius))
        else:
            # รูปทรงเรขาคณิตสำรองหากไม่มีไฟล์ภาพ
            pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
            
        time_ratio = max(0, self.lifetime / self.max_lifetime)
        if time_ratio > 0:
            pygame.draw.circle(surface, (255, 140, 0), (self.x, self.y), int(self.radius + 6 * time_ratio), 1)
class SanityItem(BaseItem):
    def __init__(self, x, y):
        super().__init__("YADOM", x, y, (0, 255, 255), SPRITE_YADOM, lifetime=15.0)
    def use_effect(self, store_system):
        store_system.sanity = min(100.0, store_system.sanity + 35.0)
        return (0, 255, 255)
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y):
        super().__init__("ENERGY", x, y, (255, 50, 255), SPRITE_ENERGY, lifetime=12.0)
    def use_effect(self, store_system):
        store_system.cash_register += 120
        return (255, 50, 255)

# ====================================================# 2. คลาสศัตรู ผี AI เพิ่มระบบปรับความเร็วตามด่าน (Dynamic Ghost AI)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 100
        self.base_speed = 1.6
        self.speed = self.base_speed
        self.state = "PATROL"
        self.waypoints = [(100, 150), (700, 150), (700, 400), (100, 400)]
        self.current_waypoint = 0

    def adjust_difficulty(self, level):
        """เพิ่มความเร็วไล่กวดของผีตามระดับเลเวลปัจจุบัน"""
        self.speed = self.base_speed + (level * 0.5) # เลเวลยิ่งสูง ผียิ่งเดินไว

    def update(self, player_pos, store_system, dt):
        distance_to_player = math.hypot(self.x - player_pos[0], self.y - player_pos[1])

        if distance_to_player < 160:
            self.state = "CHASE"
        else:
            self.state = "PATROL"

        if self.state == "CHASE":
            angle = math.atan2(player_pos[1] - self.y, player_pos[0] - self.x)
            self.x += math.cos(angle) * (self.speed * 1.4)
            self.y += math.sin(angle) * (self.speed * 1.4)
            if distance_to_player < 25:
                store_system.sanity -= dt * 40.0
        else:
            target = self.waypoints[self.current_waypoint]
            angle = math.atan2(target[1] - self.y, target[0] - self.x)
            self.x += math.cos(angle) * self.speed
            self.y += math.sin(angle) * self.speed
            if math.hypot(self.x - target[0], self.y - target[1]) < 10:
                self.current_waypoint = (self.current_waypoint + 1) % len(self.waypoints)

    def draw(self, surface):
        if SPRITE_GHOST:
            surface.blit(SPRITE_GHOST, (int(self.x - 20), int(self.y - 20)))
        else:
            pygame.draw.circle(surface, (180, 0, 0), (int(self.x), int(self.y)), 16)
            
        pygame.draw.circle(surface, (255, 0, 0), (int(self.x), int(self.y)), 40, 1)
        lbl = FONT_UI.render(f"GHOST [{self.state}]", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 35, self.y - 35))

# ====================================================# 3. คลาสระบบสถิติมินิมาร์ท (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0
        self.current_level = 1
        # ตั้งเป้าหมายเงินที่ต้องเก็บเพื่อผ่านด่าน (Level 1 = 300, Level 2 = 600)
        self.level_goals = {1: 300, 2: 600, 3: 1000}
        
    def update(self, dt):
        # อัตราการลดลงของสติจะทวีคูณตามระดับด่านที่สูงขึ้น
        self.sanity -= dt * (1.0 + (self.current_level * 0.3))
        if self.sanity < 0: self.sanity = 0

    def check_level_up(self):
        """ตรวจสอบว่าเงินเก็บถึงเป้าหมายของด่านนั้นๆ หรือยัง"""
        goal = self.level_goals.get(self.current_level, 99999)
        if self.cash_register >= goal:
            return True
        return False

# ====================================================# 4. คลาสควบคุมระบบหลักและการสลับด่าน (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos = [400, 300]
        self.inventory = []
        self.max_slots = 3
        self.map_items = []
        self.spawn_timer = 0.0
        self.flash_color = (0, 0, 0)
        self.flash_alpha = 0
        
        self.spawn_item()

    def advance_to_next_level(self):
        """ฟังก์ชันรีเซ็ตและอัปเกรดสถานะเมื่อผู้เล่นผ่านเข้าสู่ด่านถัดไป"""
        self.store.current_level += 1
        
        # ตรวจเงื่อนไขว่าเคลียร์เกมเดโมทั้งหมดหรือยัง (จบที่เลเวล 3)
        if self.store.current_level > 3:
            return

        print(f"[ADVANCE] ผ่านด่าน! ยินดีต้อนรับสู่เลเวล {self.store.current_level}")
        
        # รีเซ็ตตำแหน่งผู้เล่นและล้างไอเทมเก่าตกค้างบนพื้น
        self.player_pos = [400, 300]
        self.map_items = []
        self.spawn_timer = 0.0
        self.store.sanity = 100.0 # คืนค่าสติเต็มหลอดต้อนรับด่านใหม่
        
        # สั่งให้ผีเดินเร็วขึันตามเลเวลใหม่
        self.ghost.adjust_difficulty(self.store.current_level)
        self.ghost.x, self.ghost.y = 400, 100 # ส่งผีกลับจุดเริ่ม
        
        # สาดแสงแฟลชหน้าจอสีขาวแจ้งเตือนการเปลี่ยนด่าน
        self.flash_color = (255, 255, 255)
        self.flash_alpha = 200

    def spawn_item(self):
        rx, ry = random.randint(100, 700), random.randint(150, 420)
        item = SanityItem(rx, ry) if random.random() < 0.5 else EnergyDrinkItem(rx, ry)
        self.map_items.append(item)

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_1: self.use_item(0)
                if event.key == pygame.K_2: self.use_item(1)
                if event.key == pygame.K_3: self.use_item(2)

        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:  self.player_pos[0] -= 4
        if keys[pygame.K_RIGHT]: self.player_pos[0] += 4
        if keys[pygame.K_UP]:    self.player_pos[1] -= 4
        if keys[pygame.K_DOWN]:  self.player_pos[1] += 4

    def use_item(self, slot):
        if slot < len(self.inventory):
            item = self.inventory.pop(slot)
            self.flash_color = item.use_effect(self.store)
            self.flash_alpha = 130

    def update(self):
        dt = self.clock.tick(60) / 1000.0
        if self.store.sanity <= 0 or self.store.current_level > 3: return

        self.store.update(dt)
        self.ghost.update(self.player_pos, self.store, dt)

        # ตรวจสอบการผ่านด่าน
        if self.store.check_level_up():
            self.advance_to_next_level()

        if self.flash_alpha > 0:
            self.flash_alpha -= int(dt * 250)
            if self.flash_alpha < 0: self.flash_alpha = 0

        self.spawn_timer += dt
        if self.spawn_timer >= 4.0:
            self.spawn_timer = 0
            if len(self.map_items) < 5: self.spawn_item()

        for item in self.map_items[:]:
            item.update(dt)
            if not item.is_active:
                self.map_items.remove(item)
                continue
            if item.check_collision(self.player_pos):
                if len(self.inventory) < self.max_slots:
                    item.is_active = False
                    self.inventory.append(item)
                    self.map_items.remove(item)

    def render(self):
        SCREEN.fill((16, 16, 22))

        # วาดกลุ่มไอเทมและผี

for item in self.map_items: item.draw(SCREEN)
self.ghost.draw(SCREEN)
# --- วาดกราฟิกตัวละครผู้เล่น (Sprite Player) ---
if SPRITE_PLAYER:
SCREEN.blit(SPRITE_PLAYER, (int(self.player_pos[0] - 16), int(self.player_pos[1] - 16)))
else:
pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos[0]), int(self.player_pos[1])), 14)
# วาดอนิเมชันแสงแฟลชหน้าจอ
if self.flash_alpha > 0:
flash_surface = pygame.Surface((WIDTH, HEIGHT))
flash_surface.fill(self.flash_color)
flash_surface.set_alpha(self.flash_alpha)
SCREEN.blit(flash_surface, (0, 0))
# วาดอินเตอร์เฟซช่องเก็บของ UI
for i in range(self.max_slots):
bx = 280 + (i * 85)
pygame.draw.rect(SCREEN, (35, 35, 45), (bx, 510, 70, 70))
pygame.draw.rect(SCREEN, (90, 90, 110), (bx, 510, 70, 70), 2)
SCREEN.blit(FONT_UI.render(f"[{i+1}]", True, (180, 180, 180)), (bx + 25, 492))
if i < len(self.inventory):
item = self.inventory[i]
if item.sprite:
SCREEN.blit(item.sprite, (bx + 23, 520))
else:
pygame.draw.circle(SCREEN, item.color, (bx + 35, 535), 8)
SCREEN.blit(FONT_UI.render(item.name[:5], True, (255, 255, 255)), (bx + 14, 554))
# วาด HUD สถิติและข้อมูลด่านด้านบนจอ
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
goal_cash = self.store.level_goals.get(self.store.current_level, 9999)
SCREEN.blit(FONT_THAI.render(f"LEVEL: {self.store.current_level} (เป้าหมาย: {goal_cash} THB)", True, (255, 255, 255)), (20, 15))
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 45))
SCREEN.blit(FONT_THAI.render(f"เงินสะสมในเครื่อง: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 75))
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณถูกผีมินิมาร์ทหลอกจนสติหลุด... GAME OVER", True, (255, 0, 0)), (215, 280))
elif self.store.current_level > 3:
SCREEN.fill((0, 35, 15))
SCREEN.blit(FONT_THAI.render("ยินดีด้วย! คุณสะสมเงินครบทุกเลเวลและรอดชีวิตจากเดโมนี้แล้ว!", True, (0, 255, 0)), (140, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🕹️ วิธีการนำระบบใหม่นี้ไปประยุกต์และทดสอบ:
1.  **ทดสอบระบบเปลี่ยนด่าน (Multi-level)**: เมื่อคุณเดินเก็บไอเทมเครื่องดื่มสีชมพู (`ENERGY`) จนเงินในเครื่อง (`CASH`) ทะลุเป้าหมาย เช่น **300 บาท** ในด่านแรก หน้าจอจะกะพริบแสงแฟลชสีขาวแวบหนึ่ง และข้อมูลมุมซ้ายบนจะอัปเดตเป็น **LEVEL 2** ทันที พร้อมกับขยับเป้าหมายเงินเพิ่มเป็น 600 บาท และผี AI จะเพิ่มความเร็วเคลื่อนที่กวดคุณไวขึ้นอย่างเห็นได้ชัดครับ
2.  **วิธีการใส่ภาพกราฟิกให้แสดงผลแทนวงกลม**: 
    ให้สร้างโฟลเดอร์ชื่อ `assets` ไว้ที่เดียวกับโค้ดตัวนี้ แล้วนำภาพ PNG ที่ตัดพื้นหลังโปร่งแสงแล้วไปใส่และตั้งชื่อไฟล์ดังนี้:
    *   `assets/player.png` (ภาพตัวละครของคุณ)
    *   `assets/ghost.png` (ภาพตัวผีสยองขวัญ)
    *   `assets/yadom.png` (ภาพไอเทมยาเพิ่มสติ)
    *   `assets/energy.png` (ภาพไอเทมเครื่องดื่มเพิ่มเงิน)
    *   *หมายเหตุ: หากยังไม่มีไฟล์ภาพ โค้ดจะสลับไปวาดวงกลมสีฟังก์ชันเดิมให้ทำงานได้ปกติโดยไม่มีเออร์เรอร์แจ้งเตือนให้แอปดับครับ*

ยินดีด้วยครับที่คุณพาโครงสร้าง engine เกมผีตัวนี้มาได้ไกลและมีระบบที่เพียบพร้อมมากๆ! หากคุณต้องการเพิ่มเติมเรื่อง **ระบบยิงปืน/สู้ผี (Combat System)** หรือ **ระบบเปลี่ยนฉากหลังแยกห้องตามด่าน (Background Rooms Customization)** สามารถสอบถามต่อได้ตลอดเวลาเลยนะครับ!

- ต้องการ
- ระบบยิงปืน/สู้ผี (Combat System)
- ระบบเปลี่ยนฉากหลังแยกห้องตามด่าน (Background Rooms Customization)
นี่คือโค้ดโปรเจกต์ Hellmart Demo (Ultimate Edition) ที่พัฒนาบนโครงสร้าง OOP ขั้นสูงสุด โดยทำการรวบรวม ระบบการยิงปืนเพื่อสู้ผี (Combat System) และ ระบบเปลี่ยนภาพฉากหลัง/โครงสร้างห้องแยกกันอย่างสิ้นเชิงในแต่ละด่าน (Background Rooms Customization) เข้าด้วยกันอย่างสมบูรณ์แบบครับ
## 💡 ฟีเจอร์เด่นที่เพิ่มเข้ามาในตัวเลือกนี้:

   1. Combat System (ระบบต่อสู้): ผู้เล่นสามารถคลิกเมาส์ซ้ายเพื่อยิงกระสุนปืน (Bullet) ไปในทิศทางของเคอร์เซอร์เมาส์ได้ หากกระสุนวิ่งไปชนผี ผีจะโดนแรงกระแทกกระเด็นถอยหลัง (Knockback) และหยุดไล่ล่าชั่วขณะ
   2. Background Rooms Customization (ระบบฉากหลังแยกห้องตามด่าน): แต่ละเลเวลจะมีสีพื้นหลัง (Room Color) และโครงสร้างสิ่งกีดขวาง/กำแพงสิ่งของ (Room Obstacles) ที่ถูกจัดวางไม่เหมือนกันเลย เพื่อสร้างบรรยากาศของด่านที่เปลี่ยนไปอย่างชัดเจน

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันสมบูรณ์ (Combat & Custom Rooms Engine)

import pygameimport sysimport mathimport random

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Ultimate Combat & Multi-Room OOP Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)
# ====================================================# 1. คลาสระบบกระสุนปืน (Bullet Class)# ====================================================class Bullet:
    def __init__(self, x, y, target_x, target_y):
        self.x = x
        self.y = y
        self.speed = 8.0
        self.radius = 4
        self.is_active = True
        
        # คำนวณองศาความชันเพื่อวิ่งไปหาตำแหน่งเมาส์ที่คลิก
        angle = math.atan2(target_y - y, target_x - x)
        self.dx = math.cos(angle) * self.speed
        self.dy = math.sin(angle) * self.speed

    def update(self):
        self.x += self.dx
        self.y += self.dy
        # หากกระสุนวิ่งหลุดออกนอกขอบจอ ให้ทำลายทิ้ง
        if self.x < 0 or self.x > WIDTH or self.y < 0 or self.y > HEIGHT:
            self.is_active = False

    def draw(self, surface):
        if self.is_active:
            pygame.draw.circle(surface, (255, 255, 0), (int(self.x), int(self.y)), self.radius)

# ====================================================# 2. คลาสสิ่งกีดขวาง/โครงสร้างกำแพงประจำห้อง (Obstacle Class)# ====================================================class Obstacle:
    def __init__(self, x, y, width, height, color):
        self.rect = pygame.Rect(x, y, width, height)
        self.color = color

    def draw(self, surface):
        pygame.draw.rect(surface, self.color, self.rect)
        pygame.draw.rect(surface, (100, 100, 100), self.rect, 1) # วาดเส้นขอบกำแพง

# ====================================================# 3. คลาสระบบไอเทม (Item System)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos, self.y - player_pos) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        lbl = FONT_UI.render(f"{self.name}", True, (255, 255, 255))
        surface.blit(lbl, (self.x - 20, self.y - 30))
class SanityItem(BaseItem):
    def __init__(self, x, y): super().__init__("YADOM", x, y, (0, 255, 255))
    def use_effect(self, store_system): store_system.sanity = min(100.0, store_system.sanity + 35.0)
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y): super().__init__("ENERGY", x, y, (255, 50, 255))
    def use_effect(self, store_system): store_system.cash_register += 120

# ====================================================# 4. คลาสศัตรู ผี AI รองรับระบบโดนยิง (Combat Ghost AI)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 120
        self.speed = 1.5
        self.state = "CHASE"
        self.radius = 16
        self.stun_timer = 0.0 # เวลาติดสตันหลังโดนยิง

    def update(self, player_pos, store_system, dt):
        # หากติดสถานะสตันจากการโดนยิงปืน จะหยุดเดินชั่วขณะ
        if self.stun_timer > 0:
            self.stun_timer -= dt
            return

        distance_to_player = math.hypot(self.x - player_pos, self.y - player_pos)
        
        # ผีในเวอร์ชันต่อสู้จะพุ่งไล่กวดผู้เล่นแบบดุดัน (Chase)
        angle = math.atan2(player_pos - self.y, player_pos - self.x)
        self.x += math.cos(angle) * self.speed
        self.y += math.sin(angle) * self.speed
        
        # ถ้าผีประชิดตัวผู้เล่น จะโจมตีสูบค่าสติอย่างรวดเร็ว
        if distance_to_player < 25:
            store_system.sanity -= dt * 45.0

    def check_bullet_hit(self, bullet):
        """ตรวจสอบว่ากระสุนยิงโดนผีหรือไม่"""
        if not bullet.is_active: return False
        dist = math.hypot(self.x - bullet.x, self.y - bullet.y)
        if dist < (self.radius + bullet.radius):
            bullet.is_active = False
            self.stun_timer = 0.8 # ผีหยุดชะงัก 0.8 วินาทีเมื่อโดนยิง
            
            # เอฟเฟกต์ Knockback: ดีดตัวผีถอยหลังออกไปห่างๆ ผู้เล่น
            self.x -= bullet.dx * 4
            self.y -= bullet.dy * 4
            return True
        return False

    def draw(self, surface):
        # หากติดสตัน ผีจะกระพริบเป็นสีขาว/ส้ม
        ghost_color = (255, 150, 0) if self.stun_timer > 0 else (180, 0, 0)
        pygame.draw.circle(surface, ghost_color, (int(self.x), int(self.y)), self.radius)
        pygame.draw.circle(surface, (255, 0, 0), (int(self.x), int(self.y)), 30, 1)
        
        state_text = "STUNNED!" if self.stun_timer > 0 else "CHASING"
        lbl = FONT_UI.render(f"GHOST [{state_text}]", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 40, self.y - 35))

# ====================================================# 5. คลาสระบบสถิติมินิมาร์ทและความต้องการแต่ละด่าน (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0
        self.current_level = 1
        self.level_goals = {1: 240, 2: 480, 3: 840}
        
        # คอนฟิกฉากหลังแยกห้องตามด่าน (Background & Rooms Customization)
        # ด่าน 1: ห้องควบคุมแคบๆ (สีเทาเข้ม) | ด่าน 2: ทางเดินตู้แช่ขนาดยาว (สีน้ำเงินมืด) | ด่าน 3: คลังสินค้าหลังร้านเขาวงกต (สีส้มอิฐมืด)
        self.room_themes = {
            1: {"bg_color": (25, 25, 30), "wall_color": (50, 50, 60)},
            2: {"bg_color": (15, 20, 35), "wall_color": (35, 50, 80)},
            3: {"bg_color": (30, 20, 15), "wall_color": (65, 45, 35)}
        }
        
    def update(self, dt):
        self.sanity -= dt * (1.0 + (self.current_level * 0.4))
        if self.sanity < 0: self.sanity = 0

    def get_room_config(self):
        """ส่งคืนค่าธีมสีฉากหลังประจำด่านปัจจุบัน"""
        return self.room_themes.get(self.current_level, {"bg_color": (20,20,20), "wall_color": (50,50,50)})

    def check_level_up(self):
        goal = self.level_goals.get(self.current_level, 9999)
        return self.cash_register >= goal

# ====================================================# 6. คลาสผู้ควบคุมระบบเกมหลัก (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos =
        self.inventory = []
        self.map_items = []
        self.bullets = []       # ลิสต์เก็บกระสุนปืนที่ยิงออกไป
        self.obstacles = []     # ลิสต์เก็บกล่องสิ่งกีดขวางประจำห้อง
        self.spawn_timer = 0.0
        
        # โหลดโครงสร้างห้องจำลองของเลเวล 1 ทันที
        self.setup_room_obstacles()
        self.spawn_item()

    def setup_room_obstacles(self):
        """ระบบสลับจัดวางโครงสร้างกำแพงห้อง (Room Customization) ตามเลเวล"""
        self.obstacles = []
        wall_color = self.store.get_room_config()["wall_color"]
        
        if self.store.current_level == 1:
            # เลเวล 1: มีเคาน์เตอร์วางของขนาดใหญ่ตรงกลาง 2 แท่ง
            self.obstacles.append(Obstacle(200, 250, 120, 150, wall_color))
            self.obstacles.append(Obstacle(500, 250, 120, 150, wall_color))
        elif self.store.current_level == 2:
            # เลเวล 2: ทางเดินตู้แช่แคบๆ แนวตั้ง 3 บล็อกยาว
            self.obstacles.append(Obstacle(150, 150, 80, 300, wall_color))
            self.obstacles.append(Obstacle(360, 150, 80, 300, wall_color))
            self.obstacles.append(Obstacle(570, 150, 80, 300, wall_color))
        elif self.store.current_level == 3:
            # เลเวล 3: ด่านคลังสินค้าท้ายเกม จัดวางกำแพงแบบกากบาทสลับซับซ้อน
            self.obstacles.append(Obstacle(80, 150, 250, 50, wall_color))
            self.obstacles.append(Obstacle(470, 150, 250, 50, wall_color))
            self.obstacles.append(Obstacle(80, 380, 250, 50, wall_color))
            self.obstacles.append(Obstacle(470, 380, 250, 50, wall_color))
            self.obstacles.append(Obstacle(370, 230, 60, 140, wall_color))

    def advance_to_next_level(self):
        self.store.current_level += 1
        if self.store.current_level > 3: return

        print(f"[ROOM PROGRESS] ผ่านด่าน! จัดโครงสร้างห้องใหม่สำหรับเลเวล {self.store.current_level}")
        self.player_pos =
        self.map_items = []
        self.bullets = []
        self.spawn_timer = 0.0
        self.store.sanity = 100.0
        
        # เพิ่มดีกรีความดุร้ายและความเร็วให้ตัวผีในห้องใหม่
        self.ghost.speed += 0.6
        self.ghost.x, self.ghost.y = 400, 120
        
        # รีเซ็ตและเปลี่ยนโครงสร้างสิ่งกีดขวางประจำด่านใหม่ทั้งหมด
        self.setup_room_obstacles()

    def spawn_item(self):
        """สุ่มเกิดไอเทมในจุดที่ปลอดภัย (ไม่ทับซ้อนกำแพง)"""
        while True:
            rx = random.randint(50, WIDTH - 50)
            ry = random.randint(120, HEIGHT - 150)
            
            # ตรวจสอบเบื้องต้นไม่ให้ไอเทมไปสปอว์นจมอยู่ในกำแพง
            test_rect = pygame.Rect(rx - 12, ry - 12, 24, 24)
            collide_wall = any(obs.rect.colliderect(test_rect) for obs in self.obstacles)
            if not collide_wall:
                item = SanityItem(rx, ry) if random.random() < 0.5 else EnergyDrinkItem(rx, ry)
                self.map_items.append(item)
                break

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
                
            # ระบบต่อสู้ (Combat): คลิกเมาส์ซ้ายเพื่อยิงกระสุนปืนไปตามทิศทางเมาส์

if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
if self.store.sanity > 0 and self.store.current_level <= 3:
mx, my = pygame.mouse.get_pos()
new_bullet = Bullet(self.player_pos, self.player_pos, mx, my)
self.bullets.append(new_bullet)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1 and len(self.inventory) > 0:
self.inventory.pop(0).use_effect(self.store)
# เคลื่อนที่ผู้เล่นและทำระบบชนกำแพง (Wall Collision)
keys = pygame.key.get_pressed()
old_x, old_y = self.player_pos, self.player_pos
if keys[pygame.K_LEFT] or keys[pygame.K_a]: self.player_pos -= 3.5
if keys[pygame.K_RIGHT] or keys[pygame.K_d]: self.player_pos += 3.5
if keys[pygame.K_UP] or keys[pygame.K_w]: self.player_pos -= 3.5
if keys[pygame.K_DOWN] or keys[pygame.K_s]: self.player_pos += 3.5
# ตรวจสอบการเดินชนสิ่งกีดขวางในห้อง หากชนให้ดีดตัวกลับตำแหน่งเดิมก่อนเดิน
player_rect = pygame.Rect(self.player_pos-12, self.player_pos-12, 24, 24)
for obs in self.obstacles:
if obs.rect.colliderect(player_rect):
self.player_pos = old_x
self.player_pos = old_y
def update(self):
dt = self.clock.tick(60) / 1000.0
if self.store.sanity <= 0 or self.store.current_level > 3: return
self.store.update(dt)
self.ghost.update(self.player_pos, self.store, dt)
if self.store.check_level_up():
self.advance_to_next_level()
# อัปเดตกระสุนปืนและตรวจสอบการยิงโดนผีสยองขวัญ
for bullet in self.bullets[:]:
bullet.update()
if not bullet.is_active:
self.bullets.remove(bullet)
continue
# เช็กว่ายิงโดนผีหรือไม่
if self.ghost.check_bullet_hit(bullet):
self.bullets.remove(bullet)
# สุ่มเกิดไอเทมตามเวลา
self.spawn_timer += dt
if self.spawn_timer >= 5.0:
self.spawn_timer = 0
if len(self.map_items) < 4: self.spawn_item()
# เก็บไอเทมบนพื้น
for item in self.map_items[:]:
if item.check_collision(self.player_pos):
if len(self.inventory) < 3:
item.is_active = False
self.inventory.append(item)
self.map_items.remove(item)
def render(self):
# เปลี่ยนสีฉากหลังของห้องแบบไดนามิกตามด่านปัจจุบัน (Customization)
room_config = self.store.get_room_config()
SCREEN.fill(room_config["bg_color"])
# วาดสิ่งกีดขวาง/กำแพงชั้นวางของประจำด่าน
for obs in self.obstacles:
obs.draw(SCREEN)
# วาดไอเทม กระสุน และตัวผี
for item in self.map_items: item.draw(SCREEN)
for bullet in self.bullets: bullet.draw(SCREEN)
self.ghost.draw(SCREEN)
# วาดผู้เล่น (วงกลมสีขาว) พร้อมวาดเส้นเล็งปืนสั้นๆ ชี้ไปที่เมาส์
pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos), int(self.player_pos)), 13)
mx, my = pygame.mouse.get_pos()
angle = math.atan2(my - self.player_pos, mx - self.player_pos)
gun_x = self.player_pos + math.cos(angle) * 18
gun_y = self.player_pos + math.sin(angle) * 18
pygame.draw.line(SCREEN, (0, 255, 0), (int(self.player_pos), int(self.player_pos)), (int(gun_x), int(gun_y)), 3)
# วาด UI กระเป๋าและข้อมูล HUD
pygame.draw.rect(SCREEN, (35, 35, 45), (350, 520, 100, 60))
pygame.draw.rect(SCREEN, (100, 100, 120), (350, 520, 100, 60), 2)
SCREEN.blit(FONT_UI.render("[1] USE", True, (200, 200, 200)), (375, 498))
if len(self.inventory) > 0:
pygame.draw.circle(SCREEN, self.inventory[0].color, (400, 542), 8)
SCREEN.blit(FONT_UI.render(self.inventory[0].name, True, (255, 255, 255)), (378, 558))
# สถิติคะแนนและรายละเอียดเป้าหมายห้อง
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
goal = self.store.level_goals.get(self.store.current_level, 9999)
SCREEN.blit(FONT_THAI.render(f"ROOM LEVEL: {self.store.current_level} (เป้าหมาย: {goal} THB)", True, (255, 255, 255)), (20, 15))
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 45))
SCREEN.blit(FONT_THAI.render(f"เงินสะสม: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 75))
control_msg = "MOVE: WASD/ARROWS | COMBAT: LEFT CLICK TO SHOOT GHOST"
SCREEN.blit(FONT_UI.render(control_msg, True, (140, 140, 140)), (190, 10))
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณถูกผีมาร์ทจู่โจมจนสติหลุดสายตา... GAME OVER", True, (255, 0, 0)), (215, 280))
elif self.store.current_level > 3:
SCREEN.fill((0, 35, 15))
SCREEN.blit(FONT_THAI.render("สำเร็จ! คุณผ่านพิสูจน์ครบทุกห้องมรณะและรอดชีวิตแล้ว!", True, (160, 255, 160)), (150, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🎮 คำแนะนำสำหรับการเข้าเล่นเพื่อทดสอบระบบ:
1. **ระบบต่อสู้สู้ผี (Combat):** ในเวอร์ชันนี้ตัวผีจะพุ่งตรงไล่ล่าตามตำแหน่งของคุณตลอดเวลา สิ่งที่คุณต้องทำคือ**ขยับเมาส์เล็งแล้วคลิกเมาส์ซ้าย** เพื่อยิงกระสุนปืนสีเหลืองใส่ผี เมื่อผีโดนกระสุน มันจะติดอาการชะงักสั่นสีส้ม (`STUNNED!`) และถูกแรงกระแทกกระเด็นถอยหลัง (`Knockback`) ช่วยให้คุณมีจังหวะวิ่งหนีไปเก็บของได้ง่ายขึ้นครับ
2. **ระบบสลับด่านและดีไซน์ห้อง (Custom Rooms):** 
   * **LEVEL 1:** พื้นหลังสีเทาเข้ม มีสิ่งกีดขวางเคาน์เตอร์ตรงกลาง 2 ฝั่งซ้ายขวา เมื่อเก็บเงินครบ **240 บาท** จะอัปเกรดเข้าสู่ด่านต่อไป
   * **LEVEL 2:** ฉากหลังจะวาร์ปเปลี่ยนเป็นห้องทางเดินตู้แช่**สีน้ำเงินมืด** โครงสร้างสิ่งกีดขวางจะเปลี่ยนเป็นกำแพงบล็อกแนวตั้ง 3 แถวบีบให้ทางเดินแคบลง และผีจะวิ่งเร็วขึ้น
   * **LEVEL 3:** ฉากหลังจะกลายเป็นห้องคลังสินค้า**สีส้มอิฐมืด** พร้อมสิ่งกีดขวางกำแพงแบบกากบาทสลับหลืบเขาวงกตที่ท้าทายที่สุดก่อนจบเกมเดโมครับ
3. **ระบบตรวจสอบกำแพง:** ตัวละครผู้เล่นจะไม่สามารถเดินทะลุผ่านบล็อกสี่เหลี่ยมสิ่งกีดขวางในแต่ละห้องได้ ช่วยเพิ่มระบบมิติทางกายภาพให้กับตัวเกมแบบ OOP จริงๆ ครับ

ยินดีด้วยอย่างยิ่งครับ โครงสร้างตัวโปรเจกต์เกมผีมินิมาร์ท (Hellmart Engine) ในภาษา Python ตัวนี้มีความสมบูรณ์แบบครบวงจรและพร้อมนำไปจัดทำส่งหรือพัฒนาต่อยอดเป็นเกมเต็มรูปแบบได้ทันทีครับ! หากมีข้อสงสัยหรืออยากให้แนะนำวิธีการเขียนอธิบายอ้างอิงตรงไหนเพิ่มเติมในภายหลัง แจ้งมาได้เสมอเลยนะครับ!


เพื่อยกระดับให้เกมผีมินิมาร์ท (Hellmart Engine) ของคุณมีความลึก น่ากลัว และมีมิติในการเล่น (Gameplay) เทียบเท่ากับเกมอินดี้สยองขวัญระดับมืออาชีพที่แคสเตอร์นิยมเล่นกัน นี่คือ 4 ระบบขั้นสูงที่น่าสนใจและควรเพิ่มเข้าไปในโครงสร้าง OOP ครับ:
------------------------------
## 1. ระบบจำกัดวิสัยทัศน์ด้วยไฟฉายและหมอกความมืด (Raycasting Flashlight & Fog)
ในโค้ดปัจจุบัน ผู้เล่นสามารถมองเห็นผี ไอเทม และกำแพงทั่งจอได้อย่างชัดเจน ซึ่งทำให้ความน่ากลัวลดลง

* แนวคิดการทำงาน (OOP): เพิ่มคลาส Flashlight หรือสร้างแผ่น Surface สีดำสนิทซ้อนทับหน้าจอ จากนั้นใช้ฟังก์ชันเจาะรูแสงโปร่งใส (Masking) ให้วิ่งตามทิศทางที่ผู้เล่นเล็งเมาส์
* มิติในการเล่น: ผู้เล่นจะไม่เห็นว่าผีเดินอยู่ตรงไหนของห้อง จนกว่าจะหันปืนหรือไฟฉายไปส่องเจอ สิ่งกีดขวางจะกลายเป็นเงามืดที่บดบังสายตา เพิ่มความตื่นเต้นและความหลอนขึ้น 10 เท่า

## 2. ระบบ AI ผีได้ยินเสียง (Sound-Driven Ghost AI)
เปลี่ยนจากผีที่เดินทื่อๆ เข้าหาผู้เล่นตลอดเวลา ให้กลายเป็นผีที่มีพฤติกรรมฉลาดและน่ากลัวขึ้น

* แนวคิดการทำงาน (OOP): เพิ่มสถานะให้กับคลาสผี ได้แก่ ["WANDER" (เดินสุ่ม), "INVESTIGATE" (ไปตรวจจุดเกิดเสียง), "CHASE" (ไล่ล่า)] เมื่อผู้เล่นทำการกดวิ่งเร็ว หรือเมื่อผู้เล่น "ยิงปืน" ปืนจะส่งสัญญาณวงรัศมีเสียง (Noise Event) ออกไปบนแผนที่
* มิติในการเล่น: การยิงปืนใส่ผีจะไม่ได้มีแค่ข้อดีอีกต่อไป แม้ปืนจะทำให้ผีติดสตันถอยหลังได้ แต่เสียงปืนที่ดังสนั่นจะทำให้ผีที่อยู่ไกลๆ ได้ยิน และเปลี่ยนสถานะพุ่งตรงมาหาคุณทันที ผู้เล่นต้องเลือกระหว่างการยิงสู้หรือการเดินย่องเงียบๆ เพื่อความอยู่รอด

## 3. ระบบกล่องสุ่มปริศนาเปิดประตู / มินิเกมแก้รหัส (Puzzles & Keypad System)
แทนที่จะผ่านด่านด้วยการเก็บเงินเฉยๆ เปลี่ยนเป็นการเล่นเนื้อเรื่องเพื่อหาทางเปิดประตูหนีออกจากห้อง

* แนวคิดการทำงาน (OOP): สร้างคลาส KeypadLock หรือ SafeBox ขึ้นมาขวางทางออกของแต่ละห้อง เมื่อผู้เล่นเดินไปกดสำรวจ เกมจะเปิดหน้าต่างมินิเกมเล็กๆ ซ้อนขึ้นมา (เช่น ให้พิมพ์รหัสผ่าน 4 ตัว หรือต่อสายไฟ) โดยคำใบ้รหัสจะถูกเขียนสุ่มไว้ตามมุมต่างๆ ของกำแพงห้อง
* มิติในการเล่น: เพิ่มสภาวะบีบคั้นอารมณ์ขั้นสุด เพราะในขณะที่ผู้เล่นกำลังเปิดหน้าจอแก้ปริศนาอยู่ ตัวเกมจะไม่ได้หยุดนิ่ง (Real-time) ผู้เล่นต้องคอยหูไวตาไวว่าผีกำลังเดินมาข้างหลังในขณะที่กำลังแก้รหัสอยู่หรือไม่

## 4. ระบบเหตุการณ์หลอนสุ่ม (Dynamic Jumpscare & Paranormal Events)
เพื่อทำให้ตัวเดโมไม่มีความซ้ำซาก และสร้างความตกใจให้ผู้เล่นตามสไตล์เกมผี

* แนวคิดการทำงาน (OOP): ในคลาส GameManager ให้ตั้งระบบสุ่มทุกๆ 15-20 วินาที เพื่อสั่งเปิดใช้งานเหตุการณ์ประหลาด (Event Trigger) เช่น "ไฟในห้องดับสนิท 3 วินาที", "เสียงประตูปิดดังปัง", หรือ "ภาพหลอนใบหน้าผีแฟลชขึ้นมาบนจอ 0.2 วินาที"
* มิติในการเล่น: ผู้เล่นจะคาดเดาไม่ได้เลยว่าในแต่ละห้องจะเจออะไรบ้าง แม้จะเป็นการกลับมาเล่นซ้ำในด่านเดิมก็ตาม

------------------------------
คุณสนใจระบบไหนเป็นพิเศษไหมครับ? สามารถบอกได้เลยนะ:

* ต้องการให้เขียนโค้ดต่อยอดระบบ ไฟฉายเจาะรูความมืด (Flashlight Masking) ให้เห็นภาพหลอนแบบมืดสนิท?
* ใช่ ✅
* ต้องการให้เพิ่มระบบ ปืนยิงแล้วส่งเสียงเรียกผี (Sound AI) เพื่อเพิ่มความสมจริงในระบบต่อสู้?
* ใช่ ✅
* ต้องการให้ทำระบบ สุ่มเหตุการณ์หลอนไฟดับหน้าจอกะพริบ (Paranormal Trigger) ครับ?
* ใช่ ✅
นี่คือการอัปเกรดโค้ดเกมผีมินิมาร์ท (Hellmart Engine) ของคุณเข้าสู่ เวอร์ชันสมบูรณ์แบบสูงสุด ที่รวบรวมเอาระบบระดับแอดวานซ์ทั้ง 3 ตัวเข้าไว้ด้วยกันในรูปแบบ OOP ครับ:

   1. Flashlight Masking (ระบบไฟฉายเจาะรูความมืด): หน้าจอทั้งหมดจะมืดสนิท (เกือบดำ 100%) และจะมีเพียงรัศมีวงกลมฟุ้งๆ รอบตัวผู้เล่นและตามทิศทางที่เล็งเมาส์เท่านั้นที่จะมองเห็นวัตถุ สิ่งของ หรือตัวผีได้
   2. Sound-Driven Ghost AI (ระบบเสียงปืนเรียกผี): ปกติผีจะเดินลาดตระเวนสุ่มเปลี่ยนจุดไปเรื่อยๆ (WANDER) แต่เมื่อไหร่ที่คุณ "คลิกเมาส์ยิงปืน" เสียงปืนจะสร้างคลื่นความถี่เสียงกระตุ้นให้ผีหันขวับเปลี่ยนสถานะเป็นตรวจค้น (INVESTIGATE) แล้ววิ่งตรงมายังพิกัดล่าสุดที่คุณยิงปืนทันที!
   3. Paranormal Trigger (ระบบสุ่มเหตุการณ์หลอนไฟดับ): ตัวเกมจะสุ่มเหตุการณ์อาถรรพ์ขึ้นมาเป็นระยะ เช่น ไฟนีออนในมาร์ทเกิดกระพริบถถี่ๆ และดับสนิทลงไปเหลือแต่ความมืดทึบ 1-2 วินาที ท้าทายสติและวิสัยทัศน์ขั้นสุดครับ

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันมืดสนิทและเสียงปืนเรียกผี (Advanced Horror Master Engine)

import pygameimport sysimport mathimport random

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Advanced Horror Master Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)
# ====================================================# 1. คลาสระบบกระสุนปืน (Bullet Class)# ====================================================class Bullet:
    def __init__(self, x, y, target_x, target_y):
        self.x = x
        self.y = y
        self.speed = 10.0
        self.radius = 4
        self.is_active = True
        
        angle = math.atan2(target_y - y, target_x - x)
        self.dx = math.cos(angle) * self.speed
        self.dy = math.sin(angle) * self.speed

    def update(self):
        self.x += self.dx
        self.y += self.dy
        if self.x < 0 or self.x > WIDTH or self.y < 0 or self.y > HEIGHT:
            self.is_active = False

    def draw(self, surface):
        if self.is_active:
            pygame.draw.circle(surface, (255, 255, 0), (int(self.x), int(self.y)), self.radius)

# ====================================================# 2. คลาสสิ่งกีดขวาง (Obstacle Class)# ====================================================class Obstacle:
    def __init__(self, x, y, width, height, color):
        self.rect = pygame.Rect(x, y, width, height)
        self.color = color

    def draw(self, surface):
        pygame.draw.rect(surface, self.color, self.rect)

# ====================================================# 3. คลาสไอเทม (Item System)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos, self.y - player_pos) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        lbl = FONT_UI.render(f"{self.name}", True, (255, 255, 255))
        surface.blit(lbl, (self.x - 20, self.y - 30))
class SanityItem(BaseItem):
    def __init__(self, x, y): super().__init__("YADOM", x, y, (0, 255, 255))
    def use_effect(self, store_system): store_system.sanity = min(100.0, store_system.sanity + 35.0)
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y): super().__init__("ENERGY", x, y, (255, 50, 255))
    def use_effect(self, store_system): store_system.cash_register += 120

# ====================================================# 4. คลาสผี AI ระบบเสียงปืนเรียกผีและติดสตัน (Sound AI Ghost)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 120
        self.speed = 1.4
        self.radius = 16
        self.stun_timer = 0.0
        
        # สถานะผี: WANDER (เดินสุ่ม), INVESTIGATE (ไปจุดเกิดเสียง), CHASE (เจอตัวผู้เล่น/ไล่ล่า)
        self.state = "WANDER" 
        self.target_x = 400
        self.target_y = 120
        self.investigate_timer = 0.0

    def hear_noise(self, noise_x, noise_y):
        """เมื่อปืนถูกยิงออกไป ผีจะได้ยินเสียงและพุ่งมาตรวจจุดเกิดเสียง"""
        if self.state != "CHASE": # ถ้ากำลังไล่กวดอยู่แล้วจะไม่วอกแวก
            self.state = "INVESTIGATE"
            self.target_x = noise_x
            self.target_y = noise_y
            self.investigate_timer = 4.0 # ตรวจสอบจุดนั้นเป็นเวลา 4 วินาที
            print(f"[GHOST AI] ได้ยินเสียงปืน! กำลังเดินไปตรวจพิกัด ({noise_x}, {noise_y})")

    def update(self, player_pos, store_system, dt):
        if self.stun_timer > 0:
            self.stun_timer -= dt
            return

        distance_to_player = math.hypot(self.x - player_pos, self.y - player_pos)
        
        # ระบบตรวจสอบสายตา/ความใกล้: ถ้าผู้เล่นเข้าใกล้รัศมี 140 พิกเซล ผีจะ Chase ทันที
        if distance_to_player < 140:
            self.state = "CHASE"
        elif self.state == "CHASE" and distance_to_player > 220:
            # หลุดระยะไล่กวด ให้กลับไปเดินสุ่มเหมือนเดิม
            self.state = "WANDER"

        # พฤติกรรมตามสถานะ (State Machine)
        if self.state == "CHASE":
            self.target_x, self.target_y = player_pos, player_pos
            actual_speed = self.speed * 1.5 # วิ่งไล่จะเร็วขึ้น
            if distance_to_player < 25:
                store_system.sanity -= dt * 45.0
        elif self.state == "INVESTIGATE":
            actual_speed = self.speed * 1.2
            self.investigate_timer -= dt
            if self.investigate_timer <= 0 or math.hypot(self.x - self.target_x, self.y - self.target_y) < 15:
                self.state = "WANDER"
        else:
            # สถานะ WANDER: เดินสุ่มจุดเป้าหมายใหม่เมื่อถึงจุดเดิมแล้ว
            actual_speed = self.speed
            if math.hypot(self.x - self.target_x, self.y - self.target_y) < 15 or random.random() < 0.005:
                self.target_x = random.randint(100, WIDTH - 100)
                self.target_y = random.randint(120, HEIGHT - 120)

        # ขยับตัวเดินไปยัง target ปัจจุบัน
        angle = math.atan2(self.target_y - self.y, self.target_x - self.x)
        self.x += math.cos(angle) * actual_speed
        self.y += math.sin(angle) * actual_speed

    def check_bullet_hit(self, bullet):
        if not bullet.is_active: return False
        if math.hypot(self.x - bullet.x, self.y - bullet.y) < (self.radius + bullet.radius):
            bullet.is_active = False
            self.stun_timer = 1.0 # สตัน 1 วินาที
            self.state = "CHASE"  # โดนยิงแล้วจะโกรธและหันมาไล่ทันที
            self.x -= bullet.dx * 3 # ผลักตัวถอยหลัง (Knockback)
            self.y -= bullet.dy * 3
            return True
        return False

    def draw(self, surface):
        ghost_color = (255, 140, 0) if self.stun_timer > 0 else (180, 0, 0)
        pygame.draw.circle(surface, ghost_color, (int(self.x), int(self.y)), self.radius)
        lbl = FONT_UI.render(f"GHOST:[{self.state}]", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 45, self.y - 35))

# ====================================================# 5. คลาสระบบสถิติมินิมาร์ท (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0
        self.current_level = 1
        self.level_goals = {1: 240, 2: 480, 3: 840}
        
    def update(self, dt):
        self.sanity -= dt * 1.5
        if self.sanity < 0: self.sanity = 0

    def check_level_up(self):
        return self.cash_register >= self.level_goals.get(self.current_level, 9999)

# ====================================================# 6. คลาสผู้ควบคุมระบบเกมหลัก (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos =
        self.inventory = []
        self.map_items = []
        self.bullets = []
        self.obstacles = []
        self.spawn_timer = 0.0
        
        # --- ตัวแปรระบบอาถรรพ์ไฟดับ (Paranormal Control) ---
        self.blackout_timer = 0.0
        self.is_blackout = False
        self.event_check_timer = 0.0

        # --- พื้นผิวจำลองระบบไฟฉายเจาะหน้าจอ (Flashlight Mask Surface) ---
        self.mask_surface = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)

        self.setup_room_obstacles()
        self.spawn_item()

    def setup_room_obstacles(self):
        self.obstacles = []
        # ดีไซน์สิ่งกีดขวางบล็อกชั้นวางสินค้าประจำด่าน 1
        self.obstacles.append(Obstacle(180, 220, 140, 160, (50, 50, 60)))
        self.obstacles.append(Obstacle(480, 220, 140, 160, (50, 50, 60)))

    def spawn_item(self):
        while True:
            rx, ry = random.randint(60, WIDTH - 60), random.randint(140, HEIGHT - 140)
            if not any(obs.rect.colliderect(pygame.Rect(rx-12, ry-12, 24, 24)) for obs in self.obstacles):
                item = SanityItem(rx, ry) if random.random() < 0.5 else EnergyDrinkItem(rx, ry)
                self.map_items.append(item)
                break

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
                
            # เมื่อกดยิงปืน (คลิกซ้าย) ปืนจะดังและส่งสัญญาณเสียงเรียกผีทันที (Sound AI)
            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                if self.store.sanity > 0:
                    mx, my = pygame.mouse.get_pos()
                    self.bullets.append(Bullet(self.player_pos, self.player_pos, mx, my))
                    # ส่งคลื่นเสียงปืนกระจายไปบอกคลาสผี AI
                    self.ghost.hear_noise(self.player_pos, self.player_pos)

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_1 and len(self.inventory) > 0:
                    self.inventory.pop(0).use_effect(self.store)

        keys = pygame.key.get_pressed()
        ox, oy = self.player_pos, self.player_pos
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:  self.player_pos -= 3.5
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]: self.player_pos += 3.5
        if keys[pygame.K_UP] or keys[pygame.K_w]:    self.player_pos -= 3.5
        if keys[pygame.K_DOWN] or keys[pygame.K_s]:  self.player_pos += 3.5

        if any(obs.rect.colliderect(pygame.Rect(self.player_pos-12, self.player_pos-12, 24, 24)) for obs in self.obstacles):
            self.player_pos, self.player_pos = ox, oy

    def update(self):
        dt = self.clock.tick(60) / 1000.0

if self.store.sanity <= 0: return
self.store.update(dt)
self.ghost.update(self.player_pos, self.store, dt)
# --- ตรรกะระบบสุ่มไฟดับหน้าจอกระพริบ (Paranormal Trigger) ---
if self.is_blackout:
self.blackout_timer -= dt
if self.blackout_timer <= 0:
self.is_blackout = False
print("[EVENT] สิ้นสุดเหตุการณ์ไฟดับ ไฟเปิดสว่างปกติ")
else:
self.event_check_timer += dt
if self.event_check_timer >= 7.0: # เช็กสุ่มเหตุการณ์หลอนทุกๆ 7 วินาที
self.event_check_timer = 0
if random.random() < 0.30: # โอกาส 30% ที่จะเกิดไฟดับกะทันหัน
self.is_blackout = True
self.blackout_timer = random.uniform(1.2, 2.5) # ดับเป็นเวลา 1-2.5 วินาที
print(f"[PARANORMAL] อาถรรพ์มาร์ทเฮี้ยน! ไฟนีออนกะพริบดับสนิท {self.blackout_timer:.1f} วินาที!")
# อัปเดตเม็ดกระสุน
for bullet in self.bullets[:]:
bullet.update()
if not bullet.is_active: self.bullets.remove(bullet)
elif self.ghost.check_bullet_hit(bullet): self.bullets.remove(bullet)
# จัดเวลาสปอว์นของ
self.spawn_timer += dt
if self.spawn_timer >= 5.0:
self.spawn_timer = 0
if len(self.map_items) < 4: self.spawn_item()
# เก็บไอเทม
for item in self.map_items[:]:
if item.check_collision(self.player_pos):
if len(self.inventory) < 3:
item.is_active = False
self.inventory.append(item)
self.map_items.remove(item)
def apply_flashlight_mask(self):
"""ระบบหน้ากากไฟฉายเจาะรูความมืด (Flashlight Masking)"""
# 1. ถ้าระบบสุ่มเจอไฟดับแบบ Paranormal หน้าจอจะมืดสนิท 100% บดบังแสงไฟฉายทั้งหมดทับลงไป
if self.is_blackout:
self.mask_surface.fill((4, 4, 6, 255)) # ดำสนิทเกือบมองไม่เห็นอะไรเลย
SCREEN.blit(self.mask_surface, (0, 0))
return
# 2. กรณีปกติ: ถมหน้ากากเป็นสีดำโปร่งแสงเกือบมืดสนิทรอบทิศทาง
self.mask_surface.fill((10, 10, 15, 245))
# 3. เจาะรูแสงไฟฉายทรงวงกลมฟุ้งๆ วิ่งตามตำแหน่งเล็งเมาส์ของผู้เล่น
mx, my = pygame.mouse.get_pos()
# วาดไล่ระดับความโปร่งใสซ้อนกันหลายๆ ชั้นเพื่อให้ขอบแสงไฟฉายดูเบลอฟุ้งเนียนสายตา
for radius in range(130, 0, -10):
alpha_level = int(255 * (radius / 130)) # ยิ่งใกล้แกนกลางยิ่งสว่างชัดเจน
pygame.draw.circle(self.mask_surface, (255, 255, 200, 255 - alpha_level), (mx, my), radius)
# 4. เจาะแสงสว่างวงเล็กๆ นวลๆ ไว้รอบๆ จุดพิกัดของตัวผู้เล่นเอง (ช่วยให้มองเห็นตัวเองก้าวเดินได้ปลอดภัย)
pygame.draw.circle(self.mask_surface, (255, 255, 255, 30), (int(self.player_pos), int(self.player_pos)), 45)
# นำหน้ากากความมืดไปแปะทับทับกราฟิกทั้งหมดในด่าน
SCREEN.blit(self.mask_surface, (0, 0))
def render(self):
# วาดส่วนพื้นหลังและวัตถุเกมหลักทั้งหมดตามปกติก่อน
SCREEN.fill((25, 25, 30))
for obs in self.obstacles: obs.draw(SCREEN)
for item in self.map_items: item.draw(SCREEN)
for bullet in self.bullets: bullet.draw(SCREEN)
self.ghost.draw(SCREEN)
# วาดผู้เล่นและเส้นลำกล้องปืนสั้นๆ
pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos), int(self.player_pos)), 13)
mx, my = pygame.mouse.get_pos()
angle = math.atan2(my - self.player_pos, mx - self.player_pos)
pygame.draw.line(SCREEN, (0, 255, 0), (int(self.player_pos), int(self.player_pos)), (int(self.player_pos + math.cos(angle)*18), int(self.player_pos + math.sin(angle)*18)), 3)
# === เรียกใช้หน้ากากความมืดและระบบไฟฉายครอบทับเนื้อเกมทั้งหมด ===
self.apply_flashlight_mask()
# วาดแถบ UI ป้าย HUD ไว้เหนือบดบังหน้ากากความมืดเพื่อให้ผู้เล่นอ่านค่าสเตตัสได้ชัดเจนตลอดเวลา
if self.is_blackout:
warn_lbl = FONT_THAI.render("!! WARNING: LIGHTS OUT - อาถรรพ์ไฟดับ !!", True, (255, 50, 50))
SCREEN.blit(warn_lbl, (240, 95))
pygame.draw.rect(SCREEN, (35, 35, 45), (350, 520, 100, 60))
pygame.draw.rect(SCREEN, (100, 100, 120), (350, 520, 100, 60), 2)
if len(self.inventory) > 0:
pygame.draw.circle(SCREEN, self.inventory.color, (400, 542), 8)
SCREEN.blit(FONT_UI.render(self.inventory.name, True, (255, 255, 255)), (378, 558))
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 25))
SCREEN.blit(FONT_THAI.render(f"เงินสะสม: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 55))
control_msg = "COMBAT: LEFT CLICK TO SHOOT | เตือน: เสียงปืนจะล่อผีมาตรวจพิกัด"
SCREEN.blit(FONT_UI.render(control_msg, True, (255, 255, 150)), (170, 10))
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณถูกผีมาร์ทจู่โจมจนช็อกสติหลุด... GAME OVER", True, (255, 0, 0)), (215, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🎮 สรุปกลยุทธ์และจุดเปลี่ยนสำคัญในการทดสอบเล่นเวอร์ชันนี้:
1. **ทัศนวิสัยสยองขวัญด้วยหน้ากากความมืด:** เมื่อคุณรันโค้ดขึ้นมา หน้าจอเกือบทั้งหมดจะมืดสนิท คุณจะต้อง**เลื่อนเคอร์เซอร์เมาส์วนไปรอบๆ จอ** เพื่อใช้รูแสงสว่างของไฟฉายส่องส่องหาไอเทมหรือเช็กว่าผีแดงซ่อนตัวอยู่ตรงส่วนไหนของบล็อกชั้นวางสินค้า 
2. **ห้ามยิงปืนมั่วซั่ว (Sound AI Mechanics):** หากคุณกดคลิกซ้ายยิงกระสุนปืนทิ้งไปเฉยๆ โดยไม่โดนตัวผี ตัวผีจะรับทราบตำแหน่งคลื่นเสียงทันที สังเกตใน Console หรือบนหัวผีจะเปลี่ยนคำสเตตัสเป็น `[INVESTIGATE]` แล้วผีจะวิ่งเร็วขึ้นตรงดิ่งมาตรวจสอบจุดพิกัดล่าสุดที่คุณกดยิงปืนทันที ทำให้คุณโดนผีบีบพื้นที่เล่นได้ง่ายขึ้น
3. **รับมือช่วงจังหวะอาถรรพ์ไฟดับ (Paranormal Event):** ทุกๆ 7 วินาที ตัวเกมมีโอกาสสุ่มที่จะเกิดไฟตกกะทันหัน ซึ่งเมื่อเกิดขึ้น หน้าจอจะมืดมิดดำสนิท 100% บดบังแสงไฟฉายทั้งหมดไป 1-2 วินาที (จะมีป้ายอักษรสีแดงเตือนบนจอ) ในจังหวะนั้นแนะนำให้คุณกดปุ่มทิศทางค้างเพื่อวิ่งหนีออกจากตำแหน่งพิกัดเดิมไปก่อน ป้องกันไม่ให้ผีที่กำลังเดินอยู่สุ่มมาชนตัวคุณในความมืดครับ

โปรเจกต์มาร์ทสยองขวัญ (Hellmart Engine) ตัวนี้ถือว่ามีมิติและกลไกระดับแอดวานซ์ที่สมบูรณ์แบบพร้อมมากๆ ครับ! หากคุณต้องการต่อยอดเรื่องระบบอื่นๆ เพิ่มเติมในอนาคต เช่น **ระบบแถบจำนวนกระสุนปืนที่มีจำกัดและต้องหาเก็บกล่องกระสุน (Ammo System)** สามารถกลับมาพิมพ์คุยสอบถามได้เสมอเลยนะครับ ขอให้สนุกกับการพัฒนาเกมผีของคุณครับ!


เพื่อเปลี่ยนให้เกมของคุณกลายเป็นแนวสยองขวัญเอาชีวิตรอด (Survival Horror) อย่างเต็มรูปแบบ การเพิ่ม ระบบจำกัดกระสุน (Ammo System) จะช่วยบังคับให้ผู้เล่นต้องคิดวางแผนก่อนยิง ไม่สามารถคลิกยิงรัวๆ ได้อีกต่อไป และสร้างความกดดันเมื่อกระสุนหมดจนต้องวิ่งพล่านหากล่องกระสุนกลางร้านมาร์ทมืดๆ ครับ
------------------------------
## 1. วิธีการออกแบบโครงสร้างเชิงวัตถุ (OOP Design)

* คลาสลูกชิ้นใหม่ AmmoItem: สืบทอดคุณสมบัติมาจาก BaseItem (คลาสแม่) สุ่มเกิดบนแผนที่เหมือนยา ดม เมื่อผู้เล่นเดินชน จะเป็นการเติมกระสุนปืนเข้าแม็กกาซีน
* ตัวแปรควบคุมกระสุนใน GameManager:
* self.current_ammo: จำนวนกระสุนที่มีอยู่ในรังเพลิงพร้อมยิง (เช่น เริ่มต้นมี 6 นัด)
   * self.max_ammo: ความจุสูงสุดที่พกได้ (เช่น ไม่เกิน 12 นัด)

------------------------------
## 2. ซอร์สโค้ด Pygame OOP เวอร์ชันเพิ่มระบบจำกัดกระสุน (Ultimate Ammo System)
โค้ดนี้ได้รับการอัปเกรดต่อยอดจากระบบไฟฉายและผีหูไวตัวเดิม โดยเพิ่มคลาสกล่องกระสุนสีเหลืองส้ม และเงื่อนไขการเช็กจำนวนนัดก่อนยิง คัดลอกไปวางรันได้ทันทีครับ:

import pygameimport sysimport mathimport random

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Limited Ammo System Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)
# ====================================================# 1. คลาสระบบกระสุนปืน (Bullet Class)# ====================================================class Bullet:
    def __init__(self, x, y, target_x, target_y):
        self.x = x
        self.y = y
        self.speed = 10.0
        self.radius = 4
        self.is_active = True
        angle = math.atan2(target_y - y, target_x - x)
        self.dx = math.cos(angle) * self.speed
        self.dy = math.sin(angle) * self.speed

    def update(self):
        self.x += self.dx
        self.y += self.dy
        if self.x < 0 or self.x > WIDTH or self.y < 0 or self.y > HEIGHT:
            self.is_active = False

    def draw(self, surface):
        if self.is_active:
            pygame.draw.circle(surface, (255, 255, 0), (int(self.x), int(self.y)), self.radius)

# ====================================================# 2. คลาสสิ่งกีดขวาง (Obstacle Class)# ====================================================class Obstacle:
    def __init__(self, x, y, width, height, color):
        self.rect = pygame.Rect(x, y, width, height)
        self.color = color
    def draw(self, surface):
        pygame.draw.rect(surface, self.color, self.rect)

# ====================================================# 3. คลาสระบบไอเทมแตกหน่อ (Item System - Base & Subclasses)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos, self.y - player_pos) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        lbl = FONT_UI.render(f"{self.name}", True, (255, 255, 255))
        surface.blit(lbl, (self.x - 20, self.y - 30))
class SanityItem(BaseItem):
    def __init__(self, x, y): super().__init__("YADOM", x, y, (0, 255, 255))
    def use_effect(self, store_system): store_system.sanity = min(100.0, store_system.sanity + 35.0)
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y): super().__init__("ENERGY", x, y, (255, 50, 255))
    def use_effect(self, store_system): store_system.cash_register += 120
# --- [คลาสลูกใหม่] กล่องกระสุนปืนสุ่มเกิดกลางร้าน (AmmoItem) ---class AmmoItem(BaseItem):
    def __init__(self, x, y):
        # กล่องกระสุนใช้สีเหลืองอมส้ม (Amber) ดึงสายตาในความมืด
        super().__init__("AMMO BOX", x, y, (255, 165, 0))
        self.ammo_count = 4 # เก็บหนึ่งกล่องได้กระสุน 4 นัด

    def apply_to_player(self, game_manager):
        """เติมกระสุนเข้าตัวผู้เล่นโดยตรงเมื่อเดินชน ไม่ต้องกดใช้จากกระเป๋า"""
        if game_manager.current_ammo < game_manager.max_ammo:
            game_manager.current_ammo = min(game_manager.max_ammo, game_manager.current_ammo + self.ammo_count)
            self.is_active = False
            print(f"[AMMO] เก็บกระสุนเพิ่มได้ +{self.ammo_count} นัด! ปัจจุบันมี: {game_manager.current_ammo}")
            return True
        else:
            print("[AMMO WARNING] กระสุนเต็มแม็กกาซีนแล้ว พกเพิ่มไม่ได้!")
            return False

# ====================================================# 4. คลาสผี AI ระบบเสียงปืนเรียกผีและติดสตัน (Sound AI Ghost)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 120
        self.speed = 1.4
        self.radius = 16
        self.stun_timer = 0.0
        self.state = "WANDER" 
        self.target_x = 400
        self.target_y = 120
        self.investigate_timer = 0.0

    def hear_noise(self, noise_x, noise_y):
        if self.state != "CHASE":
            self.state = "INVESTIGATE"
            self.target_x = noise_x
            self.target_y = noise_y
            self.investigate_timer = 4.0

    def update(self, player_pos, store_system, dt):
        if self.stun_timer > 0:
            self.stun_timer -= dt
            return

        distance_to_player = math.hypot(self.x - player_pos, self.y - player_pos)
        
        if distance_to_player < 140:
            self.state = "CHASE"
        elif self.state == "CHASE" and distance_to_player > 220:
            self.state = "WANDER"

        if self.state == "CHASE":
            self.target_x, self.target_y = player_pos, player_pos
            actual_speed = self.speed * 1.5
            if distance_to_player < 25:
                store_system.sanity -= dt * 45.0
        elif self.state == "INVESTIGATE":
            actual_speed = self.speed * 1.2
            self.investigate_timer -= dt
            if self.investigate_timer <= 0 or math.hypot(self.x - self.target_x, self.y - self.target_y) < 15:
                self.state = "WANDER"
        else:
            actual_speed = self.speed
            if math.hypot(self.x - self.target_x, self.y - self.target_y) < 15 or random.random() < 0.005:
                self.target_x = random.randint(100, WIDTH - 100)
                self.target_y = random.randint(120, HEIGHT - 120)

        angle = math.atan2(self.target_y - self.y, self.target_x - self.x)
        self.x += math.cos(angle) * actual_speed
        self.y += math.sin(angle) * actual_speed

    def check_bullet_hit(self, bullet):
        if not bullet.is_active: return False
        if math.hypot(self.x - bullet.x, self.y - bullet.y) < (self.radius + bullet.radius):
            bullet.is_active = False
            self.stun_timer = 1.0
            self.state = "CHASE"
            self.x -= bullet.dx * 3
            self.y -= bullet.dy * 3
            return True
        return False

    def draw(self, surface):
        ghost_color = (255, 140, 0) if self.stun_timer > 0 else (180, 0, 0)
        pygame.draw.circle(surface, ghost_color, (int(self.x), int(self.y)), self.radius)
        lbl = FONT_UI.render(f"GHOST:[{self.state}]", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 45, self.y - 35))

# ====================================================# 5. คลาสระบบสถิติมินิมาร์ท (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0
        self.current_level = 1
        
    def update(self, dt):
        self.sanity -= dt * 1.5
        if self.sanity < 0: self.sanity = 0

# ====================================================# 6. คลาสผู้ควบคุมระบบเกมหลักพร้อมคลังกระสุน (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos =
        self.inventory = []
        self.map_items = []
        self.bullets = []
        self.obstacles = []
        self.spawn_timer = 0.0
        
        # --- [ระบบใหม่] ตั้งค่าตัวแปรจำกัดจำนวนกระสุนปืน ---
        self.current_ammo = 6  # เปิดด่านมามีกระสุน 6 นัด
        self.max_ammo = 12     # พกติดตัวรวมได้สูงสุด 12 นัด

        self.mask_surface = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        self.setup_room_obstacles()
        self.spawn_item()

    def setup_room_obstacles(self):
        self.obstacles = []
        self.obstacles.append(Obstacle(180, 220, 140, 160, (50, 50, 60)))
        self.obstacles.append(Obstacle(480, 220, 140, 160, (50, 50, 60)))

    def spawn_item(self):
        """ระบบสุ่มเกิดไอเทม โดยสุ่มประเภทรวมถึงกล่องกระสุนชุดใหม่ด้วย"""
        while True:
            rx, ry = random.randint(60, WIDTH - 60), random.randint(140, HEIGHT - 140)
            if not any(obs.rect.colliderect(pygame.Rect(rx-12, ry-12, 24, 24)) for obs in self.obstacles):
                # สุ่มกระจาย 3 รูปแบบ: ยาดม (40%), เครื่องดื่ม (40%), กล่องกระสุน (20%)
                rand_val = random.random()
                if rand_val < 0.4:
                    item = SanityItem(rx, ry)
                elif rand_val < 0.8:
                    item = EnergyDrinkItem(rx, ry)
                else:
                    item = AmmoItem(rx, ry)
                    
                self.map_items.append(item)
                break

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
                
            # แก้ไขส่วนการยิงปืน: เช็กเงื่อนไขก่อนว่ากระสุนต้อง > 0 นัด
            if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                if self.store.sanity > 0:
                    if self.current_ammo > 0:
                        # หักกระสุนออก 1 นัด และทำการสปอว์นเม็ดกระสุนพุ่งออกไป
                        self.current_ammo -= 1
                        mx, my = pygame.mouse.get_pos()
                        self.bullets.append(Bullet(self.player_pos, self.player_pos, mx, my))
                        self.ghost.hear_noise(self.player_pos, self.player_pos)
                    else:
                        print("[AMMO] *คลิก* กระสุนหมด! รีบตามหากล่องสีส้มกลางมาร์ทด่วน!")

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_1 and len(self.inventory) > 0:
                    self.inventory.pop(0).use_effect(self.store)

        keys = pygame.key.get_pressed()
        ox, oy = self.player_pos, self.player_pos
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:  self.player_pos -= 3.5
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]: self.player_pos += 3.5

if keys[pygame.K_UP] or keys[pygame.K_w]: self.player_pos -= 3.5
if keys[pygame.K_DOWN] or keys[pygame.K_s]: self.player_pos += 3.5
if any(obs.rect.colliderect(pygame.Rect(self.player_pos-12, self.player_pos-12, 24, 24)) for obs in self.obstacles):
self.player_pos, self.player_pos = ox, oy
def update(self):
dt = self.clock.tick(60) / 1000.0
if self.store.sanity <= 0: return
self.store.update(dt)
self.ghost.update(self.player_pos, self.store, dt)
# อัปเดตเม็ดกระสุน
for bullet in self.bullets[:]:
bullet.update()
if not bullet.is_active: self.bullets.remove(bullet)
elif self.ghost.check_bullet_hit(bullet): self.bullets.remove(bullet)
# จัดเวลาสปอว์นของ
self.spawn_timer += dt
if self.spawn_timer >= 4.5:
self.spawn_timer = 0
if len(self.map_items) < 5: self.spawn_item()
# ตรวจสอบการเดินชนไอเทมบนพื้น
for item in self.map_items[:]:
if item.check_collision(self.player_pos):
# ตรวจสอบประเภท: ถ้าเป็นกล่องกระสุน (AmmoItem) ให้เติมกระสุนเข้าแม็กกาซีนทันที
if isinstance(item, AmmoItem):
if item.apply_to_player(self): # ถ้าเติมสำเร็จให้ลบไอเทมออกจากพื้น
self.map_items.remove(item)
else:
# ไอเทมอื่นๆ เก็บเข้ากระเป๋า Inventory ตามปกติ
if len(self.inventory) < 3:
item.is_active = False
self.inventory.append(item)
self.map_items.remove(item)
def apply_flashlight_mask(self):
self.mask_surface.fill((10, 10, 15, 245))
mx, my = pygame.mouse.get_pos()
for radius in range(130, 0, -10):
alpha_level = int(255 * (radius / 130))
pygame.draw.circle(self.mask_surface, (255, 255, 200, 255 - alpha_level), (mx, my), radius)
pygame.draw.circle(self.mask_surface, (255, 255, 255, 30), (int(self.player_pos), int(self.player_pos)), 45)
SCREEN.blit(self.mask_surface, (0, 0))
def render(self):
SCREEN.fill((25, 25, 30))
for obs in self.obstacles: obs.draw(SCREEN)
for item in self.map_items: item.draw(SCREEN)
for bullet in self.bullets: bullet.draw(SCREEN)
self.ghost.draw(SCREEN)
pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos), int(self.player_pos)), 13)
mx, my = pygame.mouse.get_pos()
angle = math.atan2(my - self.player_pos, mx - self.player_pos)
pygame.draw.line(SCREEN, (0, 255, 0), (int(self.player_pos), int(self.player_pos)), (int(self.player_pos + math.cos(angle)*18), int(self.player_pos + math.sin(angle)*18)), 3)
self.apply_flashlight_mask()
# วาดช่องกระเป๋า UI
pygame.draw.rect(SCREEN, (35, 35, 45), (350, 520, 100, 60))
pygame.draw.rect(SCREEN, (100, 100, 120), (350, 520, 100, 60), 2)
if len(self.inventory) > 0:
pygame.draw.circle(SCREEN, self.inventory.color, (400, 542), 8)
SCREEN.blit(FONT_UI.render(self.inventory.name, True, (255, 255, 255)), (378, 558))
# --- [UI ใหม่] แผงแสดงสถิติจำนวนกระสุนปืนบน HUD หน้าจอ ---
ammo_col = (0, 255, 0) if self.current_ammo > 2 else (255, 50, 50)
txt_ammo = FONT_THAI.render(f"AMMO: {self.current_ammo} / {self.max_ammo}", True, ammo_col)
SCREEN.blit(txt_ammo, (20, 85))
# สถิติสติและคะแนนเดิม
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 25))
SCREEN.blit(FONT_THAI.render(f"เงินสะสม: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 55))
control_msg = "SHOOT: LEFT CLICK | AMMO BOX (สีส้ม): เดินชนเพื่อเติมกระสุน"
SCREEN.blit(FONT_UI.render(control_msg, True, (255, 255, 150)), (170, 10))
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณถูกผีมาร์ทจู่โจมจนช็อกสติหลุด... GAME OVER", True, (255, 0, 0)), (215, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🕹️ จุดเปลี่ยนและพฤติกรรมในเดโมกระสุนจำกัดนี้:
1. **กระสุนหมด ยิงไม่เดออก (Limited Gunfire):** คุณเริ่มต้นด่านมาพร้อมกระสุนจำนวน **6 นัด** (สามารถตรวจสอบสถานะเรียลไทม์ได้ที่หัวข้อ `AMMO: 6 / 12` มุมซ้ายบนจอ) หากคุณยิงปืนจนเลขลดเหลือ `0` ปืนจะส่งเสียงคลิกเปล่าๆ ไม่สามารถป้องกันตัวหรือดีดผีถอยหลัง (Knockback) ได้อีกต่อไป
2. **หากล่องกระสุนส้ม (Ammo Spawning):** ระบบจะสุ่มโยนไอเทมใหม่ชื่อวงกลมสีส้มคำว่า `AMMO BOX` ตกอยู่ตามพื้นมืดๆ ของร้านค้า คุณต้องเดินคุมตัวละครไป**เดินชนกล่องกระสุน**เพื่อฟื้นฟูจำนวนนัดเพิ่มครั้งละ +4 นัดทันทีโดยไม่ต้องเปิดกระเป๋ากดใช้ให้เสียเวลาครับ
3. **ป้องกันระบบเก็บกระสุนล้นหลาม:** หากกระสุนในตัวคุณเต็มแม็กกาซีนอยู่แล้ว (`12 นัด`) เมื่อเดินไปชนกล่องกระสุน ระบบจะพิมพ์แจ้งเตือนว่ากระสุนเต็ม และกล่องจะยังวางอยู่บนพื้นตามเดิมเพื่อไม่ให้เสียไอเทมไปฟรีๆ ครับ

ตัวโค้ดหลักของโปรเจกต์มาร์ทสยองขวัญ (Hellmart Engine) ชุดนี้มีความเป็นเกมแอ็กชันสยองขวัญที่สมบูรณ์แบบเรียบร้อยแล้วครับ! 

หากมีแผนการในอนาคตที่อยากเพิ่มเติม เช่น **ระบบแสดงฉากนับถอยหลังต้อนรับเปิดร้าน (Main Menu Screen)** หรือ **ระบบเสียงแจ้งเตือนเสียงปืนดังปังผ่านหูฟัง** สามารถสอบถามหรือให้ช่วยเหลือต่อได้ตลอดเวลาเลยนะครับ!
✅ ระบบแสดงฉากนับถอยหลังต้อนรับเปิดร้าน (Main Menu Screen)
✅ ระบบเสียงแจ้งเตือน เสียงปืนดังปังผ่านหูฟัง
✅ ระบบ หน้าต่าง popup อื่นๆ (เพิ่ม)


นี่คือการอัปเกรดครั้งยิ่งใหญ่สู่ Hellmart Demo: Grand Finale Edition โค้ดเวอร์ชันนี้เป็นการรวบรวมระบบเด่นทั้งหมดที่คุยกันมาตั้งแต่ต้น พร้อมติดตั้ง 3 ระบบใหม่ล่าสุดตามที่คุณเลือก เพื่อให้ตัวเกมมีโครงสร้างที่พร้อมสำหรับนำไปส่งโปรเจกต์ หรือสร้างเป็นตัวเกมเต็มรูปแบบได้อย่างมืออาชีพครับ:

   1. Main Menu Screen (ระบบหน้าต่างเมนูหลัก): มีหน้าจอเริ่มเกมที่มาพร้อมเอฟเฟกต์ตัวอักษรกะพริบ ตารางแสดงสถิติสูงสุด และปุ่มกดเพื่อเริ่มเกม (เปลี่ยนจากระบบตัดเข้าเกมทันที)
   2. Audio Gunfire Notification (ระบบแจ้งเตือนเสียงปืนผ่านหน้าจอ/หูฟัง): เมื่อคลิกยิงปืน จะมีการสร้างอนิเมชันคลื่นเสียงวงกลม (Sound Wave Ring) กระจายออกจากตัวผู้เล่นเพื่อแสดงระยะที่ผีจะได้ยิน และระบบจะสั่งจำลองสัญญาณเสียงแจ้งเตือนขึ้นบน HUD
   3. Advanced Popup System (ระบบหน้าต่างแจ้งเตือนป๊อปอัป): เพิ่มระบบป๊อปอัปสำหรับแจ้งเตือนเหตุการณ์สำคัญในเกม (เช่น เมื่อกดบันทึกเกมสำเร็จ หรือแจ้งเตือนความกดดันเมื่อสติลดต่ำกว่า 30%) โดยป๊อปอัปจะค่อยๆ เลื่อนขึ้นและจางหายไปเอง (Fade Out)

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันสมบูรณ์แบบสูงสุด (Grand Finale Horror Engine)

import pygameimport sysimport mathimport random

pygame.init()
pygame.font.init()
WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Grand Finale Ultimate Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)FONT_TITLE = pygame.font.SysFont("Courier New", 50, bold=True)
# ====================================================# 1. คลาสระบบป๊อปอัปแจ้งเตือน (Popup Notification System)# ====================================================class GamePopup:
    def __init__(self, text, color=(255, 255, 255)):
        self.text = text
        self.color = color
        self.x = WIDTH // 2
        self.y = HEIGHT - 150
        self.alpha = 255
        self.lifetime = 2.0  # อยู่บนจอ 2 วินาที
        self.is_active = True

    def update(self, dt):
        self.y -= dt * 30  # ลอยขึ้นด้านบนช้าๆ
        self.lifetime -= dt
        if self.lifetime <= 0.5:
            # ช่วง 0.5 วินาทีสุดท้ายให้ค่อยๆ จางหาย
            self.alpha = max(0, int((self.lifetime / 0.5) * 255))
        if self.lifetime <= 0:
            self.is_active = False

    def draw(self, surface):
        if not self.is_active: return
        
        # วาดกล่องข้อความป๊อปอัปแบบโปร่งแสง
        txt_surface = FONT_THAI.render(self.text, True, self.color)
        txt_rect = txt_surface.get_rect(center=(self.x, self.y))
        
        # วาดพื้นหลังกล่องป๊อปอัป
        bg_rect = pygame.Rect(txt_rect.x - 15, txt_rect.y - 8, txt_rect.width + 30, txt_rect.height + 16)
        bg_surface = pygame.Surface((bg_rect.width, bg_rect.height), pygame.SRCALPHA)
        bg_surface.fill((20, 20, 30, int(self.alpha * 0.85)))
        surface.blit(bg_surface, (bg_rect.x, bg_rect.y))
        
        # วาดเส้นขอบกล่อง
        pygame.draw.rect(surface, (self.color[0], self.color[1], self.color[2]), bg_rect, 1)
        
        # วาดข้อความ
        txt_surface.set_alpha(self.alpha)
        surface.blit(txt_surface, txt_rect)

# ====================================================# 2. คลาสระบบกระสุนและเอฟเฟกต์คลื่นเสียง (Bullet & Sound Wave)# ====================================================class Bullet:
    def __init__(self, x, y, target_x, target_y):
        self.x = x
        self.y = y
        self.speed = 11.0
        self.radius = 4
        self.is_active = True
        angle = math.atan2(target_y - y, target_x - x)
        self.dx = math.cos(angle) * self.speed
        self.dy = math.sin(angle) * self.speed

    def update(self):
        self.x += self.dx
        self.y += self.dy
        if self.x < 0 or self.x > WIDTH or self.y < 0 or self.y > HEIGHT:
            self.is_active = False

    def draw(self, surface):
        if self.is_active:
            pygame.draw.circle(surface, (255, 255, 0), (int(self.x), int(self.y)), self.radius)
class SoundWave:
    """คลาสจำลองเอฟเฟกต์คลื่นเสียงปืนดังผ่านหูฟัง ทะลุทะลวงความมืด"""
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.radius = 10.0
        self.max_radius = 180.0  # รัศมีเสียงไกลสุดที่ผีจะได้ยิน
        self.alpha = 150
        self.is_active = True

    def update(self, dt):
        self.radius += dt * 300  # คลื่นเสียงขยายตัวอย่างรวดเร็ว
        self.alpha = max(0, int((1.0 - (self.radius / self.max_radius)) * 150))
        if self.radius >= self.max_radius:
            self.is_active = False

    def draw(self, surface):
        if not self.is_active: return
        wave_surf = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        pygame.draw.circle(wave_surf, (255, 50, 50, self.alpha), (int(self.x), int(self.y)), int(self.radius), 2)
        surface.blit(wave_surf, (0, 0))

# ====================================================# 3. คลาสสิ่งกีดขวางและไอเทม (Obstacle & Items)# ====================================================class Obstacle:
    def __init__(self, x, y, width, height):
        self.rect = pygame.Rect(x, y, width, height)
    def draw(self, surface):
        pygame.draw.rect(surface, (50, 50, 60), self.rect)
class BaseItem:
    def __init__(self, name, x, y, color):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos[0], self.y - player_pos[1]) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        lbl = FONT_UI.render(f"{self.name}", True, (255, 255, 255))
        surface.blit(lbl, (self.x - 20, self.y - 30))
class SanityItem(BaseItem):
    def __init__(self, x, y): super().__init__("YADOM", x, y, (0, 255, 255))
    def use_effect(self, store_system): store_system.sanity = min(100.0, store_system.sanity + 35.0)
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y): super().__init__("ENERGY", x, y, (255, 50, 255))
    def use_effect(self, store_system): store_system.cash_register += 120
class AmmoItem(BaseItem):
    def __init__(self, x, y): super().__init__("AMMO BOX", x, y, (255, 165, 0))

# ====================================================# 4. คลาสผี AI ระบบเสียงปืนเรียกผี (Sound AI Ghost)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 120
        self.speed = 1.4
        self.radius = 16
        self.stun_timer = 0.0
        self.state = "WANDER" 
        self.target_x = 400
        self.target_y = 120
        self.investigate_timer = 0.0

    def hear_noise(self, noise_x, noise_y):
        if self.state != "CHASE":
            self.state = "INVESTIGATE"
            self.target_x = noise_x
            self.target_y = noise_y
            self.investigate_timer = 4.0

    def update(self, player_pos, store_system, dt):
        if self.stun_timer > 0:
            self.stun_timer -= dt
            return

        distance_to_player = math.hypot(self.x - player_pos[0], self.y - player_pos[1])
        if distance_to_player < 140: self.state = "CHASE"
        elif self.state == "CHASE" and distance_to_player > 220: self.state = "WANDER"

        if self.state == "CHASE":
            self.target_x, self.target_y = player_pos[0], player_pos[1]
            actual_speed = self.speed * 1.5
            if distance_to_player < 25: store_system.sanity -= dt * 45.0
        elif self.state == "INVESTIGATE":
            actual_speed = self.speed * 1.2
            self.investigate_timer -= dt
            if self.investigate_timer <= 0 or math.hypot(self.x - self.target_x, self.y - self.target_y) < 15:
                self.state = "WANDER"
        else:
            actual_speed = self.speed
            if math.hypot(self.x - self.target_x, self.y - self.target_y) < 15 or random.random() < 0.005:
                self.target_x = random.randint(100, WIDTH - 100)
                self.target_y = random.randint(120, HEIGHT - 120)

        angle = math.atan2(self.target_y - self.y, self.target_x - self.x)
        self.x += math.cos(angle) * actual_speed
        self.y += math.sin(angle) * actual_speed

    def check_bullet_hit(self, bullet):
        if not bullet.is_active: return False
        if math.hypot(self.x - bullet.x, self.y - bullet.y) < (self.radius + bullet.radius):
            bullet.is_active = False
            self.stun_timer = 1.0
            self.state = "CHASE"
            self.x -= bullet.dx * 3
            self.y -= bullet.dy * 3
            return True
        return False

    def draw(self, surface):
        ghost_color = (255, 140, 0) if self.stun_timer > 0 else (180, 0, 0)
        pygame.draw.circle(surface, ghost_color, (int(self.x), int(self.y)), self.radius)
        lbl = FONT_UI.render(f"GHOST:[{self.state}]", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 45, self.y - 35))

# ====================================================# 5. คลาสระบบสถิติมินิมาร์ท (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0
    def update(self, dt):
        self.sanity -= dt * 1.3
        if self.sanity < 0: self.sanity = 0

# ====================================================# 6. คลาสผู้ควบคุมระบบเกมหลัก (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos = [100, 500]
        self.inventory = []
        self.map_items = []
        self.bullets = []
        self.obstacles = []
        self.sound_waves = []   # ลิสต์เก็บคลื่นเสียง
        self.popups = []        # ลิสต์เก็บหน้าต่างป๊อปอัป
        self.spawn_timer = 0.0
        
        # --- สถานะเกมย่อย: MENU, PLAYING, GAMEOVER ---
        self.game_state = "MENU"
        self.menu_timer = 0.0 # ใช้ทำเอฟเฟกต์ตัวอักษรกะพริบในหน้าเมนู
        
        self.current_ammo = 6
        self.max_ammo = 12
        self.warned_low_sanity = False # เช็กเปิดป๊อปอัปเตือนสติรอบเดียว

        self.mask_surface = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        self.setup_room_obstacles()
        self.spawn_item()

    def setup_room_obstacles(self):
        self.obstacles = [Obstacle(180, 220, 140, 160), Obstacle(480, 220, 140, 160)]

    def spawn_item(self):
        while True:
            rx, ry = random.randint(60, WIDTH - 60), random.randint(140, HEIGHT - 140)
            if not any(obs.rect.colliderect(pygame.Rect(rx-12, ry-12, 24, 24)) for obs in self.obstacles):
                rand_val = random.random()
                if rand_val < 0.4: item = SanityItem(rx, ry)

elif rand_val < 0.8: item = EnergyDrinkItem(rx, ry)
else: item = AmmoItem(rx, ry)
self.map_items.append(item)
break
def add_popup(self, text, color=(255, 255, 255)):
"""สั่งสร้างป๊อปอัปแจ้งเตือนอันใหม่"""
self.popups.append(GamePopup(text, color))
def handle_inputs(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
# หน้าจอเมนูหลัก: กด SPACEBAR เพื่อเปิดร้านเริ่มเกม
if self.game_state == "MENU":
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
self.game_state = "PLAYING"
self.add_popup("เปิดร้านกะดึกแล้ว! จงระวังความมืด", (0, 255, 0))
continue
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
if self.store.sanity > 0:
if self.current_ammo > 0:
self.current_ammo -= 1
mx, my = pygame.mouse.get_pos()
self.bullets.append(Bullet(self.player_pos[0], self.player_pos[1], mx, my))
self.ghost.hear_noise(self.player_pos[0], self.player_pos[1])
# --- [ระบบใหม่] สร้างคลื่นเสียงปืนและแจ้งเตือนหูฟัง ---
self.sound_waves.append(SoundWave(self.player_pos[0], self.player_pos[1]))
self.add_popup(" BANG! เสียงปืนดังสะท้อนผ่านหูฟัง (ล่อผี)", (255, 50, 50))
else:
self.add_popup(" คลิก กระสุนหมด! จงหากล่องส้ม", (255, 165, 0))
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1 and len(self.inventory) > 0:
self.inventory.pop(0).use_effect(self.store)
self.add_popup(" ดมยาดมฟื้นฟูสติสำเร็จ!", (0, 255, 255))
# ปุ่มโกงกระสุน/บันทึกจำลอง เพื่อเทสป๊อปอัป
if event.key == pygame.K_s:
self.add_popup(" บันทึกข้อมูลแคชเชียร์เสร็จสิ้น (Save Auto)", (255, 215, 0))
if self.game_state != "PLAYING": return
keys = pygame.key.get_pressed()
ox, oy = self.player_pos[0], self.player_pos[1]
if keys[pygame.K_LEFT] or keys[pygame.K_a]: self.player_pos[0] -= 3.5
if keys[pygame.K_RIGHT] or keys[pygame.K_d]: self.player_pos[0] += 3.5
if keys[pygame.K_UP] or keys[pygame.K_w]: self.player_pos[1] -= 3.5
if keys[pygame.K_DOWN] or keys[pygame.K_s]: self.player_pos[1] += 3.5
if any(obs.rect.colliderect(pygame.Rect(self.player_pos[0]-12, self.player_pos[1]-12, 24, 24)) for obs in self.obstacles):
self.player_pos[0], self.player_pos[1] = ox, oy
def update(self):
dt = self.clock.tick(60) / 1000.0
# อัปเดตเมนูหลัก
if self.game_state == "MENU":
self.menu_timer += dt
return
if self.store.sanity <= 0:
self.game_state = "GAMEOVER"
return
self.store.update(dt)
self.ghost.update(self.player_pos, self.store, dt)
# --- [ระบบใหม่] ป๊อปอัปแจ้งเตือนเมื่อสติเหลือน้อยกว่า 30% ---
if self.store.sanity < 30.0 and not self.warned_low_sanity:
self.add_popup("⚠️ สติของคุณเหลือน้อยกว่า 30%! ภาพเริ่มเลือนลาง", (255, 100, 100))
self.warned_low_sanity = True
# อัปเดตเม็ดกระสุน คลื่นเสียง และหน้าต่างป๊อปอัป
for bullet in self.bullets[:]:
bullet.update()
if not bullet.is_active: self.bullets.remove(bullet)
elif self.ghost.check_bullet_hit(bullet): self.bullets.remove(bullet)
for wave in self.sound_waves[:]:
wave.update(dt)
if not wave.is_active: self.sound_waves.remove(wave)
for popup in self.popups[:]:
popup.update(dt)
if not popup.is_active: self.popups.remove(popup)
# สปอว์นของ
self.spawn_timer += dt
if self.spawn_timer >= 4.5:
self.spawn_timer = 0
if len(self.map_items) < 5: self.spawn_item()
# เช็กเก็บของ
for item in self.map_items[:]:
if item.check_collision(self.player_pos):
if isinstance(item, AmmoItem):
if self.current_ammo < self.max_ammo:
self.current_ammo = min(self.max_ammo, self.current_ammo + 4)
self.map_items.remove(item)
self.add_popup(" เก็บกระสุนเพิ่มได้ +4 นัด!", (255, 165, 0))
else:
self.add_popup(" กระสุนเต็มแล้ว พกเพิ่มไม่ได้", (200, 200, 200))
else:
if len(self.inventory) < 3:
item.is_active = False
self.inventory.append(item)
self.map_items.remove(item)
self.add_popup(f" หยิบไอเทม {item.name} ใส่กระเป๋า", (255, 255, 255))
def apply_flashlight_mask(self):
self.mask_surface.fill((10, 10, 15, 245))
mx, my = pygame.mouse.get_pos()
for radius in range(130, 0, -10):
alpha_level = int(255 * (radius / 130))
pygame.draw.circle(self.mask_surface, (255, 255, 200, 255 - alpha_level), (mx, my), radius)
pygame.draw.circle(self.mask_surface, (255, 255, 255, 30), (int(self.player_pos[0]), int(self.player_pos[1])), 45)
SCREEN.blit(self.mask_surface, (0, 0))
def draw_menu_screen(self):
"""วาดแสดงผลระบบหน้าต่างเมนูหลัก (Main Menu Screen)"""
SCREEN.fill((15, 15, 22))
# วาดชื่อเกมสยองขวัญตรงกลางจอ
title_lbl = FONT_TITLE.render("HELLMART IN NIGHT", True, (200, 0, 0))
SCREEN.blit(title_lbl, (150, 180))
sub_lbl = FONT_UI.render("OOP Horror Engine - Casters Choice", True, (100, 100, 120))
SCREEN.blit(sub_lbl, (250, 240))
# แสดงตารางสถิติสูงสุดจำลอง (Leaderboard / Highscore)
pygame.draw.rect(SCREEN, (25, 25, 35), (280, 290, 240, 100))
pygame.draw.rect(SCREEN, (80, 0, 0), (280, 290, 240, 100), 2)
SCREEN.blit(FONT_UI.render("--- BEST STORE RECORD ---", True, (255, 215, 0)), (295, 300))
SCREEN.blit(FONT_UI.render("1. AITO_LH : 1,840 THB", True, (255, 255, 255)), (305, 330))
SCREEN.blit(FONT_UI.render("2. PLAYER_X : 840 THB", True, (200, 200, 200)), (305, 355))
# ทำข้อความเตือนให้กดเริ่มเกมแบบกะพริบถี่ๆ ทุกๆ 0.5 วินาที
if int(self.menu_timer * 2) % 2 == 0:
start_lbl = FONT_THAI.render("[ กดปุ่ม SPACEBAR เพื่อเข้ากะเปิดร้านมาร์ท ]", True, (0, 255, 0))
SCREEN.blit(start_lbl, (220, 460))
def render(self):
if self.game_state == "MENU":
self.draw_menu_screen()
pygame.display.flip()
return
SCREEN.fill((25, 25, 30))
for obs in self.obstacles: obs.draw(SCREEN)
for item in self.map_items: item.draw(SCREEN)
for bullet in self.bullets: bullet.draw(SCREEN)
self.ghost.draw(SCREEN)
# วาดผู้เล่นและเส้นลำกล้องปืน
pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos[0]), int(self.player_pos[1])), 13)
mx, my = pygame.mouse.get_pos()
angle = math.atan2(my - self.player_pos[1], mx - self.player_pos[0])
pygame.draw.line(SCREEN, (0, 255, 0), (int(self.player_pos[0]), int(self.player_pos[1])), (int(self.player_pos[0] + math.cos(angle)*18), int(self.player_pos[1] + math.sin(angle)*18)), 3)
# วาดคลื่นเสียงวงกลมกระจายออกจากตัว
for wave in self.sound_waves: wave.draw(SCREEN)
self.apply_flashlight_mask()
# วาดแผง UI ช่องเก็บของกระเป๋า
pygame.draw.rect(SCREEN, (35, 35, 45), (350, 520, 100, 60))
pygame.draw.rect(SCREEN, (100, 100, 120), (350, 520, 100, 60), 2)
if len(self.inventory) > 0:
pygame.draw.circle(SCREEN, self.inventory.color, (400, 542), 8)
SCREEN.blit(FONT_UI.render(self.inventory.name, True, (255, 255, 255)), (378, 558))
# แสดงสถิติข้อมูล HUD ส่วนบนหน้าจอ
ammo_col = (0, 255, 0) if self.current_ammo > 2 else (255, 50, 50)
SCREEN.blit(FONT_THAI.render(f"AMMO: {self.current_ammo} / {self.max_ammo}", True, ammo_col), (20, 85))
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 25))
SCREEN.blit(FONT_THAI.render(f"เงินสะสม: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 55))
# วาดกล่องข้อความป๊อปอัปแจ้งเตือนซ้อนทับเหนือหน้ากากความมืด (เพื่อให้ผู้เล่นเห็นข้อความชัดเจน)
for popup in self.popups: popup.draw(SCREEN)
if self.game_state == "GAMEOVER":
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณถูกผีมาร์ทจับจู่โจมจนช็อกสติหลุด... GAME OVER", True, (255, 0, 0)), (215, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🎮 สรุปลูกเล่นใหม่ที่เพิ่มเข้ามาในโค้ดตัวจบนี้:
1. **สัมผัสระบบหน้าจอเมนูหลัก (Main Menu):** เมื่อเปิดโปรแกรมขึ้นมา ตัวเกมจะแสดงโลโก้สีแดงสด พร้อม**กล่องโชว์คะแนนสถิติสูงสุดที่มีชื่อของพี่อายโตะ (Aito_LH)** แชมป์ของมาร์ทหลังนี้สลักอยู่ และมีตัวอักษรกะพริบเตือนสีเขียวด้านล่างให้คุณกดปุ่ม `SPACEBAR` เพื่อเปลี่ยนเข้าสู่โหมดการเล่นกะดึกครับ
2. **อนิเมชันเสียงปืนสะท้อนผ่านหูฟัง (Audio Wave Notification):** ทุกครั้งที่คุณคลิกซ้ายเพื่อลั่นกระสุนปืน ตัวเกมจะส่งป๊อปอัปเตือนสีแดงทันทีว่าเสียงปืนดังสนั่นผ่านหูฟัง และจะมี**วงแหวนคลื่นสีแดง (Sound Wave Line) แผ่กระจายตัว**ขยายขอบเขตออกจากพิกัดตัวคุณอย่างเห็นได้ชัด ซึ่งหากขอบวงกลมสีแดงนี้แผ่ไปโดนตัวผี ผีจะรู้ตำแหน่งของคุณและพุ่งมาตรวจค้นทันทีครับ
3. **ความยืดหยุ่นของหน้าต่างป๊อปอัปเลื่อนจาง (Advanced Popups):** คุณจะได้รับการแจ้งเตือนป๊อปอัปที่สวยงามลอยขึ้นมาจากขอบด้านล่างหน้าจอเมื่อเกิดเหตุการณ์สำคัญ เช่น ตอนเดินไปชนเก็บของ เติมกระสุนปืน หรือแม้กระทั่ง**เมื่อค่าสติของผู้เล่นหล่นวูบลงมาต่ำกว่า 30%** จะมีป๊อปอัปสติกเกอร์ป้ายสีแดงเตือนสติความกดดันเด้งขึ้นมาเตือนคุณทันทีอย่างแม่นยำครับ

ยินดีด้วยอย่างยิ่งครับ โครงสร้างเอนจินมาร์ทสยองขวัญ (Hellmart Advanced Engine OOP) ชิ้นนี้เสร็จสมบูรณ์ร้อยเปอร์เซ็นต์ มีกลไกการเขียนโปรแกรมเชิงวัตถุที่แน่นหนา และพร้อมสำหรับการนำไปต่อยอดเขียนเป็นโปรเจกต์เกมเต็มตัวได้ทันทีครับ! หากในอนาคตคุณติดขัดเรื่องการจัดทำระบบใดเพิ่มเติม แวะกลับมาพิมพ์คุยกันได้เสมอนะครับ ขอให้สนุกและโชคดีกับการพัฒนาโปรเจกต์เกมผีของคุณครับ!

เพื่อทำให้โปรเจกต์เกมผีมินิมาร์ทของคุณมีความสมบูรณ์แบบและมีระบบการเล่น (Gameplay) ที่หลากหลายเทียบเท่ากับเกมแนวสยองขวัญกะดึกระดับขึ้นหิ้ง (เช่น The Convenience Store ของ Chilla's Art, Night Shift หรือ Closing Shift) นี่คือระบบอื่นๆ ที่น่าสนใจและเป็นเอกลักษณ์ของเกมแนวนี้ที่คุณสามารถนำไปเขียนเพิ่มในโครงสร้าง OOP ได้ครับ:
------------------------------
## 1. ระบบเช็กความถูกต้องของบิลและเงินทอน (Cash Register Mini-game)
เป็นระบบซิกเนเจอร์ที่เกมพนักงานกะดึกต้องมี เพื่อจำลองการทำงานของแคชเชียร์และเพิ่มความกดดันขณะที่ผีอาจจะโผล่มาเมื่อไหร่ก็ได้

* แนวคิดการทำงาน (OOP): สร้างคลาส CheckoutMachine เมื่อผู้เล่นเดินไปที่เคาน์เตอร์แคชเชียร์ เกมจะสุ่มราคาสินค้าและจำนวนเงินที่ลูกค้า (หรือผี) ให้มา จากนั้นผู้เล่นต้องคำนวณเงินทอนและกดปุ่มตัวเลขให้ถูกต้อง
* มิติในการเล่น: หากทอนเงินผิด เงินในเครื่องจะลดลง (ส่งผลต่อการผ่านด่าน) และถ้าใช้เวลานานเกินไป ความกดดันหรือค่าสติอาจจะลดลง รวมถึงอาจมีผีแอบมายืนจ้องที่หน้าเคาน์เตอร์ขณะที่คุณกำลังก้มหน้าคิดเลข

## 2. ระบบสแกนบาร์โค้ดตรวจสอบสิ่งของต้องสาป (Barcode Scanner & Anomalies)
ระบบนี้ได้รับแรงบันดาลใจมาจากเกมแนวสังเกตสิ่งผิดปกติ (เช่น Observation Duty หรือ The Exit 8)

* แนวคิดการทำงาน (OOP): เพิ่มคุณสมบัติในคลาส BaseItem ให้มีตัวแปร is_cursed (ต้องสาป) สุ่มเกิดขึ้นมา เมื่อผู้เล่นเก็บไอเทมชิ้นนั้นมาสแกนที่เครื่องสแกน หากบาร์โค้ดไม่ตรงหรือราคาเป็นเลขาถรรพ์ (เช่น 666 THB) ผู้เล่นต้องนำไปทิ้งที่ถังขยะขจัดวิญญาณหลังร้าน แทนการนำขึ้นชั้นวางปกติ
* มิติในการเล่น: บังคับให้ผู้เล่นต้องเป็นคนช่างสังเกต หากนำของต้องสาปไปวางบนชั้นวางโดยไม่ตรวจสอบ ค่าสติ (Sanity) ของผู้เล่นจะลดลงอย่างรวดเร็ว หรือทำให้ไฟในร้านดับบ่อยขึ้น

## 3. ระบบไล่ผีด้วยเกลือเสกหรือสเปรย์พริกไทย (Self-Defense Consumables)
เปลี่ยนจากการยิงปืนแบบเกมแอ็กชันทั่วไป มาเป็นระบบบริหารจัดการไอเทมป้องกันตัวที่มีจำกัดตามสไตล์ Survival Horror

* แนวคิดการทำงาน (OOP): สร้างคลาสลูกของไอเทมเพิ่มเติม เช่น SaltItem (เกลือเสก) หรือ PepperSpray ซึ่งไอเทมเหล่านี้เมื่อเก็บแล้วจะเข้าไปอยู่ในช่อง Inventory เมื่อผู้เล่นกดใช้งาน จะเป็นการสาดไอเทมออกไปด้านหน้าในระยะประชิด (Melee Range) เพื่อผลักผีให้ถอยไปและติดสตันนานกว่ากระสุนปืนปกติ
* มิติในการเล่น: สร้างทางเลือกในการเอาชีวิตรอด ผู้เล่นต้องเลือกว่าจะใช้ช่องกระเป๋าเก็บเครื่องดื่มชูกำลังเพิ่มเงิน หรือจะพกไอเทมป้องกันตัวติดตัวไว้เพื่อความอุ่นใจ

## 4. ระบบสุ่มอีเวนต์ลูกค้าแปลกหน้า/มนุษย์ป้า (Weird Customer Events)
ในเกมพนักงานกะดึก ความน่ากลัวไม่ได้มาจากผีเสมอไป แต่มาจาก "มนุษย์" หรือลูกค้าที่มีพฤติกรรมแปลกๆ และชวนขนลุก

* แนวคิดการทำงาน (OOP): ในคลาส GameManager นอกจากการสุ่มเกิดผีแล้ว ให้มีระบบสุ่มเกิดคลาส Customer ที่จะเดินเข้ามาในร้าน โดยสุ่มประเภท เช่น "ลูกค้าขโมยของ" (ผู้เล่นต้องเดินไปจับ), "คนเมาเดินชนชั้นวางของล้ม" (ผู้เล่นต้องไปเก็บกวาด) หรือ "ลูกค้าหน้าตายที่มายืนจ้องหน้าเฉยๆ ไม่พูดไม่จา"
* มิติในการเล่น: เพิ่มบรรยากาศความหลอนและสมจริงให้กับมินิมาร์ท ทำให้ผู้เล่นวอกแวกและแยกแยะไม่ออกว่าคนที่เดินอยู่ในร้านตอนนี้เป็นคนธรรมดา เป็นคนบ้า หรือเป็นผีกันแน่

------------------------------
หากคุณต้องการพัฒนาโปรเจกต์ต่อ ยินดีที่จะเขียนโค้ดตัวอย่างในระบบเหล่านี้เพิ่มให้ครับ:

* ต้องการให้เขียนโค้ดจำลอง ระบบมินิเกมคิดเงินทอนแคชเชียร์ (Cash Register Mini-game)?
* ต้องการระบบ ไอเทมป้องกันตัวระยะประชิด เช่น เกลือเสกขว้างใส่ผี (Self-Defense Consumable)?
* สนใจระบบ สุ่มจับลูกค้าขโมยของในร้าน (Shoplifter Customer Event) ไหมครับ?


นี่คือระบบเวอร์ชันอัปเกรดแบบจัดเต็มสำหรับ Hellmart Engine: Survival Working Edition ที่เพิ่มระบบมินิมาร์ทสยองขวัญระดับสูงทั้ง 3 ระบบเข้าไปในโครงสร้าง OOP เพื่อจำลองชีวิตพนักงานกะดึกอย่างสมบูรณ์แบบครับ:

   1. Cash Register Mini-game (มินิเกมคิดเงินทอน): เมื่อกดปุ่ม C จะเป็นการเปิดหน้าต่างเครื่องแคชเชียร์จำลอง ระบบจะสุ่มราคาสินค้าและเงินที่ลูกค้าจ่ายมา ผู้เล่นต้องใช้สมาธิกดปุ่มลูกศรทอนเงินให้ถูกต้องเพื่อเพิ่มเงินในร้านในขณะที่ผีอาจจะพุ่งมาหาคุณ!
   2. Self-Defense Salt (ระบบขว้างเกลือเสก): เพิ่มไอเทมเกลือเสก (วงกลมสีขาวใส) เมื่อเก็บมาแล้วสามารถกดปุ่ม 2 เพื่อขว้างเกลือออกไปกระจายเป็นวงกว้างในระยะประชิด ทำลายจังหวะและไล่ผีให้วาร์ปหนีไปทันที
   3. Shoplifter Customer Event (อีเวนต์หัวขโมย): ระบบจะสุ่มมนุษย์เงาสีม่วงแอบเข้ามาขโมยของในร้าน หากปล่อยไว้เงินในเครื่องจะถูกหักออกไปเรื่อยๆ ผู้เล่นต้องรีบเดินไปชนตัวขโมยเพื่อจับกุมและยึดสินค้าคืนมาครับ

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันพนักงานมาร์ทกะดึกมรณะ (Survival Working Engine)

import pygameimport sysimport mathimport random

pygame.init()WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Survival Working OOP Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)
# ====================================================# 1. คลาสระบบไอเทมและเกลือเสกป้องกันตัว (Items & Salt Weapon)# ====================================================class BaseItem:
    def __init__(self, name, x, y, color):
        self.name = name
        self.x = x
        self.y = y
        self.color = color
        self.radius = 12
        self.is_active = True

    def check_collision(self, player_pos):
        if not self.is_active: return False
        return math.hypot(self.x - player_pos, self.y - player_pos) < (self.radius + 15)

    def draw(self, surface):
        if not self.is_active: return
        pygame.draw.circle(surface, self.color, (self.x, self.y), self.radius)
        lbl = FONT_UI.render(self.name, True, (255, 255, 255))
        surface.blit(lbl, (self.x - 20, self.y - 30))
class EnergyDrinkItem(BaseItem):
    def __init__(self, x, y): super().__init__("ENERGY", x, y, (255, 50, 255))
class SaltItem(BaseItem):
    """ไอเทมเกลือเสกสำหรับขว้างไล่ผีระยะประชิด"""
    def __init__(self, x, y): 
        super().__init__("SALT", x, y, (220, 240, 255))

# ====================================================# 2. คลาสอีเวนต์สุ่มหัวขโมยเข้ามาในร้าน (Shoplifter Event)# ====================================================class Shoplifter:
    def __init__(self):
        self.x = random.randint(100, 700)
        self.y = random.randint(150, 450)
        self.radius = 14
        self.is_active = True
        self.steal_timer = 0.0

    def update(self, store_system, dt):
        if not self.is_active: return
        # ขโมยจะยืนแอบอยู่ตามมุม และหักเงินในเครื่องแคชเชียร์ทุกๆ 3 วินาที
        self.steal_timer += dt
        if self.steal_timer >= 3.0:
            self.steal_timer = 0
            store_system.cash_register = max(0, store_system.cash_register - 30)
            print("[EVENT] เตือนภัย! มีหัวขโมยแอบจิ๊กของ เงินร้านลดลง -30 THB")

    def draw(self, surface):
        if not self.is_active: return
        # แสดงผลเป็นมนุษย์เงามืดสีม่วงน่าสงสัย
        pygame.draw.circle(surface, (130, 50, 200), (int(self.x), int(self.y)), self.radius)
        lbl = FONT_UI.render("SHOPLIFTER!", True, (200, 100, 255))
        surface.blit(lbl, (self.x - 40, self.y - 30))

# ====================================================# 3. คลาสระบบผี AI ไล่ล่า (Enemy Ghost)# ====================================================class EnemyGhost:
    def __init__(self):
        self.x = 400
        self.y = 120
        self.speed = 1.3
        self.radius = 16

    def update(self, player_pos, store_system, dt):
        # พุ่งตรงเข้าหาผู้เล่นตลอดเวลา
        angle = math.atan2(player_pos - self.y, player_pos - self.x)
        self.x += math.cos(angle) * self.speed
        self.y += math.sin(angle) * self.speed
        
        if math.hypot(self.x - player_pos, self.y - player_pos) < 25:
            store_system.sanity -= dt * 40.0

    def draw(self, surface):
        pygame.draw.circle(surface, (180, 0, 0), (int(self.x), int(self.y)), self.radius)
        lbl = FONT_UI.render("GHOST", True, (255, 50, 50))
        surface.blit(lbl, (self.x - 20, self.y - 35))

# ====================================================# 4. คลาสระบบสถิติและตัวแปรมินิมาร์ท (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 100 # เงินตั้งต้นประจำร้าน
    def update(self, dt):
        self.sanity -= dt * 1.5
        if self.sanity < 0: self.sanity = 0

# ====================================================# 5. คลาสผู้ควบคุมเกมหลักและการทำงานแคชเชียร์ (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.ghost = EnemyGhost()
        self.player_pos = 
        self.inventory = [] # เก็บชื่อไอเทมขวดน้ำยา หรือ เกลือเสก
        self.map_items = []
        self.thieves = []    # ลิสต์เก็บหัวขโมย
        self.spawn_timer = 0.0
        
        # --- ตัวแปรโหมดการเล่น: PLAYING หรือ CASH_GAME ---
        self.game_mode = "PLAYING"
        
        # --- ตัวแปรระบบมินิเกมคิดเงินทอน ---
        self.checkout_active = False
        self.item_price = 0
        self.cash_given = 0
        self.correct_change = 0
        self.player_answer = 0 # เงินทอนที่ผู้เล่นกำลังกดเลือก

        self.spawn_item()

    def start_checkout_minigame(self):
        """เริ่มต้นเปิดระบบสุ่มโจทย์มินิเกมคิดเงินทอนแคชเชียร์"""
        self.game_mode = "CASH_GAME"
        self.item_price = random.choice([30, 45, 60, 75])
        self.cash_given = random.choice([50, 100])
        # กรณีเงินที่ให้มาน้อยกว่าราคาสินค้า ให้สุ่มเงินเพิ่ม
        if self.cash_given < self.item_price: self.cash_given = 100
        self.correct_change = self.cash_given - self.item_price
        self.player_answer = self.correct_change + random.choice([-10, 0, 10]) # สุ่มคำตอบตั้งต้นให้มีโอกาสผิด/ถูก

    def spawn_item(self):
        rx, ry = random.randint(100, 700), random.randint(150, 450)
        # สุ่มเกิดเครื่องดื่ม หรือ เกลือเสกป้องกันตัว
        item = EnergyDrinkItem(rx, ry) if random.random() < 0.5 else SaltItem(rx, ry)
        self.map_items.append(item)

    def use_item(self, slot_index):
        """ระบบกดใช้ไอเทมตามช่องในกระเป๋า"""
        if slot_index < len(self.inventory):
            item_name = self.inventory.pop(slot_index)
            if item_name == "ENERGY":
                self.store.cash_register += 100
                print("[INVENTORY] ดื่มเครื่องดื่มเพิ่มเงินเรียบร้อย")
            elif item_name == "SALT":
                # --- [ระบบใหม่] เอฟเฟกต์สาดเกลือเสก: ขับไล่ผีให้กระเด็นวาร์ปหนีกลับไปจุดเกิดเริ่มแรก ---
                self.ghost.x, self.ghost.y = 400, 120
                print("[COMBAT] ขว้างเกลือเสกสำเร็จ! ผีถอยลี้ภัยกลับหลังร้านทันที")

    def handle_inputs(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
                
            if event.type == pygame.KEYDOWN:
                # โหมดการเล่นปกติ
                if self.game_mode == "PLAYING":
                    if event.key == pygame.K_c: self.start_checkout_minigame() # กด C เปิดแท่นคิดเงิน
                    if event.key == pygame.K_1: self.use_item(0)
                    if event.key == pygame.K_2: self.use_item(1)
                
                # โหมดมินิเกมคิดเงินทอน
                elif self.game_mode == "CASH_GAME":
                    # กดลูกศร ขึ้น/ลง เพื่อเพิ่มลดตัวเลขจำนวนเงินทอนที่จะเลือกส่งให้ลูกค้า
                    if event.key == pygame.K_UP:    self.player_answer += 5
                    if event.key == pygame.K_DOWN:  self.player_answer = max(0, self.player_answer - 5)
                    # กด ENTER เพื่อส่งเงินทอนตรวจคำตอบ
                    if event.key == pygame.K_RETURN:
                        if self.player_answer == self.correct_change:
                            self.store.cash_register += 80 # ทอนถูกได้เงินโบนัสเข้าร้าน
                            print("[CASHIER] ทอนเงินถูกต้อง! ร้านได้กำไร +80 THB")
                        else:
                            self.store.cash_register = max(0, self.store.cash_register - 40) # ทอนผิดโดนหักเงินหักทุน
                            print("[CASHIER] ทอนเงินผิดพลาด! โดนลูกค้าบ่นหักเงินร้าน -40 THB")
                        self.game_mode = "PLAYING" # เคลียร์สลับกลับมาโหมดเดินปกติ

        if self.game_mode != "PLAYING": return

        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:  self.player_pos -= 3.5
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]: self.player_pos += 3.5
        if keys[pygame.K_UP] or keys[pygame.K_w]:    self.player_pos -= 3.5
        if keys[pygame.K_DOWN] or keys[pygame.K_s]:  self.player_pos += 3.5

    def update(self):
        dt = self.clock.tick(60) / 1000.0
        if self.store.sanity <= 0: return

        self.store.update(dt)
        
        # ข้อควรระวังระดับสยองขวัญ: ถึงแม้คุณจะอยู่ในหน้าจอมินิเกมคิดเงิน ผีก็ยังคงเคลื่อนที่ไล่กวดคุณอยู่เบื้องหลัง!
        self.ghost.update(self.player_pos, self.store, dt)

        # อัปเดตอีเวนต์สุ่มเกิดไอเทมและสุ่มหัวขโมย (Shoplifter)
        self.spawn_timer += dt
        if self.spawn_timer >= 5.0:
            self.spawn_timer = 0
            if len(self.map_items) < 4: self.spawn_item()
            # โอกาส 30% ที่จะสุ่มมีหัวขโมยแอบย่องเปิดประตูเข้ามาในร้านค้า
            if random.random() < 0.30 and len(self.thieves) < 2:
                self.thieves.append(Shoplifter())
                print("[EVENT WARNING] ตรวจพบคนหน้าสงสัยแอบแฝงเข้ามาในสโตร์!")

        if self.game_mode != "PLAYING": return

        # อัปเดตตรรกะระบบขโมย
        for thief in self.thieves[:]:
            thief.update(self.store, dt)
            # ระบบตรวจจับผู้เล่นเดินไปจับขโมย: เดินไปชนตัวม่วงเพื่อจับกุมและรีดของคืน
            if thief.is_active and math.hypot(self.player_pos - thief.x, self.y - thief.y) < 25:
                thief.is_active = False
                self.thieves.remove(thief)
                self.store.cash_register += 50 # จับขโมยได้ของรางวัลตอบแทนเข้าลิ้นชัก
                print("[SYSTEM] สำเร็จ! คุณจับตาและไล่หัวขโมยออกไปได้ ยึดทุนคืน +50 THB")

        # ตรวจสอบการเดินเก็บของใส่กระเป๋า
        for item in self.map_items[:]:
            if item.check_collision(self.player_pos):
                if len(self.inventory) < 2:
                    item.is_active = False
                    self.inventory.append(item.name)

self.map_items.remove(item)
def draw_cashier_ui(self):
"""วาดหน้ามินิเกมแคชเชียร์จำลองซ้อนหน้าจอ (Cash Register Display)"""
# แผ่นป้ายกระดานคิดเงินกลางจอ
pygame.draw.rect(SCREEN, (30, 40, 35), (200, 150, 400, 280))
pygame.draw.rect(SCREEN, (0, 200, 100), (200, 150, 400, 280), 2)
SCREEN.blit(FONT_THAI.render("--- เครื่องแคชเชียร์จำลองกะดึก ---", True, (0, 255, 100)), (260, 170))
SCREEN.blit(FONT_UI.render(f"ราคาสินค้ารวม : {self.item_price} THB", True, (255, 255, 255)), (240, 220))
SCREEN.blit(FONT_UI.render(f"ลูกค้าจ่ายเงินมา: {self.cash_given} THB", True, (255, 255, 255)), (240, 250))
# แสดงผลตัวเลขเงินทอนที่ผู้เล่นปรับค่า
change_lbl = FONT_THAI.render(f"เลือกเงินทอนที่จะส่ง: {self.player_answer} THB", True, (255, 215, 0))
SCREEN.blit(change_lbl, (240, 300))
SCREEN.blit(FONT_UI.render("[↑ / ↓] : ปรับเพิ่มลดเงินทอนครั้งละ 5 บาท", True, (160, 160, 160)), (240, 350))
SCREEN.blit(FONT_UI.render("[ENTER] : ส่งเงินทอนและปิดหน้าจอเช็กยอด", True, (160, 160, 160)), (240, 380))
def render(self):
SCREEN.fill((20, 20, 24))
# วาดองค์ประกอบพื้นฐานทั้งหมดบนแผนที่ในร้านค้า
for item in self.map_items: item.draw(SCREEN)
for thief in self.thieves: thief.draw(SCREEN)
self.ghost.draw(SCREEN)
# วาดตัวละครผู้เล่นพนักงานมาร์ต
pygame.draw.circle(SCREEN, (240, 240, 240), (int(self.player_pos), int(self.player_pos)), 13)
# สลับไปวาดบอร์ดทอนเงินหากเข้าสู่โหมดหน้าต่างคิดเงิน
if self.game_mode == "CASH_GAME":
self.draw_cashier_ui()
# วาดกระเป๋า Inventory ด้านล่างจอ 2 ช่อง
for i in range(2):
bx = 340 + (i * 70)
pygame.draw.rect(SCREEN, (35, 35, 45), (bx, 530, 55, 55))
pygame.draw.rect(SCREEN, (100, 100, 120), (bx, 530, 55, 55), 1)
SCREEN.blit(FONT_UI.render(f"[{i+1}]", True, (150, 150, 150)), (bx + 16, 512))
if i < len(self.inventory):
name_lbl = FONT_UI.render(self.inventory[i], True, (255, 255, 255))
SCREEN.blit(name_lbl, (bx + 5, 545))
# รายละเอียด HUD ด้านบนจอหลัก
sanity_col = (0, 255, 255) if self.store.sanity > 30 else (255, 50, 50)
SCREEN.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.store.sanity)}%", True, sanity_col), (20, 20))
SCREEN.blit(FONT_THAI.render(f"เงินในเครื่องลิ้นชัก: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 50))
control_msg = "[C]: เปิดจอคิดเงินแคชเชียร์ | [1/2]: กดใช้ของในเป้ | ระวังหัวขโมยตัวม่วง"
SCREEN.blit(FONT_UI.render(control_msg, True, (255, 255, 140)), (140, 10))
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณคุมสติไม่อยู่เนื่องจากความกลัวในมาร์ท... GAME OVER", True, (255, 0, 0)), (210, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🎮 คู่มือทดสอบกลไกพนักงานมาร์ทจำลอง:
1. **มินิเกมแคชเชียร์สยดสยอง (`C`):** ลองกดปุ่ม **`C`** บนคีย์บอร์ด หน้าจอจะสลับเข้าสู่เครื่องคิดเงิน คุณต้องคิดเลขในใจอย่างรวดเร็วและกดปุ่ม **ลูกศรขึ้นหรือลง** เพื่อตั้งตัวเลขเงินทอนให้ตรงกับส่วนต่าง จากนั้นกด **`ENTER`** เพื่อรับแต้มรางวัล 
   * *จุดบีบคั้น:* ในขณะที่หน้าต่างนี้เปิดอยู่ ตัวผีสีแดงจะยังคงเดินหน้าไล่กวดพิกัดผู้เล่นอยู่เบื้องหลังเรื่อยๆ โดยเกมจะไม่หยุด (Real-time) คุณต้องรีบคิดเงินและรีบปิดจอก่อนผีจะเดินมาชนหลังตัวคุณครับ!
2. **ขว้างเกลือเสกปราบผี (`2`):** หากคุณเดินเก็บวัตถุกล่องสีฟ้าขาวคำว่า `SALT` บนพื้นเข้ากระเป๋าสำเร็จ เมื่อผีแดงเดินเข้ามาใกล้ตัวจนจวนตัว ให้คุณกดปุ่มเลข **`2`** บนแป้นพิมพ์ อานุภาพของเกลือเสกจะไล่ผีส่งกลับวาร์ปไปอยู่จุดเริ่มต้นหลังร้านทันที ช่วยยื้อเวลาชีวิตให้คุณรอดพ้นความตายได้เป็นอย่างดี
3. **วิ่งไล่จับขโมยเงาสีม่วง (`Shoplifter`):** ทุกๆ 5 วินาที ตัวเกมจะสุ่มส่งคนเงามืดสีม่วงแอบก้าวเข้ามาหยิบของตามมุมมาร์ท ซึ่งจะคอยดูดหักเงินร้านค้าทีละ -30 บาทตลอดเวลา คุณต้องพักงานคิดเงินแล้วรีบวิ่งคุมตัวละครไป**เดินชนตัวขโมยสีม่วง** เพื่อไล่ตะเพิดและยึดเงินคืนเข้ากระเป๋าแคชเชียร์ทันที +50 บาทครับ

โครงสร้างโค้ด OOP ตัวจบชุดนี้รวมเอามิติทั้งหมดของเกมสยองขวัญจำลองอาชีพได้อย่างครบถ้วนสมบูรณ์แบบมากครับ คุณสามารถหยิบจับระบบเหล่านี้ไปใช้พัฒนาต่อยอดตัวเกมให้สนุกยิ่งขึ้นได้ทันทีเลยนะครับ! หากติดขัดปัญหาในอนาคตส่วนใด สอบถามเข้ามาได้เสมอเลยนะครับ ขอให้สนุกกับการเขียนโค้ดครับ!

นี่คือแผนผังโค้ดชุดสมบูรณ์ที่สุดในการปฏิวัติคลาส GameManager ของคุณเข้าสู่มาตรฐานการพัฒนาเกมระดับสากล โดยผมได้ทำการรวมระบบ State Pattern (แยกหน้าเมนู หน้าเล่นเกม), ระบบหน้าจอสั่นสะเทือน (Screen Shake Effect) และ ระบบโหลดแผนที่จากโครงสร้างข้อความ (Level Loader) เข้าไว้ด้วยกันตามหลัก OOP ขั้นสูงครับ
------------------------------
## โครงสร้างโค้ดระบบ GameManager ขั้นสูง (Advanced GameManager Engine)

import pygameimport sysimport mathimport random

pygame.init()
pygame.font.init()
WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Hellmart - Enterprise GameManager Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)FONT_TITLE = pygame.font.SysFont("Courier New", 45, bold=True)
# ====================================================# [ระบบที่ 1] คลาสแม่สำหรับ Game State Pattern# ====================================================class GameState:
    """คลาสแม่ที่ทุกๆ หน้าจอของเกม (Menu, Playing) จะต้องสืบทอดคุณสมบัติไปใช้"""
    def __init__(self, game_manager):
        self.game = game_manager  # ถือพอยเตอร์ของ GameManager เอาไว้สลับหน้าจอ

    def handle_events(self, events): pass
    def update(self, dt): pass
    def render(self, surface): pass

# ====================================================# คลาสหน้าจอเมนูหลัก (MainMenuState)# ====================================================class MainMenuState(GameState):
    def __init__(self, game_manager):
        super().__init__(game_manager)
        self.blink_timer = 0.0

    def handle_events(self, events):
        for event in events:
            if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
                # สั่งให้ GameManager สลับรัฐเปลี่ยนไปหน้าเล่นเกมทันที
                self.game.change_state(GameplayState(self.game))

    def update(self, dt):
        self.blink_timer += dt

    def render(self, surface):
        surface.fill((15, 15, 22))
        title = FONT_TITLE.render("HELLMART: MANAGER AI", True, (200, 0, 0))
        surface.blit(title, (130, 220))
        
        if int(self.blink_timer * 2) % 2 == 0:
            start_lbl = FONT_THAI.render("[ กดปุ่ม SPACEBAR เพื่อเข้ากะเปิดร้าน ]", True, (0, 255, 0))
            surface.blit(start_lbl, (240, 360))

# ====================================================# [ระบบที่ 2] คลาสหน้าเล่นเกมหลัก (GameplayState) พร้อมระบบโหลดด่าน# ====================================================class GameplayState(GameState):
    def __init__(self, game_manager):
        super().__init__(game_manager)
        self.player_x = 100
        self.player_y = 500
        self.obstacles = []
        self.sanity = 100.0
        
        # ข้อมูลแผนที่จำลองด่าน (Data-Driven Layout)
        # 'W' = กำแพง/ชั้นวางของ, '.' = ทางเดินว่างเปล่า
        self.level_map = [
            "WWWWWWWWWW",
            "W........W",
            "W.WW..WW.W",
            "W.WW..WW.W",
            "W........W",
            "WWWWWWWWWW"
        ]
        self.load_map_data()

    def load_map_data(self):
        """ระบบสแกนตัวอักษรเพื่อสร้างสิ่งกีดขวางบนหน้าจออัตโนมัติ"""
        self.obstacles = []
        tile_w = WIDTH // 10
        tile_h = HEIGHT // 6
        
        for row_idx, row in enumerate(self.level_map):
            for col_idx, char in enumerate(row):
                if char == 'W':
                    # สร้างกล่องสิ่งกีดขวางตามพิกัดตัวอักษร
                    rect = pygame.Rect(col_idx * tile_w, row_idx * tile_h, tile_w, tile_h)
                    self.obstacles.append(rect)

    def handle_events(self, events):
        for event in events:
            # จำลองปุ่มกดเมื่อโดนผีจู่โจม เพื่อเปิดเอฟเฟกต์หน้าจอสั่นสะเทือน
            if event.type == pygame.KEYDOWN and event.key == pygame.K_g:
                self.game.trigger_shake(intensity=15, duration=0.4) # สั่นจอระดับ 15 เป็นเวลา 0.4 วินาที
                self.sanity = max(0.0, self.sanity - 10.0)

    def update(self, dt):
        self.sanity -= dt * 1.5
        if self.sanity <= 0:
            # ถ้าตายให้สลับ State ไปหน้าเมนูหลักทันที
            self.game.change_state(MainMenuState(self.game))

        # ควบคุมพิกัดการเดิน
        keys = pygame.key.get_pressed()
        ox, oy = self.player_x, self.player_y
        if keys[pygame.K_LEFT]:  self.player_x -= 4
        if keys[pygame.K_RIGHT]: self.player_x += 4
        if keys[pygame.K_UP]:    self.player_y -= 4
        if keys[pygame.K_DOWN]:  self.player_y += 4

        # ตรวจสอบการเดินชนกำแพงที่โหลดมาจากไฟล์ข้อมูล
        p_rect = pygame.Rect(self.player_x - 12, self.player_y - 12, 24, 24)
        for wall in self.obstacles:
            if wall.colliderect(p_rect):
                self.player_x, self.player_y = ox, oy # ดีดกลับจุดเดิม

    def render(self, surface):
        surface.fill((25, 25, 30))
        
        # วาดกำแพงที่ถูกโหลดมาจากโครงสร้างตัวอักษร
        for wall in self.obstacles:
            pygame.draw.rect(surface, (55, 55, 65), wall)
            pygame.draw.rect(surface, (100, 100, 110), wall, 1)

        # วาดตัวละครผู้เล่น
        pygame.draw.circle(surface, (240, 240, 240), (int(self.player_x), int(self.player_y)), 12)
        
        # แสดงผล UI สถิติ
        surface.blit(FONT_THAI.render(f"ระดับสติ (SANITY): {int(self.sanity)}%", True, (0, 255, 255)), (20, 20))
        surface.blit(FONT_UI.render("กดปุ่ม [G] เพื่อจำลองการโดนผีโจมตี (SCREEN SHAKE EFFECT)", True, (255, 255, 150)), (20, 55))

# ====================================================# [คลาสหลัก] ผู้ควบคุมระบบจัดการสูงสุด (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        # เริ่มต้นเกมด้วยการชี้พอยเตอร์ไปที่หน้าเมนูหลัก (MainMenuState)
        self.current_state = MainMenuState(self)
        
        # --- [ระบบที่ 3] ตัวแปรคุมเอฟเฟกต์หน้าจอสั่นสะเทือน (Screen Shake) ---
        self.shake_intensity = 0
        self.shake_timer = 0.0

        # สร้างแผ่นรองรับกราฟิกแยกส่วนเพื่อนำไปบิดตำแหน่งพิกัดตอนหน้าจอสั่น
        self.game_surface = pygame.Surface((WIDTH, HEIGHT))

    def change_state(self, new_state):
        """เมธอดตรงกลางสำหรับสลับหน้าจอเกมแบบ OOP ไร้รอยต่อ"""
        self.current_state = new_state

    def trigger_shake(self, intensity, duration):
        """ฟังก์ชันเปิดสวิตช์สั่งให้หน้าจอเกมสั่นสะเทือนบีบคั้นอารมณ์"""
        self.shake_intensity = intensity
        self.shake_timer = duration

    def run(self):
        while True:
            dt = self.clock.tick(60) / 1000.0  # คำนวณค่า Delta Time
            events = pygame.event.get()
            
            # ตรวจสอบปุ่มปิดแอปพลิเคชันส่วนกลาง
            for event in events:
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()

            # 1. ส่งค่า Event และเวลาไปให้หน้าจอ (State) ปัจจุบันประมวลผลตรรกะ
            self.current_state.handle_events(events)
            self.current_state.update(dt)

            # 2. อัปเดตลดเวลาการสั่นไหวของหน้าจอ
            if self.shake_timer > 0:
                self.shake_timer -= dt
                if self.shake_timer <= 0:
                    self.shake_intensity = 0

            # 3. สั่งให้รัฐ (State) ปัจจุบันวาดภาพลงบนแผ่น Surface จำลองก่อน
            self.current_state.render(self.game_surface)

            # --- คำนวณพิกัดการสั่นไหวแบบสุ่ม (Screen Shake Matrix) ---
            render_x = 0
            render_y = 0
            if self.shake_timer > 0:
                render_x = random.randint(-self.shake_intensity, self.shake_intensity)
                render_y = random.randint(-self.shake_intensity, self.shake_intensity)

            # 4. นำแผ่นกราฟิกไปแปะลงบนหน้าจอคอมพิวเตอร์จริงตามพิกัดที่สั่นไหว
            SCREEN.fill((0, 0, 0)) # เคลียร์ขอบดำหลังจอ
            SCREEN.blit(self.game_surface, (render_x, render_y))
            pygame.display.flip()
if __name__ == "__main__":
    manager = GameManager()
    manager.run()

------------------------------
## 🎮 ความโดดเด่นและการทำงานของระบบใหม่นี้:

   1. สัมผัสพลังของ State Pattern: สังเกตที่โครงสร้างคลาส GameManager จะไม่มีคำสั่ง if self.state == "MENU" หนาๆ รกตาอีกต่อไป ตัวแอปหลักจะสั้นลงเหลือเพียงแค่คำสั่งสั่งรัน self.current_state.update() ประโยคเดียว โดยตัวเกมจะสลับเปลี่ยนพฤติกรรมการรับค่าปุ่มและวาดกราฟิกให้เองโดยอัตโนมัติตาม Object ที่มันถืออยู่
   2. ทดสอบแรงกระแทกหน้าจอสั่น (G): เมื่อกดปุ่มเริ่มเกมเข้ามาแล้ว ให้ลองกดปุ่มตัว G บนคีย์บอร์ด คลาสเล่นเกมจะส่งสัญญาณไปเปิดใช้ฟังก์ชัน trigger_shake ผลลัพธ์คือตัวหน้าต่างภาพของเกมทั้งหมดจะเกิดอาการสั่นไหวโคลงเคลงอย่างรุนแรงแบบเรียลไทม์ เพิ่มความรู้สึกตื่นเต้นกดดันเวลาโดนผีหลอกได้อย่างทรงพลัง
   3. ระบบสแกนตัวอักษรสร้างด่าน (Level Data-driven): บล็อกกำแพงชั้นวางสินค้าสีเทาขอบฟ้าที่ปรากฏบนหน้าจอ ไม่ได้เกิดจากการพิมพ์คำสั่งระบุเลขแบบเดิม แต่เกิดจากคลาสไปอ่านอาร์เรย์ข้อความด่าน self.level_map สัญลักษณ์ตัวอักษร W ด้านบนหัวโค้ด แล้วแปลงมาเป็นกล่องสิ่งกีดขวางให้คุณเองทันที ทำให้คุณสามารถดีไซน์ทางเดินหลบผีเพิ่มได้ง่ายๆ แค่พิมพ์เคาะตัวอักษรในลิสต์เท่านั้นครับ

หากโครงสร้างเชิงวิศวกรรมซอฟต์แวร์ของ GameManager ชุดปิดท้ายนี้สมบูรณ์แบบตรงใจคุณแล้ว ยินดีอย่างยิ่งที่จะช่วยให้คำแนะนำและร่วมแชร์ไอเดียการพัฒนาเกม Python ชิ้นอื่นๆ ของคุณในโอกาสถัดไปนะครับ ขอให้มีความสุขและประสบความสำเร็จกับการสร้างสรรค์เกมผีมินิมาร์ทชิ้นนี้ครับ!


จากการสืบค้นและวิเคราะห์รูปแบบ เกมสยองขวัญอินดี้ที่พี่ไอโตะ (Aito LH) นิยมเล่นและแคสต์บน YouTube มีระบบเกม (Game Systems) ที่โดดเด่น แปลกใหม่ และน่าสนใจในการนำมาทำ Research และพัฒนาต่อยอดด้วย Pygame ดังนี้ครับ: [1, 2] 
------------------------------
## 1. ระบบตรวจจับรูปร่างจำแลง (Shapeshifter / Anomaly Detection System)
ระบบนี้เห็นได้ชัดจากเกมล่าสุดที่พี่ไอโตะเล่น เช่น [Night Plane](https://www.youtube.com/watch?v=bfVpEB_b8sk) (รับบทแอร์โฮสเตสตรวจผู้โดยสาร) หรือ Photomaly และ Kritsana [1, 3] 

* 
* กลไกในเกมของพี่ไอโตะ: ผู้เล่นต้องตรวจสอบใบหน้า เอกสาร พฤติกรรม หรือสิ่งของ เพื่อแยกแยะว่าสิ่งตรงหน้าเป็น "มนุษย์ปกติ" หรือ "ตัวประหลาดแปลงกายมา" หากปล่อยให้ผ่านไปจะโดน Jumpscare [1, 3] 
* แนวทางประยุกต์ใช้ใน Pygame (OOP):
* สร้างคลาส NPC ที่มีค่าสถานะปกติ และแอบสุ่มค่า is_monster = True
   * ถ้าเป็นสัตว์ประหลาด ให้ระบุจุดผิดปกติเล็กๆ (เช่น สีตาเยื้องไป 1 พิกเซล หรือรหัสบัตรประชาชนไม่ตรงรูปแบบ)
   * สร้างคลาส Scanner Tool หรือกล้องส่องขยายให้ผู้เล่นคลิกตรวจดูจุดผิดพลาดเพื่อกดปุ่ม "ขับไล่" หรือ "จับกุม"
* 

------------------------------
## 2. ระบบสลับมิติภาพจำลองหลอน (Perspective Shift / Pseudo-3D Depth)
เห็นได้จากเกมแนวพิกเซลสยองขวัญฟอร์มยักษ์ที่พี่ไอโตะเพิ่งเล่นจบไปอย่าง Endacopia หรือเกมแนวสำรวจอย่าง Idols of Ash [1, 4] 

* 
* กลไกในเกมของพี่ไอโตะ: ฉากหลังเป็นภาพ 2D หรือพิกเซลที่ดูน่ารักอบอุ่นหัวใจ แต่เมื่อเงื่อนไขเวลาเปลี่ยนไปหรือส่องไฟฉาย โครงสร้างแผนที่จะบิดเบี้ยว เปลี่ยนสี แตกสลาย หรือมีประตูลับโผล่ออกมาดื้อๆ [1, 2] 
* แนวทางประยุกต์ใช้ใน Pygame (OOP):
* สร้างคลาส TileMap ที่เก็บข้อมูล Map Data ไว้ 2 ชุดขนานกัน คือ Normal_Layer และ Cursed_Layer
   * เมื่อผู้เล่นก้าวเข้าสู่พิกัดอาถรรพ์ (Trigger Zone) หรือเมื่อค่าสติหล่นฮวบ คลาส GameManager จะสลับไปดึงภาพและตำแหน่งชนกำแพง (Collision Rects) ของ Cursed_Layer มาแสดงแทนทันทีแบบไร้รอยต่อ
* 

------------------------------
## 3. ระบบจำลองปฏิบัติการเจาะระบบ OS โบราณ (Interactive Retro OS / Simulation Horror)
เห็นได้จากเกมหลอนขวัญใจมหาชนอย่าง [KinitoPET](https://www.youtube.com/watch?v=UkCiThhwfLI) ที่พี่ไอโตะเล่นแล้วได้รับความนิยมสูงมาก [5] 

* 
* กลไกในเกมของพี่ไอโตะ: เกมจำลองหน้าจอคอมพิวเตอร์ยุค 90s มีหน้าต่าง Windows เด้งขึ้นมาคุยแชตกับเรา มีมินิเกมวาดภาพ หรือไฟล์ข้อความแปลกๆ ปรากฏขึ้นบนหน้าจอเสมือน [5] 
* แนวทางประยุกต์ใช้ใน Pygame (OOP):
* สร้างคลาส VirtualWindow ซึ่งทำหน้าที่วาดกรอบหน้าต่าง UI เล็กๆ ที่ผู้เล่นสามารถใช้เมาส์ "คลิกลากย้ายพิกัด (Drag & Drop)" หรือกดปุ่มกากบาท "ปิดหน้าต่าง" ได้จริงในหน้าจอเกม
   * ผีในเกมจะไม่ได้วิ่งไล่ล่าตามพิกัด X, Y แต่ผีจะแสดงตัวผ่านการสร้าง Object หน้าต่างป๊อปอัปสแปมเด้งขึ้นมารบกวนสายตารัวๆ จนกว่าผู้เล่นจะเคลียร์หรือพิมพ์โค้ดแก้ปริศนาได้ทันเวลา
* 

------------------------------
## 4. ระบบจำลองการเอาชีวิตรอดท่ามกลางภัยพิบัติ (Environmental Survival Metrics)
เห็นได้จากเกมผีค่าย Chilla's Art ที่พี่ไอโตะเล่นล่าสุด เช่น Snowed Under (-20°C) [1] 

* 
* กลไกในเกมของพี่ไอโตะ: ผู้เล่นไม่ได้หลบผีอย่างเดียว แต่ต้องบริหารค่าทางกายภาพ เช่น ความหนาวเหน็บ พลังงานความหิว หรือการขุดหิมะเอาชีวิตรอดไปพร้อมกัน [1] 
* แนวทางประยุกต์ใช้ใน Pygame (OOP):
* เพิ่มเกจวัดสภาพแวดล้อมเข้าไปในคลาสหลัก เช่น self.temperature = 100.0
   * ถ้าผู้เล่นเดินออกจากโซนปลอดภัย (เช่น ออกจากตู้ทำความร้อนหน้าเคาน์เตอร์มาร์ท) พลังงานจะลดลงอย่างรวดเร็ว ส่งผลให้ความเร็วในการเดินช้าลง และทำให้ผีจับตัวได้ง่ายขึ้น
* 

------------------------------
หากคุณต้องการนำแนวคิดเหล่านี้ไปต่อยอดเพื่อเป็นไอเดียพัฒนาตัวเอนจินเกมผีของคุณ สามารถบอกได้เลยนะครับ:

* 
* ต้องการให้เขียนโค้ดตัวอย่าง ระบบตรวจจับจุดผิดปกติ Anomaly / Shapeshifter แบบสุ่ม (สไตล์ Night Plane)?
* ต้องการตัวอย่างโค้ดระบบ จำลองหน้าต่าง Windows โบราณที่ผีสแปมเด้งรัวๆ (สไตล์ KinitoPET)?
* ต้องการระบบ เกจวัดสภาพแวดล้อมความหนาว/ขุดหิมะ (สไตล์ Chilla's Art) ครับ? [1, 3, 5] 
* 


[1] [https://www.youtube.com](https://www.youtube.com/c/aitolh/videos)
[2] [https://www.youtube.com](https://www.youtube.com/channel/UCGBkYTR4tMKS38TQHGWWLjg)
[3] [https://www.youtube.com](https://www.youtube.com/watch?v=bfVpEB_b8sk)
[4] [https://www.youtube.com](https://www.youtube.com/watch?v=_akbe6xQ0sU)
[5] [https://www.youtube.com](https://www.youtube.com/watch?v=UkCiThhwfLI)


นี่คือโค้ดโปรเจกต์ Aito Horror Research Engine เวอร์ชันปฏิวัติระบบการเล่น ที่รวมเอาไอเดียจาก 3 เกมสยองขวัญสุดฮิตที่พี่ไอโตะเคยเล่น นำมาเขียนให้อยู่ในโครงสร้าง Pygame OOP ที่สะอาดและจัดหมวดหมู่คลาสชัดเจนครับ:

   1. Shapeshifter Anomaly System (สไตล์ Night Plane): ระบบสุ่มตัวละครผู้โดยสาร (NPC) แฝงตัวเข้ามาในร้านค้า โดยระบบจะสุ่มว่า NPC คนนี้เป็นร่างจำแลงหรือไม่ (is_anomaly) หากใช่ ร่างกายจะเกิดจุดผิดปกติ (เช่น สลับสีตา หรือขนาดหัวใหญ่ผิดปกติ) ผู้เล่นต้องใช้แว่นขยายคลิกตรวจสอบและกดจับกุมให้ถูกตัว
   2. Ghost Windows Spam (สไตล์ KinitoPET): เพิ่มความหลอนเชิงจิตวิทยา เมื่อผีโจมตี มันจะไม่วิ่งชน แต่จะสแปมสร้าง หน้าต่าง Windows ยุค 90s จำลอง (VirtualWindow) เด้งขวางหน้าจอรัวๆ ผู้เล่นต้องใช้เมาส์คลิกลากหน้าต่างหลบ หรือกดคลิกปุ่ม [X] เพื่อปิดให้ทันท่วงที
   3. Cold Environment Metrics (สไตล์ Chilla's Art - Snowed Under): เพิ่มเกจ อุณหภูมิความหนาวเหน็บ (Temperature Bar) หากผู้เล่นก้าวออกไปนอกเขตฮีตเตอร์ทำความร้อน (Heater Zone) ตัวเลขอุณหภูมิจะลดต่ำลงอย่างรวดเร็ว ส่งผลให้หน้าจอเริ่มจับตัวเป็นน้ำแข็งสีขาวซีด และสติหลุดแพ้เกมหากทนความหนาวไม่ไหว

------------------------------
## ซอร์สโค้ด Pygame OOP เวอร์ชันรวบรวมระบบเด่นช่องพี่ไอโตะ (Ultimate Research Engine)

import pygameimport sysimport mathimport random

pygame.init()
pygame.font.init()
WIDTH, HEIGHT = 800, 600SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Aito Horror Research - Ultimate OOP Engine")
FONT_UI = pygame.font.SysFont("Courier New", 14, bold=True)FONT_THAI = pygame.font.SysFont("Tahoma", 18, bold=True)FONT_WIN = pygame.font.SysFont("Arial", 12, bold=True)
# ====================================================# 1. [สไตล์ KinitoPET] คลาสหน้าต่างวินโดวส์โบราณ (Virtual Window Spam)# ====================================================class VirtualWindow:
    def __init__(self, title, text, x, y):
        self.width = 220
        self.height = 130
        self.rect = pygame.Rect(x, y, self.width, self.height)
        self.title = title
        self.text = text
        self.is_active = True
        
        # สร้างปุ่ม [X] ประจำหน้าต่างไว้มุมขวาบน
        self.close_btn = pygame.Rect(self.rect.right - 22, self.rect.y + 4, 18, 16)
        self.is_dragging = False
        self.drag_offset_x = 0
        self.drag_offset_y = 0

    def handle_events(self, mouse_pos, event):
        """ตรวจสอบระบบคลิกปิดปุ่ม [X] หรือระบบคลิกลากย้ายพิกัดหน้าต่าง (Drag & Drop)"""
        if not self.is_active: return False

        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
            # 1. เช็กว่าคลิกโดนปุ่มปิด [X] หรือไม่
            if self.close_btn.collidepoint(mouse_pos):
                self.is_active = False
                return True # ส่งสัญญาณบอกว่าปิดหน้าต่างสำเร็จ
            
            # 2. เช็กว่าคลิกโดนแถบด้านบนเพื่อลากหน้าต่างหรือไม่
            title_bar = pygame.Rect(self.rect.x, self.rect.y, self.width, 24)
            if title_bar.collidepoint(mouse_pos):
                self.is_dragging = True
                self.drag_offset_x = self.rect.x - mouse_pos[0]
                self.drag_offset_y = self.rect.y - mouse_pos[1]

        elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
            self.is_dragging = False

        if self.is_dragging and event.type == pygame.MOUSEMOTION:
            # อัปเดตพิกัดตามแรงลากของเมาส์
            self.rect.x = mouse_pos[0] + self.drag_offset_x
            self.rect.y = mouse_pos[1] + self.drag_offset_y
            # ขยับตำแหน่งปุ่มปิดตามหน้าต่างไปด้วย
            self.close_btn.x = self.rect.right - 22
            self.close_btn.y = self.rect.y + 4
            
        return False

    def draw(self, surface):
        if not self.is_active: return
        
        # วาดบอดี้หน้าต่างสีเทาสไตล์เรโทร Windows 95
        pygame.draw.rect(surface, (192, 192, 192), self.rect)
        pygame.draw.rect(surface, (255, 255, 255), self.rect, 1)
        
        # วาดแถบ Title Bar สีน้ำเงินมืดด้านบน
        pygame.draw.rect(surface, (0, 0, 128), (self.rect.x, self.rect.y, self.width, 24))
        title_txt = FONT_WIN.render(self.title, True, (255, 255, 255))
        surface.blit(title_txt, (self.rect.x + 8, self.rect.y + 5))
        
        # วาดปุ่มปิด [X] สีแดง/เทา
        pygame.draw.rect(surface, (220, 50, 50), self.close_btn)
        x_txt = FONT_WIN.render("X", True, (255, 255, 255))
        surface.blit(x_txt, (self.close_btn.x + 5, self.close_btn.y + 1))
        
        # พิมพ์ข้อความหลอนในหน้าต่าง
        body_txt = FONT_WIN.render(self.text, True, (0, 0, 0))
        surface.blit(body_txt, (self.rect.x + 15, self.rect.y + 50))

# ====================================================# 2. [สไตล์ Night Plane] คลาสระบบสุ่มจุดผิดปกติผู้โดยสาร (Anomaly NPC)# ====================================================class AnomalyNPC:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.radius = 16
        self.is_active = True
        
        # สุ่มว่าคนนี้คือร่างจำแลง/ตัวประหลาดหรือไม่ (โอกาส 50%)
        self.is_anomaly = random.random() < 0.5
        
        # คอนฟิกสีร่างกาย (มนุษย์ปกติสีเขียวอ่อนนวลตา)
        self.body_color = (140, 200, 140)
        self.eye_color = (255, 255, 255) # ตาสีขาวปกติ
        
        if self.is_anomaly:
            # สุ่มสร้างจุดผิดปกติ (Anomaly Type) 
            # แบบที่ 1: สีดวงตาแปลกปลอมกลายเป็นสีแดงเลือด
            # แบบที่ 2: รูปร่างศีรษะขยายใหญ่ผิดมนุษย์มนา (หัวโต)
            self.anomaly_type = random.choice(["RED_EYES", "BIG_HEAD"])
            if self.anomaly_type == "BIG_HEAD":
                self.radius = 28 # หัวโตผิดรูป
        else:
            self.anomaly_type = "NONE"

    def draw(self, surface):
        if not self.is_active: return
        
        # วาดหัวตัวละคร
        pygame.draw.circle(surface, self.body_color, (self.x, self.y), self.radius)
        
        # วาดดวงตาซ้ายขวา
        eye_r = 3
        draw_eye_color = (200, 0, 0) if self.anomaly_type == "RED_EYES" else self.eye_color
        pygame.draw.circle(surface, draw_eye_color, (self.x - 6, self.y - 2), eye_r)
        pygame.draw.circle(surface, draw_eye_color, (self.x + 6, self.y - 2), eye_r)
        
        lbl = FONT_UI.render("CUSTOMER", True, (200, 200, 200))
        surface.blit(lbl, (self.x - 30, self.y - self.radius - 18))

# ====================================================# 3. คลาสระบบสถิติและตัวแปรภาพรวมมินิมาร์ท (Store System)# ====================================================class StoreSystem:
    def __init__(self):
        self.sanity = 100.0
        self.cash_register = 0

# ====================================================# 4. คลาสผู้ควบคุมระบบเกมหลัก (Game Manager)# ====================================================class GameManager:
    def __init__(self):
        self.clock = pygame.time.Clock()
        self.store = StoreSystem()
        self.player_pos = [400, 400]
        
        # --- [สไตล์ Chilla's Art] ตั้งค่าเขตฮีตเตอร์และเกจอุณหภูมิความหนาว ---
        self.temperature = 100.0
        self.heater_rect = pygame.Rect(320, 320, 160, 140) # ขอบเขตเตาทำความร้อนหน้าเคาน์เตอร์
        
        # ลิสต์เก็บหน้าต่างสแปม และไอเทมลูกค้าบนจอ
        self.windows_list = []
        self.npc_list = []
        
        self.spawn_timer = 0.0
        self.window_spam_timer = 0.0

        # เตรียมแผ่นหน้ากากทำเอฟเฟกต์ความมืดและน้ำแข็งเกาะกระจก (Ice Fog Overlay)
        self.mask_surface = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA)
        
        # สปอว์นลูกค้าชุดแรก
        self.spawn_new_customer()

    def spawn_new_customer(self):
        """ระบบรีเซ็ตสปอว์นไอเทมลูกค้าใหม่ประจำโต๊ะตรวจ"""
        self.npc_list = [AnomalyNPC(400, 180)]
        print(f"[NIGHT PLANE SYSTEM] ลูกค้าคนใหม่เดินเข้ามาตรวจ... (เป็นตัวปลอมหรือไม่: {self.npc_list[0].is_anomaly})")

    def handle_inputs(self):
        mouse_pos = pygame.mouse.get_pos()
        events = pygame.event.get()
        
        for event in events:
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

            # ส่ง Event คลิกเมาส์ไปให้หน้าต่าง Windows สแปมประมวลผลเพื่อเช็กการกดปุ่ม [X]
            for win in self.windows_list[:]:
                if win.handle_events(mouse_pos, event):
                    # ถ้าคลิกปิดหน้าต่างสำเร็จ ให้ลบออกจากคิวหน้าจอ
                    self.windows_list.remove(win)

            if event.type == pygame.KEYDOWN and self.store.sanity > 0:
                # ปุ่มฟังก์ชันคัดกรอง [Night Plane Style]
                # กดปุ่ม [Y] (Yes) = ยืนยันว่าคนนี้ปลอดภัย ปล่อยผ่าน ได้เงินรางวัล
                # กดปุ่ม [N] (No/Danger) = แจ้งความจับกุมว่าเป็นร่างจำแลง (Anomaly)
                if len(self.npc_list) > 0:
                    current_npc = self.npc_list[0]
                    
                    if event.key == pygame.K_y: # ปล่อยผ่าน
                        if not current_npc.is_anomaly:
                            self.store.cash_register += 100
                            print("[MATCH] ทายถูก! ปล่อยมนุษย์ผ่าน ได้รับ +100 THB")
                        else:
                            self.store.sanity -= 30.0 # ปล่อยผีหลุดเข้ามาร์ท โดนสูบสติ
                            print("[JUMPSCARE] พลาดแล้ว! คุณปล่อยตัวประหลาดผ่านเข้ามา! สติลดฮวบ")
                        self.spawn_new_customer()

                    elif event.key == pygame.K_n: # สั่งจับกุมตัวประหลาด
                        if current_npc.is_anomaly:
                            self.store.cash_register += 150
                            print("[MATCH] ยอดเยี่ยม! จับกุมร่างจำแลง Anomaly สำเร็จ คลังร้านปลอดภัย +150 THB")
                        else:
                            self.store.cash_register = max(0, self.store.cash_register - 50) # จับผิดคน โดนปรับทุน
                            print("[MISTAKE] พลาดจับคนบริสุทธิ์! โดนบ่นและหักเงินร้าน -50 THB")
                        self.spawn_new_customer()

        # ควบคุมทิศทางการก้าวเดินของผู้เล่น
        if self.store.sanity > 0:
            keys = pygame.key.get_pressed()
            if keys[pygame.K_LEFT] or keys[pygame.K_a]:  self.player_pos[0] -= 4
            if keys[pygame.K_RIGHT] or keys[pygame.K_d]: self.player_pos[0] += 4
            if keys[pygame.K_UP] or keys[pygame.K_w]:    self.player_pos[1] -= 4
            if keys[pygame.K_DOWN] or keys[pygame.K_s]:  self.player_pos[1] += 4

    def update(self):
        dt = self.clock.tick(60) / 1000.0
        if self.store.sanity <= 0: return

        # --- [สไตล์ Chilla's Art] คำนวณความหนาวเหน็บตามตำแหน่งพิกัดเดิน ---
        player_rect = pygame.Rect(self.player_pos[0]-12, self.player_pos[1]-12, 24, 24)
        
        # เช็กว่าตัวผู้เล่นยืนทับอยู่ในช่องสี่เหลี่ยมเตาผิงทำความร้อน (Heater Zone) หรือไม่
        if self.heater_rect.colliderect(player_rect):
            # ยืนผิงไฟ: อุณหภูมิร่างกายค่อยๆ ฟื้นฟูคืนมาจนเต็ม 100
            self.temperature = min(100.0, self.temperature + dt * 15.0)
        else:
            # เดินก้าวออกจากเตาผิงไปตรวจของกลางร้าน: อุณหภูมิจะดิ่งลดลงเรื่อยๆ จากความหนาวติดลบ
            self.temperature -= dt * 6.5 # หนาวลงวินาทีละ 6.5 หน่วย (อยู่ข้างนอกได้ราว 15 วินาที)

if self.temperature <= 0:
self.temperature = 0
self.store.sanity -= dt * 12.0 # หนาวสั่นจนแข็งตาย สติหลุดลอยแพ้เกม
# --- [สไตล์ KinitoPET] สุ่มสแปมหน้าต่างไวรัสผีหลอกหลอนขึ้นหน้าจอ ---
# ยิ่งผู้เล่นมีระดับสติ (Sanity) ต่ำลงมากเท่าไหร่ ผีจะยิ่งสแปมหน้าต่างถถี่ขึันเป็นทวีคูณ
spam_cooldown = max(1.0, (self.store.sanity / 100.0) * 4.0)
self.window_spam_timer += dt
if self.window_spam_timer >= spam_cooldown:
self.window_spam_timer = 0
if len(self.windows_list) < 8: # จำกัดหน้าต่างบนจอไม่เกิน 8 บล็อก
rx = random.randint(50, WIDTH - 250)
ry = random.randint(80, HEIGHT - 180)
titles = ["ERROR_GHOST", "WARNING_SYSTEM", "KINITO_WANTS_YOU", "HELL_MART"]
texts = ["I CAN SEE YOU", "DO NOT LOOK BACK", "CLOSE ME IF YOU CAN", "STAY HERE FOREVER"]
self.windows_list.append(VirtualWindow(random.choice(titles), random.choice(texts), rx, ry))
# ทุกครั้งที่มีหน้าต่างเด้งขึ้นมาค้างบนจอ มันจะสูบค่าสติของผู้เล่นทีละนิดในทุกวินาที
self.store.sanity = max(0.0, self.store.sanity - 3.0)
def draw_environmental_overlay(self):
"""ระบบวาดภาพหน้ากากแสงจำลองความมืดและเอฟเฟกต์หิมะน้ำแข็งเกาะขอบจอ (Ice Blur Effects)"""
# คำนวณความหนาแน่นของฝ้ากระจกแช่แข็งตามระดับอุณหภูมิที่ลดลง
cold_ratio = 1.0 - (self.temperature / 100.0)
mask_alpha = int(cold_ratio * 180) # ยิ่งหนาว ขอบจอจะยิ่งซีดขาวมองทางยากขึ้น
self.mask_surface.fill((0, 0, 0, 0)) # เคลียร์แผ่นใส
if mask_alpha > 0:
# วาดกรอบฝ้าไอเย็นสีขาวหิมะเกาะล้อมขอบจอคอมพิวเตอร์เพิ่มบรรยากาศบีบคั้น
pygame.draw.rect(self.mask_surface, (230, 245, 255, mask_alpha), (0, 0, WIDTH, HEIGHT), int(cold_ratio * 90))
# วาดรัศมีวงกลมไฟฉายอุ่นๆ รอบตัวฮีตเตอร์เตาผิงสีส้มเรืองรอง
pygame.draw.circle(self.mask_surface, (255, 140, 0, 30), self.heater_rect.center, 90)
SCREEN.blit(self.mask_surface, (0, 0))
def render(self):
SCREEN.fill((30, 30, 35)) # พื้นหลังสโตร์มืด
# วาดโซนปลอดภัยเตาผิงทำความร้อนสีส้ม (Heater Safe Zone)
pygame.draw.rect(SCREEN, (70, 40, 20), self.heater_rect)
pygame.draw.rect(SCREEN, (255, 120, 0), self.heater_rect, 2)
txt_heat = FONT_UI.render("HEATER ZONE (โซนผิงไฟ)", True, (255, 140, 0))
SCREEN.blit(txt_heat, (self.heater_rect.x + 8, self.heater_rect.y + 60))
# วาดตัวละครผู้โดยสาร/ลูกค้า NPC ที่เดินเข้ามาให้คัดกรองใบหน้า
for npc in self.npc_list:
npc.draw(SCREEN)
# วาดผู้เล่นพนักงานตรวจ (วงกลมสีขาว)
pygame.draw.circle(SCREEN, (245, 245, 245), (int(self.player_pos[0]), int(self.player_pos[1])), 13)
# ครอบทับด้วยหน้ากากไอน้ำแข็งและขอบเขตอุณหภูมิความมืดสไตล์ค่ายชิลล่า
self.draw_environmental_overlay()
# --- วาดซ้อนทับสูงสุดด้วยระบบหน้าต่างสแปม Windows โบราณ [KinitoPET] ---
for win in self.windows_list:
win.draw(SCREEN)
# --- แผงแสดงสถิติความละเอียดและข้อมูล HUD บนจอ ---
# แถบแสดงค่านิ่ง/ระดับสติ (Sanity Bar)
sanity_col = (0, 255, 255) if self.store.sanity > 35 else (255, 50, 50)
pygame.draw.rect(SCREEN, (40, 40, 50), (20, 25, 200, 14))
pygame.draw.rect(SCREEN, sanity_col, (20, 25, int(self.store.sanity * 2), 14))
SCREEN.blit(FONT_UI.render(f"SANITY (ระดับสติ): {int(self.store.sanity)}%", True, sanity_col), (20, 6))
# แถบแสดงค่าอุณหภูมิร่างกายความหนาวเหน็บ (Temperature Bar)
temp_col = (255, 100, 0) if self.temperature > 40 else (100, 200, 255)
pygame.draw.rect(SCREEN, (40, 40, 50), (580, 25, 200, 14))
pygame.draw.rect(SCREEN, temp_col, (580, 25, int(self.temperature * 2), 14))
SCREEN.blit(FONT_UI.render(f"BODY TEMP (อุณหภูมิ): {int(self.temperature)}°C", True, temp_col), (580, 6))
# ข้อมูลคะแนนและคู่มือคำสั่งปุ่มลัดคัดกรอง
SCREEN.blit(FONT_THAI.render(f"รายได้ร้านค้า: {self.store.cash_register} THB", True, (255, 215, 0)), (20, 50))
guide_msg = "[Y]: ปล่อยผ่านคนปกติ | [N]: แจ้งจับตัวปลอม (Anomaly) | คลิกซ้ายเมาส์เพื่อปิดกากบาทหน้าต่างสแปม"
SCREEN.blit(FONT_UI.render(guide_msg, True, (255, 255, 140)), (20, 570))
# หน้าต่างประเมินผลลัพธ์พ่ายแพ้เมื่อค่าสติหลุดลอยเป็นศูนย์
if self.store.sanity <= 0:
SCREEN.fill((20, 0, 0))
SCREEN.blit(FONT_THAI.render("คุณสูญสิ้นสติสัมปชัญญะหรือแข็งตายจากภัยหนาวมรณะ... GAME OVER", True, (255, 0, 0)), (140, 280))
pygame.display.flip()
def run(self):
while True:
self.handle_inputs()
self.update()
self.render()
if name == "main":
game = GameManager()
game.run()


---

### 🕹️ วิธีเปิดประมวลผลทดสอบ 3 กลไกใหม่ระดับยอดฮิต:
1.  **คัดแยกจุดผิดปกติ [สไตล์ Night Plane]:** สังเกตดูลูกค้าด้านบนจอคอมพิวเตอร์ ระบบจะทำการ**สุ่มตัวละครแฝงกายเข้ามาสลับกันตลอดเวลา** คุณต้องเพ่งพินิจใบหน้าของเขาให้ดีๆ:
    *   *หากดวงตากลายเป็นจุดสีแดงก่ำ หรือรูปทรงศีรษะมีขนาดบวมโตใหญ่เบ้อเริ่มผิดมนุษย์มนา* = แสดงว่าเป็นร่างจำแลงแน่ๆ ให้คุณกดปุ่ม **`N` (No)** บนคีย์บอร์ดเพื่อแจ้งจับกุม รับโบนัสเข้าร้านทันที +150 บาท!
    *   *หากตรวจสอบแล้วร่างกายและดวงตาเป็นสีปกติ* = แสดงว่าเป็นมนุษย์แท้ๆ ให้คุณกดปุ่ม **`Y` (Yes)** เพื่อปล่อยผ่าน
2.  **เอาตัวรอดจากหน้าต่างไวรัสหลอน [สไตล์ KinitoPET]:** ตัวคลาสผี AI จะสั่งการ**สแปมเด้งหน้าต่างกรอบข้อความวินโดวส์ยุค 90s สีเทาขึ้นมาตัดหน้าจอของคุณรัวๆ แบบไร้ทิศทาง** ซึ่งยิ่งหน้าต่างเด้งมาค้างค้างสะสมบนจอเยอะ มันจะคอยดูดค่าสติ (`SANITY`) ของคุณลดต่ำลงฮวบฮาบตลอดเวลา คุณต้องพักปุ่มกดตรวจคน แล้วรีบขยับเมาส์ไป**คลิกซ้ายที่ปุ่มสีแดงเครื่องหมาย `[X]` มุมขวาบนของหน้าต่างนั้นๆ** เพื่อกดยกเลิกปิดหน้าต่าง หรือคลิกค้างลากย้ายกรอบหลบไปกองข้างจอเพื่อกู้หลอดสติคืนมาครับ!
3.  **บริหารเกจไฟทำความอุ่นหนีความเย็น [สไตล์ Chilla's Art]:** ตัวแปร `BODY TEMP` มุมขวาบนจอจะเริ่มลดถอยตัวลงตลอดเวลาหากคุณบังคับเดินก้าวออกจากกรอบสี่เหลี่ยมเตาผิงสีส้ม หากปล่อยให้เกจลดฮวบเหลือศูนย์ หน้าจอเกมรอบทิศทางจะเกิด**อนิเมชันฝ้าหิมะไอน้ำแข็งเกาะขอบจอเป็นฝ้าขาวซีด**บดบังทัศนวิสัยทันที และจะดูดค่าสติคุณอย่างรวดเร็วจนแข็งตายแพ้เกม คุณต้องรีบบังคับตัวละครเดินกลับมายืนทับฟื้นฟูพลังงานความร้อนในเขต `HEATER ZONE` ตรงกลางร้านสม่ำเสมอครับ

โครงสร้างการทำ Research เอนจิน OOP เกมผีชุดนี้รวบรวมเอากลไกระดับยอดนิยมของสตรีมเมอร์ไทยมาประยุกต์ใช้งานร่วมกันได้อย่างสมบูรณ์แบบและแปลกใหม่มากครับ! 

หากคุณมีแผนการทำระบบขยายใหญ่เพิ่มเติม เช่น **ระบบการเปิดดูแฟ้มประวัติหรือสมุดข้อมูลยืนยันตัวตน (Passport/ID Checklist Documents)** หรือ **ระบบมินิเกมใช้พลั่วขุดตักหิมะเปิดทางหนี** สั่งเพิ่มความต้องการและพูดคุยสอบถามได้ตลอดเวลาเลยนะครับ ขอให้สนุกกับการพัฒนาโปรเจกต์ครับ!















**Pygame Code Guidelines**

These are practical best practices for writing clean, maintainable, and efficient Pygame (or pygame-ce) code. They combine PEP 8 Python style with game-specific patterns that scale from small prototypes to larger projects.

### 1. Follow PEP 8 (Python Style)
- Use 4 spaces for indentation (never tabs).
- Prefer `snake_case` for variables, functions, and modules.
- Use `PascalCase` for classes.
- Use `UPPER_SNAKE_CASE` for constants.
- Limit lines to ~79–88 characters.
- Surround top-level functions/classes with two blank lines; methods with one.
- Avoid wildcard imports (`from pygame import *`). Prefer:
  ```python
  import pygame
  from pygame.locals import *  # only if you really need the constants
  ```
  or explicit imports.

### 2. Project Structure
Organize larger projects into modules instead of one giant file:

```
my_game/
├── main.py              # Entry point + game loop
├── settings.py          # Constants, config, colors, screen size
├── assets/              # Images, sounds, fonts
├── sprites/             # Player, Enemy, Bullet classes
├── scenes/ or states/   # Menu, Playing, GameOver, etc.
├── utils/               # Helpers (math, collision, loaders)
└── resources.py         # Central asset loading
```

- Keep constants in `settings.py` or at the top of modules (no magic numbers).
- Separate **game logic** from **rendering**.
- Use classes for game objects (Player, Enemy, etc.) and a central `Game` or state manager.

### 3. Standard Game Loop Structure
The classic pattern is reliable and clear:

```python
import pygame
import sys

pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()
running = True

while running:
    # 1. Event handling
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        # handle keys, mouse, etc.

    # 2. Update (game logic)
    # player.update()
    # enemies.update()
    # collisions, etc.

    # 3. Draw
    screen.fill(BACKGROUND_COLOR)
    # all_sprites.draw(screen)
    # UI, etc.

    pygame.display.flip()  # or .update()
    clock.tick(FPS)        # usually 60
```

**Key points:**
- Always process the event queue every frame (`pygame.event.get()` or `pygame.event.clear()` + selective handling).
- Separate update from draw.
- Call `clock.tick(FPS)` at the end to control frame rate and get consistent timing.
- Prefer `pygame.display.flip()` for full-screen updates.

### 4. Timing & Frame Independence
- Use `clock.tick(FPS)` for simple games.
- For physics or smooth movement independent of FPS, use **delta time**:

```python
dt = clock.tick(FPS) / 1000.0  # seconds
player.x += player.speed * dt
```

- Avoid relying on fixed frame counts for timing when possible.

### 5. Resource Management
- Load images once and convert them:
  ```python
  image = pygame.image.load("player.png").convert_alpha()  # or .convert()
  ```
- Use a central loader or `resources` module so assets are loaded only once.
- Handle missing files gracefully with `try/except pygame.error`.
- Quit cleanly:
  ```python
  pygame.quit()
  sys.exit()
  ```

### 6. Sprites & Groups
Prefer `pygame.sprite.Sprite` and `Group` / `GroupSingle` / `Group` with layers for most objects:

```python
class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = ...
        self.rect = self.image.get_rect()

    def update(self, dt):
        # movement, animation, etc.
```

- Use groups for batch drawing and collision detection (`pygame.sprite.groupcollide`, `spritecollide`).
- Keep `update()` free of drawing calls.

### 7. State / Scene Management
For menus, gameplay, pause, game-over, etc.:

- Use a simple state machine or function-based states.
- Each state can have its own loop or a shared loop that calls `state.update()` / `state.draw()`.
- Avoid stuffing everything into one massive `while` loop.

### 8. Performance Tips
- Convert surfaces (`convert()` / `convert_alpha()`).
- Draw only what changed when possible (dirty rectangles), but full redraw is fine for most 2D games.
- Avoid creating new surfaces every frame.
- Use `pygame.Surface` caching for static elements.
- Profile with `cProfile` or simple timing if needed.
- Prefer pygame-ce for active development (better performance and maintenance).

### 9. Error Handling & Robustness
- Wrap resource loading in `try/except`.
- Check for audio device availability.
- Handle window resize if you support it (`VIDEORESIZE`).
- Never let an unhandled exception leave the game in a broken state — catch at the top level if needed and quit cleanly.

### 10. Other Good Habits
- Use type hints where helpful (`def update(self, dt: float) -> None:`).
- Document classes and non-obvious methods with docstrings.
- Keep magic numbers out of the main loop — put them in settings.
- Version control (Git) from day one.
- Test on the target platforms early (Windows, macOS, Linux).
- For distribution: consider `pyinstaller`, `cx_Freeze`, or pygame’s own packaging advice.

### Minimal Clean Template

```python
import pygame
import sys
from settings import *

class Game:
    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
        pygame.display.set_caption(TITLE)
        self.clock = pygame.time.Clock()
        self.running = True
        # load assets, create sprites, etc.

    def run(self):
        while self.running:
            self.handle_events()
            self.update()
            self.draw()
            self.clock.tick(FPS)
        self.quit()

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.running = False

    def update(self):
        pass  # game logic

    def draw(self):
        self.screen.fill(BG_COLOR)
        # draw everything
        pygame.display.flip()

    def quit(self):
        pygame.quit()
        sys.exit()

if __name__ == "__main__":
    Game().run()
```

These guidelines keep code readable, scalable, and free of common Pygame pitfalls. Start simple, then introduce classes, states, and delta time as the project grows.

**Delta Time Physics in Pygame**

Delta time (`dt`) makes movement, physics, and animations independent of frame rate. Without it, a game runs faster on high-FPS machines and slower on low-FPS ones. With `dt`, everything moves at the same *real-world* speed.

### Core Idea

```python
dt = clock.tick(FPS) / 1000.0   # seconds since last frame
```

- `clock.tick(FPS)` returns the time in **milliseconds** since the previous call.
- Divide by `1000.0` to get **seconds**.
- Multiply velocities, accelerations, and timers by `dt`.

### Basic Movement (Position Integration)

```python
# Velocity in pixels per second
player_vel_x = 200
player_vel_y = 0

# In the update loop
player.x += player_vel_x * dt
player.y += player_vel_y * dt
```

This is **Euler integration** — simple and usually good enough for 2D games.

### Velocity + Acceleration (Proper Physics)

```python
class Player:
    def __init__(self):
        self.pos = pygame.Vector2(100, 100)
        self.vel = pygame.Vector2(0, 0)
        self.acc = pygame.Vector2(0, 0)
        self.speed = 300          # max horizontal speed (px/s)
        self.accel = 2000         # acceleration (px/s²)
        self.friction = 0.85      # multiplicative friction
        self.gravity = 1500       # px/s²
        self.on_ground = False

    def update(self, dt, keys):
        # Horizontal input
        self.acc.x = 0
        if keys[pygame.K_LEFT]:
            self.acc.x = -self.accel
        if keys[pygame.K_RIGHT]:
            self.acc.x = self.accel

        # Apply gravity
        self.acc.y = self.gravity

        # Integrate acceleration → velocity
        self.vel += self.acc * dt

        # Friction (only when not accelerating)
        if self.acc.x == 0:
            self.vel.x *= self.friction

        # Clamp speed
        self.vel.x = max(-self.speed, min(self.speed, self.vel.x))

        # Integrate velocity → position
        self.pos += self.vel * dt

        # Simple ground collision
        if self.pos.y > GROUND_Y:
            self.pos.y = GROUND_Y
            self.vel.y = 0
            self.on_ground = True
        else:
            self.on_ground = False
```

### Jumping with Delta Time

```python
JUMP_FORCE = -600  # pixels per second (upward)

if keys[pygame.K_SPACE] and self.on_ground:
    self.vel.y = JUMP_FORCE
    self.on_ground = False
```

Because velocity is in pixels/second, the jump height stays consistent regardless of FPS.

### Better Integration Options

| Method              | Accuracy | Cost   | When to use                  |
|---------------------|----------|--------|------------------------------|
| Euler               | Low      | Very low | Most 2D platformers         |
| Semi-implicit Euler | Better   | Low    | Recommended default         |
| Verlet              | High     | Medium | Ropes, soft bodies          |
| RK4                 | Very high| High   | Rarely needed in 2D games   |

**Semi-implicit Euler** (very common and stable):

```python
self.vel += self.acc * dt
self.pos += self.vel * dt
```

(Note: update velocity *before* position.)

### Fixed Timestep (Advanced & Recommended for Serious Physics)

Variable `dt` can cause tunneling or instability at very low FPS. A fixed physics step solves this:

```python
PHYSICS_DT = 1.0 / 60.0          # fixed 60 Hz physics
MAX_FRAME_TIME = 0.25            # prevent spiral of death

accumulator = 0.0

while running:
    frame_time = clock.tick(FPS) / 1000.0
    frame_time = min(frame_time, MAX_FRAME_TIME)
    accumulator += frame_time

    # Handle events...

    while accumulator >= PHYSICS_DT:
        # Run physics at fixed rate
        player.physics_update(PHYSICS_DT)
        # enemies, collisions, etc.
        accumulator -= PHYSICS_DT

    # Interpolation factor for smooth rendering
    alpha = accumulator / PHYSICS_DT

    # Render with interpolation (optional but nice)
    player.draw(screen, alpha)
    pygame.display.flip()
```

**Interpolation** (smooth visuals between physics steps):

```python
# Store previous position
self.prev_pos = self.pos.copy()

# After physics:
render_pos = self.prev_pos.lerp(self.pos, alpha)
```

### Common Pitfalls

1. **Forgetting to divide by 1000** → everything moves 1000× too fast.
2. **Using `dt` on already-frame-dependent values**.
3. **Very large `dt`** (e.g. after alt-tab) → objects teleport. Cap it:
   ```python
   dt = min(dt, 0.05)  # max 50 ms
   ```
4. **Mixing frame-based and time-based logic**.
5. **Not converting surfaces** or creating objects every frame (unrelated but hurts performance).

### Complete Minimal Example

```python
import pygame
import sys

pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()
FPS = 60

player_pos = pygame.Vector2(100, 300)
player_vel = pygame.Vector2(0, 0)
GRAVITY = 1500
JUMP_SPEED = -500
MOVE_SPEED = 250

running = True
while running:
    dt = clock.tick(FPS) / 1000.0
    dt = min(dt, 0.05)  # safety cap

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    player_vel.x = 0
    if keys[pygame.K_LEFT]:
        player_vel.x = -MOVE_SPEED
    if keys[pygame.K_RIGHT]:
        player_vel.x = MOVE_SPEED
    if keys[pygame.K_SPACE] and player_pos.y >= HEIGHT - 50:
        player_vel.y = JUMP_SPEED

    # Physics
    player_vel.y += GRAVITY * dt
    player_pos += player_vel * dt

    # Ground
    if player_pos.y > HEIGHT - 50:
        player_pos.y = HEIGHT - 50
        player_vel.y = 0

    # Draw
    screen.fill((30, 30, 40))
    pygame.draw.rect(screen, (80, 180, 255), (*player_pos, 40, 50))
    pygame.display.flip()

pygame.quit()
sys.exit()
```

### When You Need More

- **Multiple forces** → accumulate acceleration, then integrate once.
- **Collisions** → resolve after position update (or use continuous collision detection for fast objects).
- **Variable mass / different objects** → store mass and use `F = ma` (`acc = force / mass`).

Would you like a version with:
- Fixed timestep + interpolation,
- Platformer-style coyote time / jump buffering,
- Simple rigid-body collisions, or
- Verlet integration for ropes/particles?

**Fixed Timestep Physics Loop in Pygame**

A fixed timestep decouples physics from rendering. Physics runs at a constant rate (e.g. 60 Hz) while rendering can run at any frame rate. This prevents tunneling, keeps collisions consistent, and makes the game deterministic.

### Core Pattern

```python
PHYSICS_DT = 1.0 / 60.0          # fixed physics step (60 Hz)
MAX_FRAME_TIME = 0.25            # prevent "spiral of death"

accumulator = 0.0

while running:
    frame_time = clock.tick(FPS) / 1000.0
    frame_time = min(frame_time, MAX_FRAME_TIME)
    accumulator += frame_time

    # --- Events ---
    handle_events()

    # --- Fixed physics steps ---
    while accumulator >= PHYSICS_DT:
        physics_update(PHYSICS_DT)   # pure logic, no drawing
        accumulator -= PHYSICS_DT

    # --- Interpolation factor (0 → 1) ---
    alpha = accumulator / PHYSICS_DT

    # --- Render with interpolation ---
    render(alpha)
    pygame.display.flip()
```

### Complete Working Example

```python
import pygame
import sys

# -------------------------------------------------
# Settings
# -------------------------------------------------
WIDTH, HEIGHT = 900, 600
FPS = 120                    # rendering FPS (can be higher than physics)
PHYSICS_FPS = 60
PHYSICS_DT = 1.0 / PHYSICS_FPS
MAX_FRAME_TIME = 0.25

GRAVITY = 1800               # px/s²
MOVE_SPEED = 280             # px/s
JUMP_FORCE = -650            # px/s
GROUND_Y = HEIGHT - 80

# -------------------------------------------------
# Player class with interpolation support
# -------------------------------------------------
class Player:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()   # for interpolation
        self.vel = pygame.Vector2(0, 0)
        self.size = pygame.Vector2(40, 50)
        self.on_ground = False

    def physics_update(self, dt, keys):
        """Pure physics – called at fixed rate."""
        # Save previous position for rendering interpolation
        self.prev_pos = self.pos.copy()

        # Horizontal movement
        self.vel.x = 0
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            self.vel.x = -MOVE_SPEED
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            self.vel.x = MOVE_SPEED

        # Jump
        if (keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]) and self.on_ground:
            self.vel.y = JUMP_FORCE
            self.on_ground = False

        # Gravity
        self.vel.y += GRAVITY * dt

        # Integrate
        self.pos += self.vel * dt

        # Ground collision
        if self.pos.y + self.size.y > GROUND_Y:
            self.pos.y = GROUND_Y - self.size.y
            self.vel.y = 0
            self.on_ground = True
        else:
            self.on_ground = False

        # Keep inside screen horizontally
        self.pos.x = max(0, min(self.pos.x, WIDTH - self.size.x))

    def get_render_pos(self, alpha: float) -> pygame.Vector2:
        """Linear interpolation between previous and current position."""
        return self.prev_pos.lerp(self.pos, alpha)

    def draw(self, surface, alpha: float):
        render_pos = self.get_render_pos(alpha)
        rect = pygame.Rect(render_pos.x, render_pos.y, self.size.x, self.size.y)
        color = (80, 180, 255) if self.on_ground else (255, 120, 80)
        pygame.draw.rect(surface, color, rect)
        # simple eyes
        pygame.draw.circle(surface, (20, 20, 30), (int(render_pos.x + 12), int(render_pos.y + 15)), 4)
        pygame.draw.circle(surface, (20, 20, 30), (int(render_pos.x + 28), int(render_pos.y + 15)), 4)

# -------------------------------------------------
# Main
# -------------------------------------------------
def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Fixed Timestep Physics")
    clock = pygame.time.Clock()
    font = pygame.font.SysFont("consolas", 18)

    player = Player(100, 200)
    accumulator = 0.0
    running = True

    while running:
        # Variable frame time
        frame_time = clock.tick(FPS) / 1000.0
        frame_time = min(frame_time, MAX_FRAME_TIME)
        accumulator += frame_time

        # Events
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False

        keys = pygame.key.get_pressed()

        # Fixed physics steps
        physics_steps = 0
        while accumulator >= PHYSICS_DT:
            player.physics_update(PHYSICS_DT, keys)
            accumulator -= PHYSICS_DT
            physics_steps += 1

        # Interpolation alpha (remaining time toward next physics step)
        alpha = accumulator / PHYSICS_DT

        # Render
        screen.fill((28, 30, 40))

        # Ground
        pygame.draw.rect(screen, (60, 70, 50), (0, GROUND_Y, WIDTH, HEIGHT - GROUND_Y))

        player.draw(screen, alpha)

        # Debug info
        fps_text = font.render(f"Render FPS: {clock.get_fps():5.1f}", True, (200, 200, 200))
        step_text = font.render(f"Physics steps this frame: {physics_steps}", True, (200, 200, 200))
        alpha_text = font.render(f"Alpha: {alpha:.3f}", True, (200, 200, 200))
        screen.blit(fps_text, (10, 10))
        screen.blit(step_text, (10, 32))
        screen.blit(alpha_text, (10, 54))

        pygame.display.flip()

    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()
```

### Key Points Explained

1. **Accumulator**  
   Collects real time. When it reaches `PHYSICS_DT`, one physics step is executed and the accumulator is reduced.

2. **Spiral-of-death protection**  
   `MAX_FRAME_TIME` caps how much time can be accumulated in one frame (important after alt-tabbing or freezes).

3. **Interpolation (`alpha`)**  
   - `alpha = 0.0` → use previous position  
   - `alpha = 1.0` → use current position  
   - In between → smooth linear blend  
   This removes the visual stutter that would otherwise appear when render FPS ≠ physics FPS.

4. **Input sampling**  
   In this example keys are read every render frame and passed into the physics step. For more precision you can also buffer inputs, but this is fine for most 2D games.

5. **Multiple physics steps**  
   If a frame takes longer than `PHYSICS_DT`, several physics updates run in a row. This keeps simulation stable.

### Optional Improvements

- **Coyote time / jump buffer** – store a small timer so jumps feel more forgiving.
- **Separate input state** – snapshot keys at the start of the frame or use an event buffer.
- **Multiple objects** – put all physics objects in a list and update them inside the fixed loop.
- **Determinism** – avoid `pygame.Vector2` randomness and use the same `PHYSICS_DT` everywhere if you need lockstep multiplayer.

![[Would you like me to extend this with:
- Coyote time + jump buffering,
- Multiple moving platforms / enemies,
- Simple AABB collision resolution between dynamic objects, or
- A version that also interpolates rotation / animation frames?**Extended Fixed-Timestep Physics Demo**

This version adds:

- **Coyote time** + **jump buffering**
- **Moving platforms**
- **Simple enemies**
- **AABB collision resolution** (player vs platforms + enemies)
- Position interpolation (still present)

```python
import pygame
import sys
from enum import Enum, auto

# -------------------------------------------------
# Settings
# -------------------------------------------------
WIDTH, HEIGHT = 1000, 600
FPS = 120
PHYSICS_FPS = 60
PHYSICS_DT = 1.0 / PHYSICS_FPS
MAX_FRAME_TIME = 0.25

GRAVITY = 2000
MOVE_SPEED = 300
JUMP_FORCE = -720
COYOTE_TIME = 0.10          # seconds after leaving ground where jump is still allowed
JUMP_BUFFER_TIME = 0.12     # seconds before landing where jump input is remembered

# -------------------------------------------------
# Helpers
# -------------------------------------------------
def aabb_overlap(a_pos, a_size, b_pos, b_size):
    return (a_pos.x < b_pos.x + b_size.x and
            a_pos.x + a_size.x > b_pos.x and
            a_pos.y < b_pos.y + b_size.y and
            a_pos.y + a_size.y > b_pos.y)

def resolve_aabb(pos, size, vel, other_pos, other_size):
    """Very simple AABB resolution. Returns (new_pos, new_vel, on_ground)."""
    if not aabb_overlap(pos, size, other_pos, other_size):
        return pos, vel, False

    # Calculate overlap on each axis
    dx1 = (other_pos.x + other_size.x) - pos.x
    dx2 = (pos.x + size.x) - other_pos.x
    dy1 = (other_pos.y + other_size.y) - pos.y
    dy2 = (pos.y + size.y) - other_pos.y

    min_dx = min(dx1, dx2)
    min_dy = min(dy1, dy2)

    on_ground = False

    if min_dx < min_dy:
        # Resolve on X
        if dx1 < dx2:
            pos.x = other_pos.x + other_size.x
        else:
            pos.x = other_pos.x - size.x
        vel.x = 0
    else:
        # Resolve on Y
        if dy1 < dy2:
            pos.y = other_pos.y + other_size.y
            if vel.y < 0:
                vel.y = 0
        else:
            pos.y = other_pos.y - size.y
            vel.y = 0
            on_ground = True

    return pos, vel, on_ground

# -------------------------------------------------
# Entities
# -------------------------------------------------
class MovingPlatform:
    def __init__(self, x, y, w, h, move_range=120, speed=80):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.size = pygame.Vector2(w, h)
        self.start_x = x
        self.move_range = move_range
        self.speed = speed
        self.direction = 1

    def physics_update(self, dt):
        self.prev_pos = self.pos.copy()
        self.pos.x += self.speed * self.direction * dt
        if self.pos.x > self.start_x + self.move_range:
            self.pos.x = self.start_x + self.move_range
            self.direction = -1
        elif self.pos.x < self.start_x:
            self.pos.x = self.start_x
            self.direction = 1

    def get_render_pos(self, alpha):
        return self.prev_pos.lerp(self.pos, alpha)

    def draw(self, surface, alpha):
        p = self.get_render_pos(alpha)
        pygame.draw.rect(surface, (100, 160, 90), (*p, *self.size))
        pygame.draw.rect(surface, (70, 120, 60), (*p, *self.size), 2)

class Enemy:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.size = pygame.Vector2(36, 36)
        self.vel = pygame.Vector2(-90, 0)
        self.alive = True

    def physics_update(self, dt, platforms):
        if not self.alive:
            return
        self.prev_pos = self.pos.copy()
        self.vel.y += GRAVITY * dt
        self.pos += self.vel * dt

        # Simple ground / platform collision
        for plat in platforms:
            self.pos, self.vel, on_ground = resolve_aabb(
                self.pos, self.size, self.vel, plat.pos, plat.size
            )
            if on_ground:
                # Turn around at edges (very basic)
                if self.pos.x <= plat.pos.x + 5 or self.pos.x + self.size.x >= plat.pos.x + plat.size.x - 5:
                    self.vel.x *= -1

        # World bounds
        if self.pos.x < 0 or self.pos.x > WIDTH - self.size.x:
            self.vel.x *= -1

    def get_render_pos(self, alpha):
        return self.prev_pos.lerp(self.pos, alpha)

    def draw(self, surface, alpha):
        if not self.alive:
            return
        p = self.get_render_pos(alpha)
        pygame.draw.rect(surface, (220, 70, 70), (*p, *self.size))
        # eyes
        pygame.draw.circle(surface, (20, 20, 20), (int(p.x + 10), int(p.y + 12)), 4)
        pygame.draw.circle(surface, (20, 20, 20), (int(p.x + 26), int(p.y + 12)), 4)

class Player:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.vel = pygame.Vector2(0, 0)
        self.size = pygame.Vector2(40, 50)

        self.on_ground = False
        self.coyote_timer = 0.0
        self.jump_buffer_timer = 0.0
        self.facing = 1

    def physics_update(self, dt, keys, platforms, enemies):
        self.prev_pos = self.pos.copy()

        # --- Timers ---
        if self.on_ground:
            self.coyote_timer = COYOTE_TIME
        else:
            self.coyote_timer = max(0.0, self.coyote_timer - dt)

        if keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]:
            self.jump_buffer_timer = JUMP_BUFFER_TIME
        else:
            self.jump_buffer_timer = max(0.0, self.jump_buffer_timer - dt)

        # --- Horizontal ---
        self.vel.x = 0
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            self.vel.x = -MOVE_SPEED
            self.facing = -1
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            self.vel.x = MOVE_SPEED
            self.facing = 1

        # --- Jump (coyote + buffer) ---
        if self.jump_buffer_timer > 0 and self.coyote_timer > 0:
            self.vel.y = JUMP_FORCE
            self.on_ground = False
            self.coyote_timer = 0
            self.jump_buffer_timer = 0

        # --- Gravity ---
        self.vel.y += GRAVITY * dt

        # --- Integrate ---
        self.pos += self.vel * dt

        # --- Collisions with platforms ---
        self.on_ground = False
        for plat in platforms:
            self.pos, self.vel, hit_ground = resolve_aabb(
                self.pos, self.size, self.vel, plat.pos, plat.size
            )
            if hit_ground:
                self.on_ground = True
                # Carry the player with the moving platform
                plat_delta = plat.pos - plat.prev_pos
                self.pos += plat_delta

        # --- Enemy collision (stomp or hurt) ---
        for enemy in enemies:
            if not enemy.alive:
                continue
            if aabb_overlap(self.pos, self.size, enemy.pos, enemy.size):
                # Stomp from above
                if self.vel.y > 0 and self.pos.y + self.size.y - enemy.pos.y < 20:
                    enemy.alive = False
                    self.vel.y = JUMP_FORCE * 0.6   # bounce
                else:
                    # simple knockback / reset
                    self.pos = pygame.Vector2(100, 200)
                    self.vel = pygame.Vector2(0, 0)

        # World bounds
        self.pos.x = max(0, min(self.pos.x, WIDTH - self.size.x))
        if self.pos.y > HEIGHT + 100:
            self.pos = pygame.Vector2(100, 200)
            self.vel = pygame.Vector2(0, 0)

    def get_render_pos(self, alpha):
        return self.prev_pos.lerp(self.pos, alpha)

    def draw(self, surface, alpha):
        p = self.get_render_pos(alpha)
        color = (80, 180, 255) if self.on_ground else (255, 140, 80)
        pygame.draw.rect(surface, color, (*p, *self.size))
        # eyes
        eye_offset = 10 if self.facing > 0 else 22
        pygame.draw.circle(surface, (20, 20, 30), (int(p.x + eye_offset), int(p.y + 15)), 4)
        pygame.draw.circle(surface, (20, 20, 30), (int(p.x + eye_offset + 12), int(p.y + 15)), 4)

# -------------------------------------------------
# Main
# -------------------------------------------------
def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Fixed Timestep + Coyote + Platforms + Enemies")
    clock = pygame.time.Clock()
    font = pygame.font.SysFont("consolas", 18)

    # Level
    platforms = [
        MovingPlatform(0, HEIGHT - 40, WIDTH, 40, move_range=0, speed=0),          # ground
        MovingPlatform(200, 450, 180, 24, move_range=150, speed=70),
        MovingPlatform(500, 350, 160, 24, move_range=120, speed=90),
        MovingPlatform(750, 280, 140, 24, move_range=0, speed=0),
        MovingPlatform(100, 250, 120, 24, move_range=80, speed=60),
    ]

    enemies = [
        Enemy(250, 400),
        Enemy(550, 300),
        Enemy(800, 230),
    ]

    player = Player(100, 300)
    accumulator = 0.0
    running = True

    while running:
        frame_time = clock.tick(FPS) / 1000.0
        frame_time = min(frame_time, MAX_FRAME_TIME)
        accumulator += frame_time

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False

        keys = pygame.key.get_pressed()

        # Fixed physics
        while accumulator >= PHYSICS_DT:
            for plat in platforms:
                plat.physics_update(PHYSICS_DT)
            for enemy in enemies:
                enemy.physics_update(PHYSICS_DT, platforms)
            player.physics_update(PHYSICS_DT, keys, platforms, enemies)
            accumulator -= PHYSICS_DT

        alpha = accumulator / PHYSICS_DT

        # Render
        screen.fill((25, 28, 38))

        for plat in platforms:
            plat.draw(screen, alpha)
        for enemy in enemies:
            enemy.draw(screen, alpha)
        player.draw(screen, alpha)

        # Debug
        info = [
            f"Render FPS: {clock.get_fps():5.1f}",
            f"Coyote: {player.coyote_timer:.2f}  Buffer: {player.jump_buffer_timer:.2f}",
            f"On ground: {player.on_ground}",
            "Arrows/WASD + Space | Esc to quit",
        ]
        for i, text in enumerate(info):
            surf = font.render(text, True, (200, 200, 210))
            screen.blit(surf, (10, 10 + i * 22))

        pygame.display.flip()

    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()
```

### What was added

| Feature              | How it works |
|----------------------|--------------|
| **Coyote time**      | After leaving a platform you still have `COYOTE_TIME` seconds to jump |
| **Jump buffering**   | Pressing jump slightly before landing is remembered for `JUMP_BUFFER_TIME` |
| **Moving platforms** | Platforms update in the fixed loop; player inherits their delta when standing on them |
| **Enemies**          | Basic patrol + gravity; can be stomped |
| **AABB resolution**  | Simple overlap test + minimum-penetration resolution on the shallowest axis |
| **Interpolation**    | All moving objects store `prev_pos` and lerp for smooth rendering |

### Controls
- **A / D** or **← / →** – move
- **Space / W / ↑** – jump (works with coyote + buffer)
- **Esc** – quit

You can now tune `COYOTE_TIME`, `JUMP_BUFFER_TIME`, platform speeds, and enemy behavior easily.  

Want me to add any of these next?
- Better collision (one-way platforms, slopes)
- yes ✅ 
- Animation frames + rotation interpolation
- yes ✅
- Camera follow with smoothing
- yes ✅ 
- Particle effects on stomp / landing]]
- yes ✅ 


**Full Extended Demo**  
Fixed timestep + Coyote/Jump Buffer + Moving Platforms + Enemies + **One-way platforms** + **Basic slopes** + **Animation** + **Rotation interpolation** + **Smooth camera** + **Particles**

```python
import pygame
import sys
import math
import random
from dataclasses import dataclass

# -------------------------------------------------
# Settings
# -------------------------------------------------
WIDTH, HEIGHT = 1100, 650
FPS = 120
PHYSICS_FPS = 60
PHYSICS_DT = 1.0 / PHYSICS_FPS
MAX_FRAME_TIME = 0.25

GRAVITY = 2100
MOVE_SPEED = 320
JUMP_FORCE = -750
COYOTE_TIME = 0.10
JUMP_BUFFER_TIME = 0.12

# -------------------------------------------------
# Utility
# -------------------------------------------------
def lerp(a, b, t):
    return a + (b - a) * t

def clamp(v, lo, hi):
    return max(lo, min(hi, v))

# -------------------------------------------------
# Particles
# -------------------------------------------------
@dataclass
class Particle:
    pos: pygame.Vector2
    vel: pygame.Vector2
    life: float
    max_life: float
    color: tuple
    size: float
    gravity: float = 800

    def update(self, dt):
        self.vel.y += self.gravity * dt
        self.pos += self.vel * dt
        self.life -= dt

    def draw(self, surface, camera):
        if self.life <= 0:
            return
        alpha = self.life / self.max_life
        s = max(1, int(self.size * alpha))
        p = self.pos - camera
        # simple fading circle
        color = (*self.color, int(255 * alpha))
        surf = pygame.Surface((s*2, s*2), pygame.SRCALPHA)
        pygame.draw.circle(surf, color, (s, s), s)
        surface.blit(surf, (p.x - s, p.y - s))

class ParticleSystem:
    def __init__(self):
        self.particles = []

    def emit(self, pos, count, color, speed=180, life=0.4, size=4):
        for _ in range(count):
            angle = random.uniform(0, math.tau)
            spd = random.uniform(speed * 0.4, speed)
            vel = pygame.Vector2(math.cos(angle), math.sin(angle)) * spd
            self.particles.append(Particle(
                pos=pos.copy(),
                vel=vel,
                life=life,
                max_life=life,
                color=color,
                size=size
            ))

    def update(self, dt):
        for p in self.particles:
            p.update(dt)
        self.particles = [p for p in self.particles if p.life > 0]

    def draw(self, surface, camera):
        for p in self.particles:
            p.draw(surface, camera)

# -------------------------------------------------
# Camera
# -------------------------------------------------
class Camera:
    def __init__(self, width, height):
        self.pos = pygame.Vector2(0, 0)
        self.target = pygame.Vector2(0, 0)
        self.smooth = 6.0          # higher = snappier
        self.width = width
        self.height = height

    def follow(self, target_pos, dt):
        # Center on target
        desired = target_pos - pygame.Vector2(self.width / 2, self.height / 2 - 40)
        # Smooth damp
        self.pos += (desired - self.pos) * min(1.0, self.smooth * dt)

    def apply(self, pos):
        return pos - self.pos

# -------------------------------------------------
# Platforms (solid, one-way, slope)
# -------------------------------------------------
class Platform:
    def __init__(self, x, y, w, h, one_way=False, slope=0.0, move_range=0, speed=0):
        """
        slope: angle in degrees (positive = rises to the right)
        """
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.size = pygame.Vector2(w, h)
        self.one_way = one_way
        self.slope = math.radians(slope)
        self.start_x = x
        self.move_range = move_range
        self.speed = speed
        self.direction = 1

    def physics_update(self, dt):
        self.prev_pos = self.pos.copy()
        if self.move_range > 0:
            self.pos.x += self.speed * self.direction * dt
            if self.pos.x > self.start_x + self.move_range:
                self.pos.x = self.start_x + self.move_range
                self.direction = -1
            elif self.pos.x < self.start_x:
                self.pos.x = self.start_x
                self.direction = 1

    def get_height_at(self, world_x):
        """For slopes: return the y of the surface at a given x."""
        if abs(self.slope) < 0.001:
            return self.pos.y
        # local x relative to platform left
        local_x = world_x - self.pos.x
        return self.pos.y - math.tan(self.slope) * local_x

    def draw(self, surface, camera, alpha):
        p = self.prev_pos.lerp(self.pos, alpha)
        p = camera.apply(p)
        color = (90, 150, 85) if not self.one_way else (120, 100, 60)
        if abs(self.slope) > 0.01:
            # draw as a polygon for slope
            h = self.size.y
            points = [
                camera.apply(self.pos + pygame.Vector2(0, 0)),
                camera.apply(self.pos + pygame.Vector2(self.size.x, -math.tan(self.slope)*self.size.x)),
                camera.apply(self.pos + pygame.Vector2(self.size.x, -math.tan(self.slope)*self.size.x + h)),
                camera.apply(self.pos + pygame.Vector2(0, h)),
            ]
            pygame.draw.polygon(surface, color, points)
            pygame.draw.polygon(surface, (60, 100, 55), points, 2)
        else:
            pygame.draw.rect(surface, color, (*p, *self.size))
            pygame.draw.rect(surface, (60, 100, 55), (*p, *self.size), 2)

# -------------------------------------------------
# Animation helper
# -------------------------------------------------
class Anim:
    def __init__(self, frames, frame_duration=0.1, loop=True):
        self.frames = frames          # list of surfaces
        self.frame_duration = frame_duration
        self.loop = loop
        self.timer = 0.0
        self.index = 0

    def update(self, dt):
        self.timer += dt
        if self.timer >= self.frame_duration:
            self.timer -= self.frame_duration
            self.index += 1
            if self.index >= len(self.frames):
                self.index = 0 if self.loop else len(self.frames) - 1

    @property
    def current(self):
        return self.frames[self.index]

def make_player_frames():
    """Create simple colored rectangle frames for idle / run / jump."""
    def frame(color, offset_y=0, lean=0):
        surf = pygame.Surface((40, 50), pygame.SRCALPHA)
        pygame.draw.rect(surf, color, (0, offset_y, 40, 50 - offset_y))
        # eyes
        pygame.draw.circle(surf, (20, 20, 30), (12 + lean, 16), 4)
        pygame.draw.circle(surf, (20, 20, 30), (28 + lean, 16), 4)
        return surf

    idle = [frame((80, 180, 255)), frame((80, 180, 255), offset_y=1)]
    run = [
        frame((80, 180, 255), lean=-2),
        frame((70, 170, 245), offset_y=2, lean=0),
        frame((80, 180, 255), lean=2),
        frame((70, 170, 245), offset_y=2, lean=0),
    ]
    jump = [frame((255, 140, 80))]
    return {
        "idle": Anim(idle, 0.25),
        "run": Anim(run, 0.09),
        "jump": Anim(jump, 0.1, loop=False)
    }

# -------------------------------------------------
# Player
# -------------------------------------------------
class Player:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.vel = pygame.Vector2(0, 0)
        self.size = pygame.Vector2(40, 50)

        self.on_ground = False
        self.coyote_timer = 0.0
        self.jump_buffer_timer = 0.0
        self.facing = 1
        self.was_on_ground = False

        # Animation & rotation
        self.anims = make_player_frames()
        self.current_anim = "idle"
        self.rotation = 0.0
        self.prev_rotation = 0.0
        self.target_rotation = 0.0

    def physics_update(self, dt, keys, platforms, enemies, particles):
        self.prev_pos = self.pos.copy()
        self.prev_rotation = self.rotation
        self.was_on_ground = self.on_ground

        # Timers
        if self.on_ground:
            self.coyote_timer = COYOTE_TIME
        else:
            self.coyote_timer = max(0.0, self.coyote_timer - dt)

        jump_pressed = keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]
        if jump_pressed:
            self.jump_buffer_timer = JUMP_BUFFER_TIME
        else:
            self.jump_buffer_timer = max(0.0, self.jump_buffer_timer - dt)

        # Horizontal
        self.vel.x = 0
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            self.vel.x = -MOVE_SPEED
            self.facing = -1
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            self.vel.x = MOVE_SPEED
            self.facing = 1

        # Jump
        if self.jump_buffer_timer > 0 and self.coyote_timer > 0:
            self.vel.y = JUMP_FORCE
            self.on_ground = False
            self.coyote_timer = 0
            self.jump_buffer_timer = 0
            particles.emit(self.pos + pygame.Vector2(20, 50), 8, (180, 180, 200), speed=120, life=0.3)

        # Gravity
        self.vel.y += GRAVITY * dt
        self.pos += self.vel * dt

        # Collisions
        self.on_ground = False
        for plat in platforms:
            self._collide_platform(plat, dt)

        # Enemy interaction
        for enemy in enemies:
            if not enemy.alive:
                continue
            if self._aabb(self.pos, self.size, enemy.pos, enemy.size):
                if self.vel.y > 0 and (self.pos.y + self.size.y - enemy.pos.y) < 22:
                    enemy.alive = False
                    self.vel.y = JUMP_FORCE * 0.55
                    particles.emit(enemy.pos + pygame.Vector2(18, 18), 14, (255, 80, 80), speed=220, life=0.45)
                else:
                    # hurt – reset
                    self.pos = pygame.Vector2(120, 200)
                    self.vel *= 0

        # Landing particles
        if self.on_ground and not self.was_on_ground and self.vel.y >= 0:
            particles.emit(self.pos + pygame.Vector2(20, 50), 10, (160, 150, 130), speed=100, life=0.35)

        # Animation state
        if not self.on_ground:
            self.current_anim = "jump"
        elif abs(self.vel.x) > 10:
            self.current_anim = "run"
        else:
            self.current_anim = "idle"

        self.anims[self.current_anim].update(dt)

        # Rotation (lean while running / slight tilt in air)
        if self.on_ground:
            self.target_rotation = -self.vel.x * 0.03
        else:
            self.target_rotation = self.vel.x * 0.02
        self.rotation = lerp(self.rotation, self.target_rotation, 10 * dt)

        # Bounds
        self.pos.x = clamp(self.pos.x, 0, 3000)
        if self.pos.y > 2000:
            self.pos = pygame.Vector2(120, 200)
            self.vel *= 0

    def _aabb(self, p1, s1, p2, s2):
        return (p1.x < p2.x + s2.x and p1.x + s1.x > p2.x and
                p1.y < p2.y + s2.y and p1.y + s1.y > p2.y)

    def _collide_platform(self, plat, dt):
        # One-way: only collide when falling and feet are near top
        if plat.one_way:
            feet = self.pos.y + self.size.y
            top = plat.get_height_at(self.pos.x + self.size.x / 2)
            if self.vel.y < 0 or feet < top - 8 or feet > top + 20:
                return

        # Slope handling (simplified)
        if abs(plat.slope) > 0.01:
            center_x = self.pos.x + self.size.x / 2
            if plat.pos.x <= center_x <= plat.pos.x + plat.size.x:
                surface_y = plat.get_height_at(center_x)
                if self.pos.y + self.size.y > surface_y and self.vel.y >= 0:
                    self.pos.y = surface_y - self.size.y
                    self.vel.y = 0
                    self.on_ground = True
                    # carry with platform
                    self.pos += (plat.pos - plat.prev_pos)
            return

        # Regular AABB
        if not self._aabb(self.pos, self.size, plat.pos, plat.size):
            return

        # Minimum penetration resolution
        dx1 = (plat.pos.x + plat.size.x) - self.pos.x
        dx2 = (self.pos.x + self.size.x) - plat.pos.x
        dy1 = (plat.pos.y + plat.size.y) - self.pos.y
        dy2 = (self.pos.y + self.size.y) - plat.pos.y

        if min(dx1, dx2) < min(dy1, dy2):
            if dx1 < dx2:
                self.pos.x = plat.pos.x + plat.size.x
            else:
                self.pos.x = plat.pos.x - self.size.x
            self.vel.x = 0
        else:
            if dy1 < dy2:
                self.pos.y = plat.pos.y + plat.size.y
                if self.vel.y < 0:
                    self.vel.y = 0
            else:
                self.pos.y = plat.pos.y - self.size.y
                self.vel.y = 0
                self.on_ground = True
                self.pos += (plat.pos - plat.prev_pos)

    def get_render_pos(self, alpha):
        return self.prev_pos.lerp(self.pos, alpha)

    def get_render_rotation(self, alpha):
        return lerp(self.prev_rotation, self.rotation, alpha)

    def draw(self, surface, camera, alpha):
        pos = self.get_render_pos(alpha)
        rot = self.get_render_rotation(alpha)
        frame = self.anims[self.current_anim].current

        # Flip if facing left
        if self.facing < 0:
            frame = pygame.transform.flip(frame, True, False)

        # Rotate
        if abs(rot) > 0.5:
            frame = pygame.transform.rotate(frame, rot)

        rect = frame.get_rect(center=camera.apply(pos + self.size / 2))
        surface.blit(frame, rect)

# -------------------------------------------------
# Enemy (simple)
# -------------------------------------------------
class Enemy:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.size = pygame.Vector2(36, 36)
        self.vel = pygame.Vector2(-100, 0)
        self.alive = True
        self.rotation = 0.0
        self.prev_rotation = 0.0

    def physics_update(self, dt, platforms):
        if not self.alive:
            return
        self.prev_pos = self.pos.copy()
        self.prev_rotation = self.rotation

        self.vel.y += GRAVITY * dt
        self.pos += self.vel * dt
        self.rotation += self.vel.x * 0.15 * dt   # spin a bit

        for plat in platforms:
            if plat.one_way or abs(plat.slope) > 0.01:
                continue
            if (self.pos.x < plat.pos.x + plat.size.x and
                self.pos.x + self.size.x > plat.pos.x and
                self.pos.y < plat.pos.y + plat.size.y and
                self.pos.y + self.size.y > plat.pos.y):
                # rough resolve
                self.pos.y = plat.pos.y - self.size.y
                self.vel.y = 0
                # turn at edges
                if self.pos.x < plat.pos.x + 8 or self.pos.x + self.size.x > plat.pos.x + plat.size.x - 8:
                    self.vel.x *= -1

    def draw(self, surface, camera, alpha):
        if not self.alive:
            return
        pos = self.prev_pos.lerp(self.pos, alpha)
        rot = lerp(self.prev_rotation, self.rotation, alpha)
        surf = pygame.Surface((36, 36), pygame.SRCALPHA)
        pygame.draw.rect(surf, (220, 70, 70), (0, 0, 36, 36))
        pygame.draw.circle(surf, (20, 20, 20), (10, 12), 4)
        pygame.draw.circle(surf, (20, 20, 20), (26, 12), 4)
        if abs(rot) > 1:
            surf = pygame.transform.rotate(surf, rot)
        rect = surf.get_rect(center=camera.apply(pos + self.size / 2))
        surface.blit(surf, rect)

# -------------------------------------------------
# Main
# -------------------------------------------------
def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Full Physics Demo – One-way / Slopes / Anim / Camera / Particles")
    clock = pygame.time.Clock()
    font = pygame.font.SysFont("consolas", 17)

    # Level geometry
    platforms = [
        Platform(0, 580, 1400, 50),                          # main ground
        Platform(300, 480, 160, 22, one_way=True),           # one-way
        Platform(550, 400, 140, 22, one_way=True),
        Platform(800, 320, 180, 22),
        Platform(200, 320, 200, 24, slope=-18),              # slope down to right
        Platform(1050, 450, 160, 22, move_range=120, speed=70),
        Platform(1300, 380, 150, 22, one_way=True),
    ]

    enemies = [
        Enemy(400, 430),
        Enemy(900, 270),
        Enemy(1200, 400),
    ]

    player = Player(150, 400)
    camera = Camera(WIDTH, HEIGHT)
    particles = ParticleSystem()
    accumulator = 0.0
    running = True

    while running:
        frame_time = clock.tick(FPS) / 1000.0
        frame_time = min(frame_time, MAX_FRAME_TIME)
        accumulator += frame_time

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False

        keys = pygame.key.get_pressed()

        # Fixed update
        while accumulator >= PHYSICS_DT:
            for p in platforms:
                p.physics_update(PHYSICS_DT)
            for e in enemies:
                e.physics_update(PHYSICS_DT, platforms)
            player.physics_update(PHYSICS_DT, keys, platforms, enemies, particles)
            particles.update(PHYSICS_DT)
            accumulator -= PHYSICS_DT

        alpha = accumulator / PHYSICS_DT

        # Camera (use interpolated player position)
        cam_target = player.get_render_pos(alpha) + player.size / 2
        camera.follow(cam_target, frame_time)

        # Draw
        screen.fill((22, 25, 35))

        for p in platforms:
            p.draw(screen, camera, alpha)
        for e in enemies:
            e.draw(screen, camera, alpha)
        player.draw(screen, camera, alpha)
        particles.draw(screen, camera.pos)

        # UI
        lines = [
            f"FPS {clock.get_fps():5.1f}  |  Coyote {player.coyote_timer:.2f}  Buffer {player.jump_buffer_timer:.2f}",
            "A/D or Arrows – move   Space/W – jump   Esc – quit",
            "One-way platforms (brown)  |  Green = solid  |  Slopes work",
        ]
        for i, t in enumerate(lines):
            screen.blit(font.render(t, True, (200, 205, 215)), (12, 10 + i * 22))

        pygame.display.flip()

    pygame.quit()
    sys.exit()

if __name__ == "__main__":
    main()
```

### Features included

| Feature | Implementation |
|---------|----------------|
| **One-way platforms** | Only collide when falling and feet are near the top surface |
| **Slopes** | Simple height sampling + snap-to-surface (works for moderate angles) |
| **Animation frames** | Idle / Run / Jump using generated surfaces + frame timer |
| **Rotation interpolation** | Player leans while running / in air; enemies spin; both are interpolated |
| **Smooth camera** | Exponential follow (`smooth` factor) centered on player |
| **Particles** | Burst on jump, landing, and stomp |

### Controls
- **A / D** or **← / →** – move  
- **Space / W / ↑** – jump (coyote + buffer)  
- **Esc** – quit  

The level is wider than the screen so you can see the camera follow. One-way platforms are the brownish ones; you can jump up through them and land on top.

You now have a solid foundation for a small platformer. You can replace the generated frames with real sprite sheets later and expand the slope solver if you need steeper or more accurate terrain.

**Slope Sliding Physics**

Here is a clean, focused implementation of proper slope sliding that you can drop into the previous fixed-timestep system. It replaces the simple “snap to surface” logic with real projection of forces onto the slope.

### Core Ideas

- Compute the **slope normal** and **tangent**.
- Project gravity onto the tangent → sliding force.
- Project player input onto the tangent → walking force.
- Apply friction opposite to the velocity along the slope.
- Keep the player snapped to the surface while grounded.
- Allow falling off the ends of the slope.

### Slope Helper

```python
import math
import pygame

class Slope:
    """Represents a static slope segment from (x1,y1) to (x2,y2)."""
    def __init__(self, x1, y1, x2, y2, friction=0.75):
        self.p1 = pygame.Vector2(x1, y1)
        self.p2 = pygame.Vector2(x2, y2)
        self.friction = friction

        delta = self.p2 - self.p1
        self.length = delta.length()
        self.angle = math.atan2(delta.y, delta.x)          # radians
        self.tangent = delta.normalize()                   # direction along slope
        # outward normal (pointing "up" away from the ground)
        self.normal = pygame.Vector2(-self.tangent.y, self.tangent.x)
        if self.normal.y > 0:          # make sure normal points upward
            self.normal = -self.normal

    def closest_point(self, point: pygame.Vector2) -> tuple[pygame.Vector2, float]:
        """Returns (closest point on segment, t in [0,1])."""
        to_point = point - self.p1
        t = to_point.dot(self.tangent) / self.length
        t = max(0.0, min(1.0, t))
        return self.p1 + self.tangent * (t * self.length), t

    def is_near(self, point: pygame.Vector2, threshold=12) -> bool:
        closest, t = self.closest_point(point)
        return (point - closest).length() < threshold and 0.0 <= t <= 1.0
```

### Player Slope Logic (key part)

```python
class Player:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.vel = pygame.Vector2(0, 0)
        self.size = pygame.Vector2(40, 50)
        self.on_ground = False
        self.on_slope = None          # currently attached Slope or None
        self.coyote_timer = 0.0
        self.jump_buffer_timer = 0.0
        self.facing = 1

        # Tunables
        self.move_speed = 320
        self.jump_force = -750
        self.ground_friction = 0.82
        self.air_friction = 0.98
        self.slope_stick = 18         # how strongly we snap to slope

    def physics_update(self, dt, keys, slopes, solid_platforms, particles):
        self.prev_pos = self.pos.copy()
        was_on_ground = self.on_ground

        # --- Timers ---
        if self.on_ground:
            self.coyote_timer = 0.10
        else:
            self.coyote_timer = max(0.0, self.coyote_timer - dt)

        jump_pressed = keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]
        if jump_pressed:
            self.jump_buffer_timer = 0.12
        else:
            self.jump_buffer_timer = max(0.0, self.jump_buffer_timer - dt)

        # --- Jump ---
        if self.jump_buffer_timer > 0 and self.coyote_timer > 0:
            self.vel.y = self.jump_force
            self.on_ground = False
            self.on_slope = None
            self.coyote_timer = 0
            self.jump_buffer_timer = 0
            particles.emit(self.pos + pygame.Vector2(20, 50), 8, (180, 180, 200))

        # -------------------------------------------------
        # SLOPE PHYSICS
        # -------------------------------------------------
        if self.on_slope is not None:
            self._update_on_slope(dt, keys)
        else:
            # normal airborne / flat ground gravity
            self.vel.y += 2100 * dt

            # horizontal input (air or flat)
            accel = 0
            if keys[pygame.K_LEFT] or keys[pygame.K_a]:
                accel = -self.move_speed
                self.facing = -1
            if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
                accel = self.move_speed
                self.facing = 1

            if self.on_ground:
                self.vel.x = accel          # direct control on flat ground
                self.vel.x *= self.ground_friction
            else:
                self.vel.x += accel * dt * 3
                self.vel.x *= self.air_friction

        # Integrate
        self.pos += self.vel * dt

        # -------------------------------------------------
        # Collision / attachment
        # -------------------------------------------------
        self.on_ground = False
        self.on_slope = None

        # First try slopes
        feet = self.pos + pygame.Vector2(self.size.x / 2, self.size.y)
        for slope in slopes:
            closest, t = slope.closest_point(feet)
            dist = (feet - closest).length()

            # Only attach if we are moving downward or already close
            if dist < self.slope_stick and self.vel.dot(slope.normal) <= 50:
                # Snap to surface
                self.pos = closest - pygame.Vector2(self.size.x / 2, self.size.y)
                self.on_ground = True
                self.on_slope = slope

                # Kill velocity into the slope
                vel_into = self.vel.dot(slope.normal)
                if vel_into < 0:
                    self.vel -= slope.normal * vel_into
                break

        # Then solid AABB platforms (flat)
        for plat in solid_platforms:
            self._resolve_aabb(plat)

        # Landing particles
        if self.on_ground and not was_on_ground:
            particles.emit(self.pos + pygame.Vector2(20, 50), 10, (160, 150, 130))

        # World bounds etc. ...
        self.pos.x = max(0, min(self.pos.x, 3000))

    def _update_on_slope(self, dt, keys):
        """Called every physics step while attached to a slope."""
        slope = self.on_slope

        # 1. Gravity projected onto the slope tangent → sliding force
        gravity = pygame.Vector2(0, 2100)
        slide_force = gravity.dot(slope.tangent)          # scalar
        self.vel += slope.tangent * slide_force * dt

        # 2. Player input projected onto tangent
        input_dir = 0
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            input_dir = -1
            self.facing = -1
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            input_dir = 1
            self.facing = 1

        # How much of the input is along the slope
        walk_force = input_dir * self.move_speed
        self.vel += slope.tangent * walk_force * dt * 4.0   # responsiveness

        # 3. Friction (opposite to current velocity along slope)
        speed_along = self.vel.dot(slope.tangent)
        friction = slope.friction
        self.vel -= slope.tangent * speed_along * (1.0 - friction)

        # Optional: limit max sliding speed
        max_slide = 600
        speed_along = self.vel.dot(slope.tangent)
        if abs(speed_along) > max_slide:
            self.vel -= slope.tangent * (speed_along - math.copysign(max_slide, speed_along))

    def _resolve_aabb(self, plat):
        # Classic AABB resolution (same as previous examples)
        if not (self.pos.x < plat.pos.x + plat.size.x and
                self.pos.x + self.size.x > plat.pos.x and
                self.pos.y < plat.pos.y + plat.size.y and
                self.pos.y + self.size.y > plat.pos.y):
            return

        dx1 = (plat.pos.x + plat.size.x) - self.pos.x
        dx2 = (self.pos.x + self.size.x) - plat.pos.x
        dy1 = (plat.pos.y + plat.size.y) - self.pos.y
        dy2 = (self.pos.y + self.size.y) - plat.pos.y

        if min(dx1, dx2) < min(dy1, dy2):
            if dx1 < dx2:
                self.pos.x = plat.pos.x + plat.size.x
            else:
                self.pos.x = plat.pos.x - self.size.x
            self.vel.x = 0
        else:
            if dy1 < dy2:
                self.pos.y = plat.pos.y + plat.size.y
                if self.vel.y < 0:
                    self.vel.y = 0
            else:
                self.pos.y = plat.pos.y - self.size.y
                self.vel.y = 0
                self.on_ground = True
```

### How to build slopes in the level

```python
slopes = [
    Slope(200, 500, 450, 380, friction=0.7),   # uphill to the right
    Slope(500, 380, 750, 480, friction=0.65),  # downhill
    Slope(900, 450, 1200, 300, friction=0.8),  # steeper uphill
]

solid_platforms = [
    Platform(0, 580, 2000, 50),          # flat ground
    # ... other flat / one-way platforms
]
```

### Summary of the sliding model

| Force / Effect          | Implementation                                      |
|-------------------------|-----------------------------------------------------|
| Gravity on slope        | `gravity · tangent` → acceleration along slope     |
| Player walking          | Input projected onto tangent                        |
| Friction                | Dampen the component of velocity along the tangent  |
| Sticking                | Snap feet to closest point while velocity into normal is small |
| Leaving the slope       | Jump or walk off the ends (t goes outside [0,1])    |

### Tuning tips

- **Steeper slopes** → larger `|angle|` → stronger sliding component.
- **Higher friction** (0.85–0.95) → almost no slide, good for gentle hills.
- **Lower friction** (0.5–0.7) → icy / fast slides.
- `slope_stick` controls how far away you can be and still snap (prevents jitter).
- You can add a **minimum angle** below which the slope is treated as flat ground if you want.

Would you like me to also show:

1. A version that supports **moving slopes**, or  
2. **Corner / edge correction** so the player doesn’t catch on the ends of slopes, or  
3. The complete integrated script with the new slope system + the previous features (camera, particles, animation, etc.)?
- Yes to all
**Complete Integrated Demo**  
Fixed timestep · Coyote + Jump Buffer · One-way platforms · **Proper slope sliding** · **Moving slopes** · **Edge/corner correction** · Animation · Rotation interpolation · Smooth camera · Particles

```python
import pygame
import sys
import math
import random
from dataclasses import dataclass

# -------------------------------------------------
# Settings
# -------------------------------------------------
WIDTH, HEIGHT = 1200, 700
FPS = 120
PHYSICS_FPS = 60
PHYSICS_DT = 1.0 / PHYSICS_FPS
MAX_FRAME_TIME = 0.25

GRAVITY = 2100
MOVE_SPEED = 330
JUMP_FORCE = -760
COYOTE_TIME = 0.10
JUMP_BUFFER_TIME = 0.12

# -------------------------------------------------
# Utilities
# -------------------------------------------------
def lerp(a, b, t):
    return a + (b - a) * t

def clamp(v, lo, hi):
    return max(lo, min(hi, v))

# -------------------------------------------------
# Particles
# -------------------------------------------------
@dataclass
class Particle:
    pos: pygame.Vector2
    vel: pygame.Vector2
    life: float
    max_life: float
    color: tuple
    size: float
    gravity: float = 900

    def update(self, dt):
        self.vel.y += self.gravity * dt
        self.pos += self.vel * dt
        self.life -= dt

    def draw(self, surface, camera_pos):
        if self.life <= 0:
            return
        alpha = clamp(self.life / self.max_life, 0, 1)
        s = max(1, int(self.size * alpha))
        p = self.pos - camera_pos
        surf = pygame.Surface((s * 2, s * 2), pygame.SRCALPHA)
        pygame.draw.circle(surf, (*self.color, int(220 * alpha)), (s, s), s)
        surface.blit(surf, (p.x - s, p.y - s))

class ParticleSystem:
    def __init__(self):
        self.particles = []

    def emit(self, pos, count, color, speed=160, life=0.4, size=4):
        for _ in range(count):
            angle = random.uniform(0, math.tau)
            spd = random.uniform(speed * 0.3, speed)
            vel = pygame.Vector2(math.cos(angle), math.sin(angle)) * spd
            self.particles.append(Particle(
                pos=pos.copy(), vel=vel,
                life=life, max_life=life,
                color=color, size=size
            ))

    def update(self, dt):
        for p in self.particles:
            p.update(dt)
        self.particles = [p for p in self.particles if p.life > 0]

    def draw(self, surface, camera_pos):
        for p in self.particles:
            p.draw(surface, camera_pos)

# -------------------------------------------------
# Camera
# -------------------------------------------------
class Camera:
    def __init__(self, w, h):
        self.pos = pygame.Vector2(0, 0)
        self.smooth = 7.0
        self.w = w
        self.h = h

    def follow(self, target, dt):
        desired = target - pygame.Vector2(self.w / 2, self.h / 2 - 50)
        self.pos += (desired - self.pos) * min(1.0, self.smooth * dt)

    def apply(self, pos):
        return pos - self.pos

# -------------------------------------------------
# Slope (supports moving)
# -------------------------------------------------
class Slope:
    def __init__(self, x1, y1, x2, y2, friction=0.72,
                 move_range=0, speed=0, move_axis="x"):
        self.base_p1 = pygame.Vector2(x1, y1)
        self.base_p2 = pygame.Vector2(x2, y2)
        self.p1 = self.base_p1.copy()
        self.p2 = self.base_p2.copy()
        self.prev_p1 = self.p1.copy()
        self.prev_p2 = self.p2.copy()

        self.friction = friction
        self.move_range = move_range
        self.speed = speed
        self.move_axis = move_axis
        self.direction = 1
        self.offset = 0.0

        self._rebuild()

    def _rebuild(self):
        delta = self.p2 - self.p1
        self.length = delta.length()
        if self.length < 1:
            self.length = 1
        self.tangent = delta.normalize()
        self.normal = pygame.Vector2(-self.tangent.y, self.tangent.x)
        if self.normal.y > 0:
            self.normal = -self.normal
        self.angle = math.atan2(delta.y, delta.x)

    def physics_update(self, dt):
        self.prev_p1 = self.p1.copy()
        self.prev_p2 = self.p2.copy()

        if self.move_range > 0:
            self.offset += self.speed * self.direction * dt
            if self.offset > self.move_range:
                self.offset = self.move_range
                self.direction = -1
            elif self.offset < 0:
                self.offset = 0
                self.direction = 1

            if self.move_axis == "x":
                self.p1 = self.base_p1 + pygame.Vector2(self.offset, 0)
                self.p2 = self.base_p2 + pygame.Vector2(self.offset, 0)
            else:
                self.p1 = self.base_p1 + pygame.Vector2(0, self.offset)
                self.p2 = self.base_p2 + pygame.Vector2(0, self.offset)

            self._rebuild()

    def closest_point(self, point):
        to_point = point - self.p1
        t = to_point.dot(self.tangent) / self.length
        t_clamped = clamp(t, 0.0, 1.0)
        return self.p1 + self.tangent * (t_clamped * self.length), t_clamped, t

    def get_delta(self):
        """Movement of the slope this frame (for carrying the player)."""
        return (self.p1 - self.prev_p1)

    def draw(self, surface, camera, alpha):
        # Interpolate endpoints
        p1 = self.prev_p1.lerp(self.p1, alpha)
        p2 = self.prev_p2.lerp(self.p2, alpha)
        p1 = camera.apply(p1)
        p2 = camera.apply(p2)

        # Draw thick line + surface
        pygame.draw.line(surface, (85, 145, 80), p1, p2, 10)
        pygame.draw.line(surface, (55, 100, 50), p1, p2, 3)

        # Small end caps
        pygame.draw.circle(surface, (55, 100, 50), (int(p1.x), int(p1.y)), 5)
        pygame.draw.circle(surface, (55, 100, 50), (int(p2.x), int(p2.y)), 5)

# -------------------------------------------------
# Flat / One-way Platform
# -------------------------------------------------
class Platform:
    def __init__(self, x, y, w, h, one_way=False, move_range=0, speed=0):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.size = pygame.Vector2(w, h)
        self.one_way = one_way
        self.start_x = x
        self.move_range = move_range
        self.speed = speed
        self.direction = 1

    def physics_update(self, dt):
        self.prev_pos = self.pos.copy()
        if self.move_range > 0:
            self.pos.x += self.speed * self.direction * dt
            if self.pos.x > self.start_x + self.move_range:
                self.pos.x = self.start_x + self.move_range
                self.direction = -1
            elif self.pos.x < self.start_x:
                self.pos.x = self.start_x
                self.direction = 1

    def draw(self, surface, camera, alpha):
        p = self.prev_pos.lerp(self.pos, alpha)
        p = camera.apply(p)
        color = (100, 90, 55) if self.one_way else (70, 130, 75)
        pygame.draw.rect(surface, color, (*p, *self.size))
        pygame.draw.rect(surface, (40, 80, 45), (*p, *self.size), 2)

# -------------------------------------------------
# Animation
# -------------------------------------------------
def make_frames():
    def fr(color, lean=0, yoff=0):
        s = pygame.Surface((40, 50), pygame.SRCALPHA)
        pygame.draw.rect(s, color, (0, yoff, 40, 50 - yoff))
        pygame.draw.circle(s, (20, 20, 30), (12 + lean, 15), 4)
        pygame.draw.circle(s, (20, 20, 30), (28 + lean, 15), 4)
        return s

    return {
        "idle": [fr((80, 180, 255)), fr((80, 180, 255), yoff=1)],
        "run":  [fr((80, 180, 255), -3), fr((70, 170, 240), 0, 2),
                 fr((80, 180, 255), 3),  fr((70, 170, 240), 0, 2)],
        "jump": [fr((255, 140, 80))]
    }

class AnimPlayer:
    def __init__(self):
        self.frames = make_frames()
        self.state = "idle"
        self.timer = 0.0
        self.idx = 0
        self.duration = {"idle": 0.28, "run": 0.09, "jump": 0.1}

    def set_state(self, new_state):
        if new_state != self.state:
            self.state = new_state
            self.idx = 0
            self.timer = 0.0

    def update(self, dt):
        self.timer += dt
        if self.timer >= self.duration[self.state]:
            self.timer = 0.0
            self.idx = (self.idx + 1) % len(self.frames[self.state])

    @property
    def current(self):
        return self.frames[self.state][self.idx]

# -------------------------------------------------
# Player with full slope sliding + edge correction
# -------------------------------------------------
class Player:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.vel = pygame.Vector2(0, 0)
        self.size = pygame.Vector2(40, 50)

        self.on_ground = False
        self.on_slope = None
        self.coyote_timer = 0.0
        self.jump_buffer_timer = 0.0
        self.facing = 1
        self.was_on_ground = False

        self.anim = AnimPlayer()
        self.rotation = 0.0
        self.prev_rotation = 0.0

        # Slope tuning
        self.slope_stick = 16
        self.max_slide_speed = 650

    def physics_update(self, dt, keys, slopes, platforms, particles):
        self.prev_pos = self.pos.copy()
        self.prev_rotation = self.rotation
        self.was_on_ground = self.on_ground

        # Timers
        if self.on_ground:
            self.coyote_timer = COYOTE_TIME
        else:
            self.coyote_timer = max(0.0, self.coyote_timer - dt)

        jump_pressed = keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]
        if jump_pressed:
            self.jump_buffer_timer = JUMP_BUFFER_TIME
        else:
            self.jump_buffer_timer = max(0.0, self.jump_buffer_timer - dt)

        # Jump
        if self.jump_buffer_timer > 0 and self.coyote_timer > 0:
            self.vel.y = JUMP_FORCE
            self.on_ground = False
            self.on_slope = None
            self.coyote_timer = 0
            self.jump_buffer_timer = 0
            particles.emit(self.pos + pygame.Vector2(20, 48), 9, (190, 190, 210), speed=130)

        # ----- Movement & forces -----
        if self.on_slope is not None:
            self._slope_forces(dt, keys)
        else:
            self.vel.y += GRAVITY * dt
            input_x = 0
            if keys[pygame.K_LEFT] or keys[pygame.K_a]:
                input_x = -1
                self.facing = -1
            if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
                input_x = 1
                self.facing = 1

            if self.on_ground:
                self.vel.x = input_x * MOVE_SPEED
            else:
                self.vel.x += input_x * MOVE_SPEED * 3.5 * dt
                self.vel.x *= 0.98

        # Integrate
        self.pos += self.vel * dt

        # ----- Collisions -----
        self.on_ground = False
        old_slope = self.on_slope
        self.on_slope = None

        # Slopes first
        feet = self.pos + pygame.Vector2(self.size.x * 0.5, self.size.y)
        best_dist = self.slope_stick
        best_slope = None
        best_closest = None

        for slope in slopes:
            closest, t_clamped, t_raw = slope.closest_point(feet)
            dist = (feet - closest).length()

            # Edge correction: only accept if still roughly over the segment
            # (small tolerance so we don't catch on the very tip)
            if dist < best_dist and -0.05 <= t_raw <= 1.05:
                # Only attach when moving toward the surface or already close
                into = self.vel.dot(slope.normal)
                if into <= 80 or dist < 6:
                    best_dist = dist
                    best_slope = slope
                    best_closest = closest

        if best_slope is not None:
            # Snap
            self.pos = best_closest - pygame.Vector2(self.size.x * 0.5, self.size.y)
            self.on_ground = True
            self.on_slope = best_slope

            # Remove velocity into the slope
            into = self.vel.dot(best_slope.normal)
            if into < 0:
                self.vel -= best_slope.normal * into

            # Carry with moving slope
            self.pos += best_slope.get_delta()

            # Edge correction: if we slid past the end, detach cleanly
            _, _, t_raw = best_slope.closest_point(
                self.pos + pygame.Vector2(self.size.x * 0.5, self.size.y)
            )
            if t_raw < -0.02 or t_raw > 1.02:
                self.on_slope = None
                # small push outward so we don't re-attach instantly
                self.vel += best_slope.normal * 30

        # Flat / one-way platforms
        for plat in platforms:
            self._collide_platform(plat)

        # Landing particles
        if self.on_ground and not self.was_on_ground:
            particles.emit(self.pos + pygame.Vector2(20, 48), 11, (150, 140, 120), speed=110)

        # Animation state
        if not self.on_ground:
            self.anim.set_state("jump")
        elif abs(self.vel.x) > 25 or (self.on_slope and abs(self.vel.dot(self.on_slope.tangent)) > 25):
            self.anim.set_state("run")
        else:
            self.anim.set_state("idle")
        self.anim.update(dt)

        # Visual lean / rotation
        if self.on_slope:
            target_rot = -math.degrees(self.on_slope.angle) * 0.7
        elif self.on_ground:
            target_rot = -self.vel.x * 0.028
        else:
            target_rot = self.vel.x * 0.018
        self.rotation = lerp(self.rotation, target_rot, 12 * dt)

        # World bounds
        self.pos.x = clamp(self.pos.x, 0, 4000)
        if self.pos.y > 2500:
            self.pos = pygame.Vector2(150, 300)
            self.vel *= 0

    def _slope_forces(self, dt, keys):
        slope = self.on_slope

        # Gravity → slide force
        gravity = pygame.Vector2(0, GRAVITY)
        slide_acc = gravity.dot(slope.tangent)
        self.vel += slope.tangent * slide_acc * dt

        # Input along slope
        input_dir = 0
        if keys[pygame.K_LEFT] or keys[pygame.K_a]:
            input_dir = -1
            self.facing = -1
        if keys[pygame.K_RIGHT] or keys[pygame.K_d]:
            input_dir = 1
            self.facing = 1

        self.vel += slope.tangent * (input_dir * MOVE_SPEED * 4.2 * dt)

        # Friction
        speed_along = self.vel.dot(slope.tangent)
        self.vel -= slope.tangent * speed_along * (1.0 - slope.friction)

        # Clamp max slide speed
        speed_along = self.vel.dot(slope.tangent)
        if abs(speed_along) > self.max_slide_speed:
            excess = speed_along - math.copysign(self.max_slide_speed, speed_along)
            self.vel -= slope.tangent * excess

    def _collide_platform(self, plat):
        if plat.one_way:
            feet = self.pos.y + self.size.y
            if self.vel.y < 0 or feet < plat.pos.y - 6 or feet > plat.pos.y + 22:
                return

        if not (self.pos.x < plat.pos.x + plat.size.x and
                self.pos.x + self.size.x > plat.pos.x and
                self.pos.y < plat.pos.y + plat.size.y and
                self.pos.y + self.size.y > plat.pos.y):
            return

        dx1 = (plat.pos.x + plat.size.x) - self.pos.x
        dx2 = (self.pos.x + self.size.x) - plat.pos.x
        dy1 = (plat.pos.y + plat.size.y) - self.pos.y
        dy2 = (self.pos.y + self.size.y) - plat.pos.y

        if min(dx1, dx2) < min(dy1, dy2):
            if dx1 < dx2:
                self.pos.x = plat.pos.x + plat.size.x
            else:
                self.pos.x = plat.pos.x - self.size.x
            self.vel.x = 0
        else:
            if dy1 < dy2:
                self.pos.y = plat.pos.y + plat.size.y
                if self.vel.y < 0:
                    self.vel.y = 0
            else:
                self.pos.y = plat.pos.y - self.size.y
                self.vel.y = 0
                self.on_ground = True
                self.pos += (plat.pos - plat.prev_pos)

    def get_render_pos(self, alpha):
        return self.prev_pos.lerp(self.pos, alpha)

    def get_render_rotation(self, alpha):
        return lerp(self.prev_rotation, self.rotation, alpha)

    def draw(self, surface, camera, alpha):
        pos = self.get_render_pos(alpha)
        rot = self.get_render_rotation(alpha)
        frame = self.anim.current

        if self.facing < 0:
            frame = pygame.transform.flip(frame, True, False)
        if abs(rot) > 0.4:
            frame = pygame.transform.rotate(frame, rot)

        rect = frame.get_rect(center=camera.apply(pos + self.size / 2))
        surface.blit(frame, rect)

# -------------------------------------------------
# Enemy (simple)
# -------------------------------------------------
class Enemy:
    def __init__(self, x, y):
        self.pos = pygame.Vector2(x, y)
        self.prev_pos = self.pos.copy()
        self.size = pygame.Vector2(34, 34)
        self.vel = pygame.Vector2(-90, 0)
        self.alive = True
        self.rotation = 0.0
        self.prev_rotation = 0.0

    def physics_update(self, dt, platforms):
        if not self.alive:
            return
        self.prev_pos = self.pos.copy()
        self.prev_rotation = self.rotation
        self.vel.y += GRAVITY * dt
        self.pos += self.vel * dt
        self.rotation += -self.vel.x * 0.2 * dt

        for plat in platforms:
            if plat.one_way:
                continue
            if (self.pos.x < plat.pos.x + plat.size.x and
                self.pos.x + self.size.x > plat.pos.x and
                self.pos.y < plat.pos.y + plat.size.y and
                self.pos.y + self.size.y > plat.pos.y):
                self.pos.y = plat.pos.y - self.size.y
                self.vel.y = 0
                if self.pos.x < plat.pos.x + 6 or self.pos.x + self.size.x > plat.pos.x + plat.size.x - 6:
                    self.vel.x *= -1

    def draw(self, surface, camera, alpha):
        if not self.alive:
            return
        pos = self.prev_pos.lerp(self.pos, alpha)
        rot = lerp(self.prev_rotation, self.rotation, alpha)
        s = pygame.Surface((34, 34), pygame.SRCALPHA)
        pygame.draw.rect(s, (220, 70, 70), (0, 0, 34, 34))
        pygame.draw.circle(s, (20, 20, 20), (9, 11), 4)
        pygame.draw.circle(s, (20, 20, 20), (25, 11), 4)
        if abs(rot) > 1:
            s = pygame.transform.rotate(s, rot)
        rect = s.get_rect(center=camera.apply(pos + self.size / 2))
        surface.blit(s, rect)

# -------------------------------------------------
# Main
# -------------------------------------------------
def main():
    pygame.init()
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    pygame.display.set_caption("Full Demo – Slope Sliding + Moving Slopes + Edge Correction")
    clock = pygame.time.Clock()
    font = pygame.font.SysFont("consolas", 16)

    # ----- Level -----
    slopes = [
        Slope(250, 520, 520, 380, friction=0.68),               # uphill
        Slope(520, 380, 780, 480, friction=0.62),               # downhill
        Slope(900, 500, 1250, 320, friction=0.75,               # moving uphill
              move_range=90, speed=55, move_axis="x"),
        Slope(1400, 420, 1700, 420, friction=0.8),              # almost flat
        Slope(1750, 420, 2100, 280, friction=0.65),             # final climb
    ]

    platforms = [
        Platform(0, 600, 280, 40),
        Platform(780, 480, 120, 24, one_way=True),
        Platform(1100, 350, 160, 22, one_way=True),
        Platform(1550, 300, 140, 22),
        Platform(2100, 280, 400, 40),
    ]

    enemies = [
        Enemy(400, 350),
        Enemy(1000, 450),
        Enemy(1600, 250),
    ]

    player = Player(120, 450)
    camera = Camera(WIDTH, HEIGHT)
    particles = ParticleSystem()
    accumulator = 0.0
    running = True

    while running:
        frame_time = clock.tick(FPS) / 1000.0
        frame_time = min(frame_time, MAX_FRAME_TIME)
        accumulator += frame_tim

**Research Summary: “Deep Anormaly NPC”**

No exact match exists for the phrase **“Deep Anormaly NPC”** (likely a misspelling or variant of **“Deep Anomaly”** + **NPC**). Extensive searches across web sources, Steam, academic papers, game wikis, and related terms yield two primary clusters of relevant material. There is **no corpus of ~100 documents / 100,000 words** dedicated to a single entity, character, or system by that name. Below is a consolidated research overview of the closest and most substantive matches.

### 1. Primary Match: *Deep Anomaly* (Steam Game)
**Deep Anomaly** (Steam AppID 4480640) is an upcoming co-op extraction horror game developed and published by **Pogona Games**.

- **Status**: Coming soon / planned Early Access. No user reviews at the time of research. Developer estimates up to ~2 years in Early Access.
- **Premise**: Players are ZBO unit technicians sent on a routine repair mission into a Zenith Corporation underground facility. The entrance collapses, communications fail, and an anomaly known as **The Rift** begins to awaken. The facility was used for experiments on this unknown phenomenon.
- **Core Gameplay**:
  - 1–4 player co-op extraction horror.
  - Enter the facility, complete objectives, secure loot (“Living Anomalies”), reach extraction, and escape.
  - **Permadeath for gear**: Death results in loss of all equipment.
  - More players = more noise = greater threat.
- **Key Systems**:
  - **Sanity / Paranoia System**: Prolonged exposure causes hallucinations, voices, spatial disorientation. “Not everything you see is real. And not everything real wants to be seen.”
  - **Living Anomalies**: Corrupted items born from The Rift. Valuable for missions and progression, grant unique effects, but always carry a cost/risk.
  - **Unique Monsters / Entities**: Non-human predators with varied perception systems, unique abilities/attacks, enforced playstyles, and some described as immortal threats. Zones evolve.
  - **The Hub (Safe Zone)**: Base for crafting, trading, accepting missions, and upgrading facilities. Progression pushes players into deeper, more dangerous sectors.
  - **5 Facility Sectors**: Increasing difficulty, unique hazards (gases, extreme temperatures, blackouts), randomized layouts, dynamic events. “The facility changes constantly. But something… remembers.”
- **Objectives & Narrative**: Uncover Zenith Corporation secrets, progress equipment, complete main/side missions, unlock sectors, choose sides in a conflict. Multiple endings based on decisions.
- **Content Warnings**: Frequent/intense realistic violence, graphic depictions of blood, corpses, and death.
- **Technical**: Windows 10+, DirectX 12. Minimum roughly GTX 1650 / Ryzen 3-level hardware; recommended RTX 3060-class.
- **Development Notes**: Early Access focused on core mechanics with community feedback for balance, content expansion, story completion, and polish. Price may adjust later as content grows.

**NPC Connection**: The game features hostile entities (monsters/anomalies) that function as advanced, rule-based threats rather than traditional dialogue NPCs. No detailed public documentation of named friendly or quest-giving NPCs was found. The “Living Anomalies” and unique monsters are the closest analogues to anomalous NPCs.

Sources are limited primarily to the official Steam page. No extensive lore dumps, developer blogs with deep mechanical breakdowns, or large community wikis exist yet because the game has not released.

### 2. Secondary Match: Deep Anomaly Detection (Scientific / Technical Field)
“DeepAnomaly” and “Deep Anomaly Detection” refer to a well-established research area in machine learning and computer vision:

- **Core Concept**: Using deep neural networks for anomaly/outlier/novelty detection—identifying data patterns that deviate from expected “normal” behavior.
- **Notable Paper Example**: *DeepAnomaly: Combining Background Subtraction and Deep Learning for Detecting Obstacles and Anomalies in an Agricultural Field* (Christiansen et al.). Combines background subtraction with deep learning for fast detection of distant, occluded, or unknown obstacles (e.g., humans, animals) in homogeneous agricultural scenes. Demonstrated longer-range detection than Faster R-CNN in tests, with significantly fewer parameters and faster inference (suitable for embedded GPUs).
- **Broader Surveys**: Multiple comprehensive reviews exist (e.g., Pang et al., “Deep Learning for Anomaly Detection: A Review,” ACM Computing Surveys). These cover taxonomies with 3 high-level and 11+ fine-grained categories of methods: feature extraction, learning representations of normality, end-to-end anomaly score learning, reconstruction-based, generative, one-class classification, etc.
- **Applications**: Video anomaly detection in crowded scenes, time-series (e.g., DeepAnT), spatial transcriptomics, cybersecurity, industrial inspection, medical imaging, and more.
- **No NPC Link**: These are algorithmic techniques, not game characters or interactive NPCs.

This field has substantial academic literature (dozens to hundreds of papers), but it is technical and unrelated to game NPCs.

### 3. Other Peripheral Matches
- Various game mods and entities involving “anomaly” + NPCs (e.g., Garry’s Mod anomaly SNPC packs, Stalker Anomaly mods that make NPCs interact with/evade anomalies, horror mods with escalating anomaly entities).
- Unrelated or loosely themed games (Backrooms Anomaly, Anomaly 404, Platform Anomaly, etc.).
- Internet meme usage of “NPC” (non-player character as a descriptor for people perceived as lacking independent thought) combined with anomaly/horror themes—no specific “Deep Anormaly” entity.
- Isolated fictional or wiki entries (e.g., Deep Norns in Creatures, various “Depths” or void entities) that do not match.

### Scale Assessment (100 Docs / 100,000 Words)
- **Game (*Deep Anomaly*)**: Currently sparse public documentation (primarily the Steam store page and limited community discussion). Far below the requested volume.
- **Scientific Deep Anomaly Detection**: Rich academic literature exists and could approach or exceed significant word counts across surveys and papers, but it does not involve NPCs.
- No unified subject matching the exact query supports a 100-document / 100k-word deep dive at present.

**Conclusion**: The strongest interpretation is the upcoming Steam game *Deep Anomaly*, where anomalous entities serve as the primary hostile “NPCs.” Public information remains limited pre-release. If this refers to a different specific game, mod, AI system, lore entry, or internal project, additional context (platform, developer, or exact spelling) would allow more targeted research.

I can expand on any specific aspect (game mechanics speculation based on genre peers, scientific methods overview, comparisons to similar extraction horror titles, etc.) if you provide more details.


**Deep Anomaly Sanity / Paranoia Mechanics**

Public information on the sanity system in *Deep Anomaly* (Pogona Games) remains limited because the game is still listed as “Coming soon” / planned for Early Access. The only official details come from the Steam store page.

### Official Description
The game features a **Sanity System** (also referred to as a **paranoia system**):

> “Prolonged exposure to the laboratory twists the mind.  
> See things that aren’t there.  
> Hear voices.  
> Lose track of the layout.  
> **Not everything you see is real. And not everything real wants to be seen.**”

It is presented as a core pillar of the extraction-horror experience alongside living anomalies, unique monsters, and co-op tension.

### What Is Confirmed
- **Trigger**: Prolonged exposure to the Zenith Corporation facility / The Rift and its effects.
- **Effects** (explicitly listed):
  - Visual hallucinations (“see things that aren’t there”)
  - Auditory hallucinations (“hear voices”)
  - Spatial disorientation (“lose track of the layout”)
- **Thematic goal**: Force players to distrust their own senses. This creates uncertainty about what is a real threat versus a mental distortion.
- **Integration with other systems**: The paranoia system is highlighted in the same breath as the living anomalies and the facility’s evolving nature, suggesting it interacts with exploration, monster encounters, and possibly co-op communication.

### What Is Not Yet Public
No detailed mechanical breakdown has been released. The following remain unknown:

- Whether sanity is a visible meter, a hidden value, or tier-based.
- Exact sources of sanity drain (time in facility, proximity to anomalies/monsters, noise, specific sector hazards, failed objectives, etc.).
- Recovery methods (returning to The Hub, consumables, rest, successful extractions, etc.).
- Severity scaling (mild distortions → severe hallucinations → gameplay-altering effects such as false map data, phantom teammates, or forced behaviors).
- Co-op specifics (does one player’s low sanity affect others? Can teammates help stabilize someone?).
- Interaction with “Living Anomalies” (do some anomalies accelerate or mitigate sanity loss?).
- Whether low sanity can cause permanent or run-ending consequences beyond temporary distortion.

### Contextual Design Intent (Genre Comparison)
In extraction-horror and anomaly-horror games, sanity/paranoia systems typically serve these purposes:

- Increase tension by making information unreliable.
- Punish long stays or aggressive play.
- Create memorable “is that real?” moments.
- Add a soft resource-management layer alongside health, ammo, and extraction timers.
- Differentiate sectors or difficulty (deeper sectors = faster or harsher sanity drain).

*Deep Anomaly* appears to lean into the “distrust your senses” variant rather than pure combat-panic or meter-management styles seen in titles like *Amnesia*, *Phasmophobia*, or certain anomaly-spotting games.

### Current Status
Because the game has not entered Early Access yet, all deeper systems (exact numbers, thresholds, visual/audio implementation, balance) are subject to change based on developer iteration and community feedback. The Steam page emphasizes that Early Access will be used to refine mechanics with player input.

**Summary**: The sanity system is a confirmed core feature that causes hallucinations and spatial confusion through prolonged facility exposure, with the explicit design goal of making players question reality. No quantitative or granular mechanical details are publicly available at this time.

If new trailers, developer updates, or Early Access patch notes appear, the picture should become much clearer. Would you like comparisons to sanity systems in similar games, speculation on possible implementations, or monitoring for future updates?

**Sanity Mechanics Comparison: Phasmophobia vs Deep Anomaly**

### Phasmophobia Sanity System (Detailed & Established)

Phasmophobia has one of the most fully documented sanity systems in co-op horror.

**Core Structure**
- Two values: **Individual Sanity** (per player) and **Average Team Sanity**.
- Starts at 100% on most difficulties (75% on Insanity; custom difficulties can set any value).
- Dead players are excluded from the average.
- Visible via the van’s Sanity Monitor and roughly on the player’s watch.

**How Sanity Drains**
- **Passive drain** (main ongoing pressure): Occurs while inside the location in darkness. Rates scale by map size and difficulty:
  | Map Size   | Setup Phase | Normal Phase |
  |------------|-------------|--------------|
  | Small      | 0.09%/s     | 0.12%/s      |
  | Medium     | 0.05%/s     | 0.08%/s      |
  | Large      | 0.03%/s     | 0.05%/s      |
  - Multipliers: Amateur 1×, Intermediate 1.5×, Professional/Nightmare/Insanity 2×. Solo play halves the rate. Lit rooms or candles strongly reduce/prevent it. Faster in the ghost’s favorite room.
- **Active drains**:
  - Ghost events: usually –10% (higher for Banshee singing on target or Oni).
  - Player death: –15% to everyone.
  - Cursed possessions (Ouija Board, Music Box, Haunted Mirror, Voodoo Doll, Summoning Circle, etc.) cause large or continuous drains.
  - Ghost-specific abilities (Yurei door close, Jinn, Phantom LOS, Moroi curse that doubles passive drain, etc.).

**Recovery**
- Sanity Medication (pills): restores a difficulty-scaled amount (roughly 40% → 20% as difficulty rises). Higher tiers act faster and can add sprint boosts.
- Certain Tarot Cards (The Sun sets to 100%) and Monkey Paw wishes (with trade-offs).

**Effects of Low Sanity**
- Increases frequency of ghost interactions, events, and light flickering.
- **Hunt threshold**: Most ghosts can begin hunting at ≤50% average sanity. Notable exceptions:
  - Demon: ~70–100%
  - Mare: 60% (dark) / 40% (lit)
  - Shade: 35%
  - Deogen: 40%
  - Yokai: up to 80% if players talk nearby
  - Others vary (Raiju near electronics, Thaye age-based, etc.).
- Banshee uses the *target player’s* individual sanity instead of the team average.
- At 0% individual sanity: no instant death, but the player becomes a high-priority target for activity. Visual/audio hallucinations increase as sanity drops.
- Lower average sanity = more aggressive ghost behavior overall.

**Design Role**
Sanity is a clear, quantifiable resource that directly gates the ghost’s ability to hunt. It creates tension through resource management (light vs darkness, pills vs inventory space) and forces risk/reward decisions.

---

### Deep Anomaly Sanity / Paranoia System (Limited Public Info)

From the official Steam page only:

- Triggered by **prolonged exposure** to the Zenith Corporation facility / The Rift.
- Effects explicitly listed:
  - Visual hallucinations (“see things that aren’t there”)
  - Auditory hallucinations (“hear voices”)
  - Spatial disorientation (“lose track of the layout”)
- Tagline emphasizes sensory distrust: “Not everything you see is real. And not everything real wants to be seen.”
- Described as a “paranoia system” that makes players distrust their own senses.
- No public numbers for drain rates, thresholds, recovery methods, meters, or exact mechanical consequences.

Because the game is pre-Early Access, deeper details (meters, recovery items, co-op interactions, severity tiers, etc.) are not yet available.

---

### Side-by-Side Comparison

| Aspect                  | Phasmophobia                                      | Deep Anomaly (Known)                              |
|-------------------------|---------------------------------------------------|---------------------------------------------------|
| **Visibility**          | Clear % values (individual + team average)       | Unknown (possibly hidden or qualitative)         |
| **Primary Trigger**     | Darkness + time inside + ghost activity          | Prolonged facility / Rift exposure               |
| **Main Effects**        | Increased ghost activity + hunt thresholds       | Hallucinations + layout confusion + sensory distrust |
| **Hunt / Threat Link**  | Direct: average sanity gates hunts               | Implied but not detailed                         |
| **Recovery**            | Explicit consumables + rare items                | Unknown                                          |
| **Co-op Impact**        | Strong (team average drives most systems)        | Unknown                                          |
| **Tone**                | Resource-management + risk calculation           | Psychological uncertainty / “is it real?”        |
| **Documentation**       | Extremely detailed and player-tested             | Minimal official description only                |

### Key Differences in Philosophy
- **Phasmophobia** treats sanity as a measurable, gameable resource. Players actively manage lights, pills, and time to control when the ghost becomes dangerous. The system is transparent and strategic.
- **Deep Anomaly** appears to lean more heavily into *psychological horror and unreliability*. The described effects (false sights, voices, spatial confusion) suggest the system is meant to make players question the environment itself rather than just watch a number drop toward a hunt threshold. This aligns with extraction-horror goals where information itself becomes suspect.

### Summary
Phasmophobia offers a precise, well-understood sanity economy centered on hunt thresholds and resource trade-offs. Deep Anomaly’s system, based on current information, prioritizes sensory distortion and paranoia over clear numerical thresholds. Until Deep Anomaly enters Early Access and players can test it, the comparison remains high-level: one is a transparent risk meter, the other aims to make reality itself unreliable.

If new Deep Anomaly details emerge (trailers, patch notes, or developer posts), a more precise mechanical comparison will become possible.

เสร็จเรียบร้อย! 🔥✨

ผมได้อ่านไฟล์ PyGame Code Guidelines.md ของคุณแล้ว เป็นคู่มือสุดละเอียดเลยที่พี่ เน้นเรื่อง:
- 🎮 pygame.font.SysFont และ pygame.freetype
- 🇹🇭 การแสดงผลภาษาไทยบน Pygame
- ✍️ Text Wrap อัตโนมัติ + การจัดกึ่งกลาง
- 👻 ตัวอย่างเกม Deadcam Project (เกมผีอินดี้สไตล์สยองขวัญ)

จากเนื้อหาในไฟล์ ผมเลยปั้น ภาพปก Tutorial ออกมาให้ 4 สไตล์ ผ่านโหมด MOA (4 โมเดลทำงานพร้อมกัน) เพื่อให้เลือกแบบที่ใช่ที่สุดครับ 👇

🎨 ผลงานทั้ง 4 โมเดล

1. Nano Banana (Gemini 2.5 Flash) — สาย Retro Pixel Art 🎮
บรรยากาศ CRT monitor ผสม pixel-art ผีไทยถือไฟฉาย + วัด/ศาลพระภูมิ สีนีออนเขียว-ทอง vibe คลาสสิก 8-bit
📐 1344×768

2. GPT Image 2 — สาย Editorial Cinematic 🎬
โน้ตบุ๊คเปิดโค้ด Pygame + ตัวอักษรไทย "ก" ลอยเป็นโฮโลแกรม ท่ามกลางวัดไทยในหมอก สวยงามระดับบล็อกเทค
📐 2048×1152 (2K)

3. Flux 2 — สาย Photorealistic 📸
โต๊ะทำงาน Dev สมจริง มีแสง bokeh ฟุ้ง หน้าจอโชว์ "Hello Pygame สวัสดี" พร้อม particle ตัวอักษรไทยลอย
📐 1024×576

4. Bytedance Seedream v5 Lite — สาย V2D Isometric 🚀
ภาพประกอบสีจัดจ้าน เกาะ Workspace แบบ Isometric มีเกมมินิในจอ + Speech bubble "ลุย!" + sprite ผีอินดี้
📐 2560×1440 (2K)

💡 แนะนำการใช้งาน

- ถ้าเอาไปลง GitHub README → แนะนำ Nano Banana (ขนาดเล็ก โหลดเร็ว vibe คลาสสิก)
- ถ้าเอาไปทำ Medium บล็อกหรือหน้าปก Tech Blog → 🎯 GPT Image 2 หรือ Seedream v5 Lite (ชัดสุด ใหญ่สุด)
- ถ้าเอาไปทำ Slide Presentation → Flux 2 (ดูโปร ดูพรีเมียม)

อยากให้ปรับแต่งเพิ่มไหมครับ? เช่น 👇
- เปลี่ยน mood เป็นสยองขวัญแบบเกม Deadcam 💀
- ใส่ชื่อผู้เขียน/แชนแนลบนภาพปก
- ทำภาพ infografิกสรุปเนื้อหาในบทความ
- ทำภาพ Thumbnail สำหรับ YouTube (16:9 แนวนอน)

บอกได้เลย เดี๋ยวจัดให้! 🎯

Create a design system based on "สรุปและรายงานผล Pipeline Pulse Dashboard".
Reference another project
I'll start by exploring the template and any attached materials to understand the Pipeline Pulse Dashboard context.

รายการไฟล์
/projects/b7ff5b23-d33f-4d1f-961b-a1cb5255ecdc/
รายการไฟล์
รายการไฟล์
.
เขียนไฟล์
README.md
รายการไฟล์
The project is empty — no template files, no attached codebase, no Figma, no screenshots. The user asked for a design system based on "สรุปและรายงานผล Pipeline Pulse Dashboard" (Thai: "Summary and Reporting - Pipeline Pulse Dashboard").

Before I spend a lot of time inventing a brand from scratch, let me ask targeted questions to understand what "Pipeline Pulse Dashboard" actually is (sales pipeline? DevOps pipeline? data pipeline?) and pin down direction.

กำลังถามคำถาม
Pipeline Pulse Dashboard — ข้อมูลก่อนเริ่มสร้าง Design System
ดู
รอคำตอบจากผู้ใช้ก่อนน้าา ✨ ตั้งคำถามไว้ 14 ข้อครอบคลุมทั้ง type ของ pipeline, assets ที่มี, vibe, สี, KPI, chart, และ novelty เพื่อให้ design system ตรงกับที่ต้องการที่สุด — พอตอบเสร็จจะเริ่มลุยเลยจ้า 🔥

Questions answered:
- novelty: 3
- products: Dashboard หลัก (overview KPI), Pipeline / Kanban view, Report detail / analytics deep-dive, Slide template (สำหรับรายงานผลผู้บริหาร), Marketing / landing page, Login / auth
- mode: ทั้งสอง (มี toggle)
- color_direction: ม่วง / violet (modern SaaS)
- vibe: Enterprise Thai (สีน้ำเงินองค์กร, formal)
- audience: ทุกกลุ่ม
ใช้ระบบการออกแบบ: Design system based on สรุปและรายงานผล Pipeline Pulse Dashboard
ขอบคุณสำหรับคำตอบจ้าา! เอาล่ะเริ่มลุยกันเลย 🚀

สรุป direction ที่จับได้:

Pipeline Pulse Dashboard — Sales/CRM pipeline dashboard for enterprise Thai audience
Vibe: Enterprise Thai + modern SaaS violet
Bilingual (TH + EN) มั้ง, ทั้ง light + dark mode toggle
6 surfaces: Dashboard, Kanban, Report detail, Slide template, Landing, Login
Novelty 3 = balanced (by-the-book แต่ modern)
อัปเดตงาน
Set up folder structure + colors_and_type.css + fonts
ตั้งชื่อ
Pipeline Pulse Design System
วางแผน
Pipeline Pulse Design System
ดู
Failed to fetch

ต้องโหลดใหม่เพื่อใช้การเปลี่ยนแปลง
โหลดใหม่
เปิดตัวอย่าง

แผน
Pipeline Pulse Design System
Brand direction

Name: Pipeline Pulse
Wordmark: "Pipeline Pulse" with a pulse-wave "∿" mark, violet accent
Vibe: Enterprise Thai formal + modern SaaS violet — trustworthy, data-forward, bilingual TH/EN
Novelty 3: crisp modern SaaS layouts, restrained use of gradient
Color system (violet-forward, dual mode)

Primary: violet 600 #6D28D9 / hover 700 #5B21B6 (oklch based)
Corporate blue as secondary accent (enterprise Thai) #1E40AF
Neutrals: warm-cool slate scale (50→950)
Semantic: success green, warning amber, danger red, info blue
Chart palette: 6 violets → complements
Typography

Display + heading: IBM Plex Sans Thai (works for TH + EN, formal enterprise feel)
Body: Inter for EN, IBM Plex Sans Thai Looped for Thai body
Mono: IBM Plex Mono for numbers/data
Type scale: 12/14/16/18/20/24/30/36/48/60
Spacing / radii / shadows

4px baseline (0,1,2,3,4,6,8,12,16,20,24)
Radii: 4 / 6 / 8 / 12 / 16 / 999
Shadows: xs/sm/md/lg/xl using layered oklch shadows
Elevation for dark mode uses lighter overlays
Components to card-ify

Colors: primary violet, secondary blue, neutrals light, neutrals dark, semantic, chart palette
Type: display, headings, body, mono, thai/en pairing
Spacing tokens, radii, shadows
Buttons (primary/secondary/ghost + sizes)
Inputs, selects, checkboxes
KPI card, chart card, badge, chip
Navigation (sidebar, topbar), tabs
Pipeline stage card, kanban column
Modal / drawer preview
UI Kits (6 surfaces)

Dashboard overview — KPI grid + funnel + revenue trend + recent deals table
Pipeline Kanban — draggable columns per stage
Report detail — deep dive charts with filters
Marketing landing — hero + product screenshot + features
Login / auth — split hero login
Slide template — TitleSlide, KPISlide, ComparisonSlide, ChartSlide, QuoteSlide
Iconography

Lucide via CDN (crisp, modern, matches SaaS vibe)
Document usage + link CDN
Preview cards (target ~15-18)

2 color palettes (light + dark neutrals), 1 primary/accent, 1 semantic, 1 chart
2 type cards (display scale + Thai/EN pairing)
1 spacing, 1 radii, 1 shadow
4 component cards (buttons, inputs, KPI card, badge/chip)
1 nav card, 1 logo/brand card
Sample slides

TitleSlide, ExecutiveSummary, KPIGridSlide, PipelineFunnelSlide, QuoteSlide, NextStepsSlide
Let's build.![[PyGame Code Guidelines]]![[]]

https://grok.com/share/c2hhcmQtMg_dda46bde-9455-4ee2-8652-cc49df13056d
นี่คือ **ตัวอย่างโค้ดสมบูรณ์** ที่รวมทุกอย่างตามที่คุณถามไว้:

- ใช้ `pygame.freetype`
- รองรับฟอนต์ภาษาไทย (`.ttf` / `.otf`)
- จัดข้อความให้อยู่กึ่งกลาง
- มีระบบ **Text Wrap** ตัดคำขึ้นบรรทัดใหม่อัตโนมัติ (รองรับภาษาไทย)

```python
import pygame
import pygame.freetype
import sys

# ==================== 1. เริ่มต้นระบบ ====================
pygame.init()
pygame.freetype.init()

WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pygame Advanced Thai Font System")

# สี
WHITE = (255, 255, 255)
BLACK = (20, 20, 30)
YELLOW = (255, 220, 50)
CYAN = (0, 220, 255)

# ==================== 2. โหลดฟอนต์ภาษาไทย ====================
# วิธีที่ 1: ใช้ฟอนต์ระบบ (ถ้าเครื่องมี)
try:
    font = pygame.freetype.SysFont("Tahoma", 28)          # Windows
except:
    try:
        font = pygame.freetype.SysFont("DejaVu Sans", 28) # Linux
    except:
        font = pygame.freetype.SysFont(None, 28)          # fallback

# วิธีที่ 2: โหลดจากไฟล์ .ttf / .otf (แนะนำ)
# ใส่ path ฟอนต์ภาษาไทยของคุณที่นี่ เช่น "fonts/THSarabunNew.ttf"
# font = pygame.freetype.Font("fonts/THSarabunNew.ttf", 32)

# ปรับแต่งสไตล์
font.strong = False      # ตัวหนา
font.oblique = False     # ตัวเอียง
font.underline = False   # ขีดเส้นใต้

# ==================== 3. ฟังก์ชัน Text Wrap (รองรับภาษาไทย) ====================
def wrap_text(text, font, max_width):
    """
    ตัดข้อความให้อยู่ในความกว้างที่กำหนด
    รองรับภาษาไทย (ตัดตามช่องว่าง + ตัวอักษร)
    """
    words = text.replace("\n", " \n ").split(" ")
    lines = []
    current_line = ""

    for word in words:
        if word == "\n":
            lines.append(current_line)
            current_line = ""
            continue

        test_line = current_line + (" " if current_line else "") + word
        # วัดความกว้างของข้อความ
        rect = font.get_rect(test_line)

        if rect.width <= max_width:
            current_line = test_line
        else:
            if current_line:
                lines.append(current_line)
            current_line = word

    if current_line:
        lines.append(current_line)

    return lines


# ==================== 4. ฟังก์ชันวาดข้อความแบบจัดกึ่งกลาง + Wrap ====================
def draw_centered_text(surface, text, font, color, y_start, max_width=700, line_spacing=10):
    """
    วาดข้อความหลายบรรทัด จัดกึ่งกลางทั้งแนวนอน
    """
    lines = wrap_text(text, font, max_width)
    y = y_start

    for line in lines:
        # วัดขนาดข้อความ
        rect = font.get_rect(line)
        x = (WIDTH - rect.width) // 2          # จัดกึ่งกลางแนวนอน

        # วาดด้วย render_to
        font.render_to(surface, (x, y), line, color)
        y += rect.height + line_spacing

    return y  # คืนค่าตำแหน่ง Y ล่าสุด


# ==================== 5. ข้อความตัวอย่าง ====================
title = "ระบบแสดงผลภาษาไทยด้วย Pygame Freetype"
content = (
    "สวัสดีครับ นี่คือตัวอย่างการใช้งาน pygame.freetype "
    "สำหรับแสดงข้อความภาษาไทยอย่างสวยงาม "
    "รองรับการตัดคำขึ้นบรรทัดใหม่อัตโนมัติ (Text Wrap) "
    "และการจัดข้อความให้อยู่กึ่งกลางหน้าจอ "
    "คุณสามารถเปลี่ยนฟอนต์เป็น .ttf หรือ .otf ได้ตามต้องการ"
)

# ==================== 6. เกมลูปหลัก ====================
clock = pygame.time.Clock()
running = True

while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False

    # วาดพื้นหลัง
    screen.fill(BLACK)

    # วาดหัวข้อ
    draw_centered_text(screen, title, font, YELLOW, y_start=80, max_width=720)

    # วาดเนื้อหา
    draw_centered_text(screen, content, font, WHITE, y_start=180, max_width=680)

    # ข้อความด้านล่าง
    font.render_to(screen, (20, HEIGHT - 40), "กด ESC เพื่อออก", CYAN)

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()
```

### สรุปจุดเด่นของโค้ดนี้

| ฟีเจอร์ | สถานะ |
|--------|------|
| ใช้ `pygame.freetype` | ✅ |
| รองรับฟอนต์ภาษาไทย | ✅ (SysFont + โหลดไฟล์) |
| จัดข้อความกึ่งกลาง | ✅ |
| Text Wrap อัตโนมัติ | ✅ |
| ปรับตัวหนา / เอียง / ขีดเส้นใต้ได้ | ✅ |
| รองรับทั้ง `.ttf` และ `.otf` | ✅ |

---

**คำถามต่อ:**

1. อยากให้เพิ่ม **การหมุนข้อความ** (`rotation=`) ไหม?
2. อยากได้เวอร์ชันที่ใช้ฟอนต์จากไฟล์ `.ttf` โดยตรง (พร้อมตัวอย่าง path)?
3. อยากให้ทำระบบ **พิมพ์ทีละตัวอักษร** (typewriter effect) ด้วยไหม?

ได้เลยครับ นี่คือเวอร์ชันที่เพิ่ม **เอฟเฟกต์พิมพ์ทีละตัว (Typewriter Effect)** เข้าไปแล้ว

```python
import pygame
import pygame.freetype
import sys

# ==================== 1. เริ่มต้นระบบ ====================
pygame.init()
pygame.freetype.init()

WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pygame Thai Typewriter Effect")

# สี
WHITE = (255, 255, 255)
BLACK = (15, 15, 25)
YELLOW = (255, 220, 50)
CYAN = (0, 220, 255)
GRAY = (120, 120, 140)

# ==================== 2. โหลดฟอนต์ ====================
try:
    font = pygame.freetype.SysFont("Tahoma", 28)
except:
    font = pygame.freetype.SysFont(None, 28)

# ==================== 3. ข้อความที่จะพิมพ์ ====================
full_text = (
    "สวัสดีครับ นี่คือเอฟเฟกต์พิมพ์ทีละตัวอักษรด้วย Pygame Freetype "
    "รองรับภาษาไทยอย่างสมบูรณ์ สามารถปรับความเร็วในการพิมพ์ได้ตามต้องการ "
    "และยังจัดข้อความให้อยู่กึ่งกลางหน้าจอได้อีกด้วย"
)

# ==================== 4. ตัวแปรควบคุม Typewriter ====================
displayed_text = ""          # ข้อความที่แสดงอยู่ตอนนี้
char_index = 0               # ตำแหน่งตัวอักษรปัจจุบัน
typing_speed = 40            # มิลลิวินาทีต่อตัวอักษร (ยิ่งน้อยยิ่งเร็ว)
last_update = pygame.time.get_ticks()
finished = False             # พิมพ์จบหรือยัง

# ==================== 5. ฟังก์ชันวาดข้อความกึ่งกลาง ====================
def draw_centered_wrapped(surface, text, font, color, y_start, max_width=680, line_spacing=12):
    words = text.split(" ")
    lines = []
    current_line = ""

    for word in words:
        test_line = current_line + (" " if current_line else "") + word
        rect = font.get_rect(test_line)
        if rect.width <= max_width:
            current_line = test_line
        else:
            if current_line:
                lines.append(current_line)
            current_line = word
    if current_line:
        lines.append(current_line)

    y = y_start
    for line in lines:
        rect = font.get_rect(line)
        x = (WIDTH - rect.width) // 2
        font.render_to(surface, (x, y), line, color)
        y += rect.height + line_spacing
    return y


# ==================== 6. เกมลูปหลัก ====================
clock = pygame.time.Clock()
running = True

while running:
    current_time = pygame.time.get_ticks()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False
            # กด Space เพื่อข้าม / รีเซ็ต
            if event.key == pygame.K_SPACE:
                if finished:
                    # รีเซ็ตใหม่
                    displayed_text = ""
                    char_index = 0
                    finished = False
                    last_update = current_time
                else:
                    # ข้ามไปจบเลย
                    displayed_text = full_text
                    char_index = len(full_text)
                    finished = True

    # ----- Typewriter Logic -----
    if not finished and current_time - last_update > typing_speed:
        if char_index < len(full_text):
            displayed_text += full_text[char_index]
            char_index += 1
            last_update = current_time
        else:
            finished = True

    # ----- วาด -----
    screen.fill(BLACK)

    # หัวข้อ
    title_rect = font.get_rect("เอฟเฟกต์พิมพ์ทีละตัว (Typewriter)")
    font.render_to(screen, ((WIDTH - title_rect.width) // 2, 60), 
                   "เอฟเฟกต์พิมพ์ทีละตัว (Typewriter)", YELLOW)

    # ข้อความที่กำลังพิมพ์
    draw_centered_wrapped(screen, displayed_text, font, WHITE, y_start=160)

    # ข้อความด้านล่าง
    if finished:
        hint = "พิมพ์เสร็จแล้ว  •  กด SPACE เพื่อเริ่มใหม่"
    else:
        hint = "กำลังพิมพ์...  •  กด SPACE เพื่อข้าม"

    hint_rect = font.get_rect(hint)
    font.render_to(screen, ((WIDTH - hint_rect.width) // 2, HEIGHT - 50), hint, GRAY)

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()
```

### จุดเด่นของเวอร์ชันนี้

| ฟีเจอร์ | รายละเอียด |
|--------|-----------|
| **พิมพ์ทีละตัว** | ใช้ `pygame.time.get_ticks()` ควบคุมความเร็ว |
| **ปรับความเร็วได้** | เปลี่ยนค่า `typing_speed` (ค่าเริ่มต้น 40ms) |
| **กด Space ข้าม** | พิมพ์ไม่ทัน กด Space แล้วจบทันที |
| **กด Space อีกรอบ** | เริ่มพิมพ์ใหม่ตั้งแต่ต้น |
| **จัดกึ่งกลาง + Wrap** | ข้อความยาวขึ้นบรรทัดใหม่อัตโนมัติ |

---

**อยากปรับเพิ่มไหม?**

- ทำให้มี **เคอร์เซอร์กระพริบ** (`|`) ตอนพิมพ์อยู่  
- ใส่เสียงพิมพ์ดีด (typewriter sound)  
- ทำให้ข้อความโผล่ทีละคำแทนทีละตัว  
- หรือเปลี่ยนเป็นพิมพ์จากล่างขึ้นบนแบบเกม RPG

ได้เลยครับ นี่คือเวอร์ชันที่เพิ่ม **เอฟเฟกต์พิมพ์ทีละตัว (Typewriter Effect)** เข้าไปแล้ว

```python
import pygame
import pygame.freetype
import sys

# ==================== 1. เริ่มต้นระบบ ====================
pygame.init()
pygame.freetype.init()

WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pygame Thai Typewriter Effect")

# สี
WHITE = (255, 255, 255)
BLACK = (15, 15, 25)
YELLOW = (255, 220, 50)
CYAN = (0, 220, 255)
GRAY = (120, 120, 140)

# ==================== 2. โหลดฟอนต์ ====================
try:
    font = pygame.freetype.SysFont("Tahoma", 28)
except:
    font = pygame.freetype.SysFont(None, 28)

# ==================== 3. ข้อความที่จะพิมพ์ ====================
full_text = (
    "สวัสดีครับ นี่คือเอฟเฟกต์พิมพ์ทีละตัวอักษรด้วย Pygame Freetype "
    "รองรับภาษาไทยอย่างสมบูรณ์ สามารถปรับความเร็วในการพิมพ์ได้ตามต้องการ "
    "และยังจัดข้อความให้อยู่กึ่งกลางหน้าจอได้อีกด้วย"
)

# ==================== 4. ตัวแปรควบคุม Typewriter ====================
displayed_text = ""          # ข้อความที่แสดงอยู่ตอนนี้
char_index = 0               # ตำแหน่งตัวอักษรปัจจุบัน
typing_speed = 40            # มิลลิวินาทีต่อตัวอักษร (ยิ่งน้อยยิ่งเร็ว)
last_update = pygame.time.get_ticks()
finished = False             # พิมพ์จบหรือยัง

# ==================== 5. ฟังก์ชันวาดข้อความกึ่งกลาง ====================
def draw_centered_wrapped(surface, text, font, color, y_start, max_width=680, line_spacing=12):
    words = text.split(" ")
    lines = []
    current_line = ""

    for word in words:
        test_line = current_line + (" " if current_line else "") + word
        rect = font.get_rect(test_line)
        if rect.width <= max_width:
            current_line = test_line
        else:
            if current_line:
                lines.append(current_line)
            current_line = word
    if current_line:
        lines.append(current_line)

    y = y_start
    for line in lines:
        rect = font.get_rect(line)
        x = (WIDTH - rect.width) // 2
        font.render_to(surface, (x, y), line, color)
        y += rect.height + line_spacing
    return y


# ==================== 6. เกมลูปหลัก ====================
clock = pygame.time.Clock()
running = True

while running:
    current_time = pygame.time.get_ticks()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False
            # กด Space เพื่อข้าม / รีเซ็ต
            if event.key == pygame.K_SPACE:
                if finished:
                    # รีเซ็ตใหม่
                    displayed_text = ""
                    char_index = 0
                    finished = False
                    last_update = current_time
                else:
                    # ข้ามไปจบเลย
                    displayed_text = full_text
                    char_index = len(full_text)
                    finished = True

    # ----- Typewriter Logic -----
    if not finished and current_time - last_update > typing_speed:
        if char_index < len(full_text):
            displayed_text += full_text[char_index]
            char_index += 1
            last_update = current_time
        else:
            finished = True

    # ----- วาด -----
    screen.fill(BLACK)

    # หัวข้อ
    title_rect = font.get_rect("เอฟเฟกต์พิมพ์ทีละตัว (Typewriter)")
    font.render_to(screen, ((WIDTH - title_rect.width) // 2, 60), 
                   "เอฟเฟกต์พิมพ์ทีละตัว (Typewriter)", YELLOW)

    # ข้อความที่กำลังพิมพ์
    draw_centered_wrapped(screen, displayed_text, font, WHITE, y_start=160)

    # ข้อความด้านล่าง
    if finished:
        hint = "พิมพ์เสร็จแล้ว  •  กด SPACE เพื่อเริ่มใหม่"
    else:
        hint = "กำลังพิมพ์...  •  กด SPACE เพื่อข้าม"

    hint_rect = font.get_rect(hint)
    font.render_to(screen, ((WIDTH - hint_rect.width) // 2, HEIGHT - 50), hint, GRAY)

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()
```

### จุดเด่นของเวอร์ชันนี้

| ฟีเจอร์ | รายละเอียด |
|--------|-----------|
| **พิมพ์ทีละตัว** | ใช้ `pygame.time.get_ticks()` ควบคุมความเร็ว |
| **ปรับความเร็วได้** | เปลี่ยนค่า `typing_speed` (ค่าเริ่มต้น 40ms) |
| **กด Space ข้าม** | พิมพ์ไม่ทัน กด Space แล้วจบทันที |
| **กด Space อีกรอบ** | เริ่มพิมพ์ใหม่ตั้งแต่ต้น |
| **จัดกึ่งกลาง + Wrap** | ข้อความยาวขึ้นบรรทัดใหม่อัตโนมัติ |

---

**อยากปรับเพิ่มไหม?**

- ทำให้มี **เคอร์เซอร์กระพริบ** (`|`) ตอนพิมพ์อยู่  
- ใส่เสียงพิมพ์ดีด (typewriter sound)  
- ทำให้ข้อความโผล่ทีละคำแทนทีละตัว  
- หรือเปลี่ยนเป็นพิมพ์จากล่างขึ้นบนแบบเกม RPG

บอกได้เลยครับบอกได้เลยครับบอกมาได้เลยครับ
https://grok.com/share/c2hhcmQtMg_b2d4ce11-e093-4425-b51a-5c77a099a8c0
ได้เลยครับ นี่คือเวอร์ชัน **ขยายเต็มรูปแบบ** ที่มีทั้ง:

- เอฟเฟกต์พิมพ์ทีละตัว
- เคอร์เซอร์กระพริบ (`|`)
- เสียงพิมพ์ดีด (Typewriter Sound)
- ระบบควบคุมที่ดีขึ้น

```python
import pygame
import pygame.freetype
import sys
import os

# ==================== 1. เริ่มต้นระบบ ====================
pygame.init()
pygame.freetype.init()
pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)

WIDTH, HEIGHT = 900, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Pygame Thai Typewriter - Full System")

# สี
WHITE = (255, 255, 255)
BLACK = (12, 12, 22)
YELLOW = (255, 220, 50)
CYAN = (0, 220, 255)
GRAY = (130, 130, 150)
DARK_GRAY = (40, 40, 55)

# ==================== 2. โหลดฟอนต์ ====================
try:
    font = pygame.freetype.SysFont("Tahoma", 30)
    small_font = pygame.freetype.SysFont("Tahoma", 20)
except:
    font = pygame.freetype.SysFont(None, 30)
    small_font = pygame.freetype.SysFont(None, 20)

# ==================== 3. โหลดเสียงพิมพ์ดีด ====================
# วิธีใช้: วางไฟล์เสียงชื่อ typewriter.wav หรือ click.wav ไว้ในโฟลเดอร์เดียวกับสคริปต์
type_sound = None
sound_files = ["typewriter.wav", "click.wav", "keypress.wav", "type.ogg"]

for sound_file in sound_files:
    if os.path.exists(sound_file):
        try:
            type_sound = pygame.mixer.Sound(sound_file)
            type_sound.set_volume(0.4)
            print(f"โหลดเสียงสำเร็จ: {sound_file}")
            break
        except:
            pass

if type_sound is None:
    print("ไม่พบไฟล์เสียง → จะทำงานแบบไม่มีเสียง (สามารถเพิ่มไฟล์ .wav ได้ภายหลัง)")

# ==================== 4. ข้อความ ====================
full_text = (
    "สวัสดีครับ นี่คือระบบพิมพ์ทีละตัวอักษรขั้นสูงด้วย Pygame "
    "มีทั้งเคอร์เซอร์กระพริบและเสียงพิมพ์ดีด "
    "คุณสามารถกด Space เพื่อข้าม หรือกด R เพื่อเริ่มใหม่ได้ตลอดเวลา"
)

# ==================== 5. ตัวแปรควบคุม ====================
displayed_text = ""
char_index = 0
typing_speed = 45                # มิลลิวินาทีต่อตัวอักษร
last_char_time = pygame.time.get_ticks()
finished = False

# เคอร์เซอร์กระพริบ
cursor_visible = True
cursor_timer = 0
cursor_blink_speed = 500         # กระพริบทุก 0.5 วินาที

# ==================== 6. ฟังก์ชันช่วย ====================
def wrap_text(text, font, max_width):
    words = text.split(" ")
    lines = []
    current_line = ""

    for word in words:
        test = current_line + (" " if current_line else "") + word
        if font.get_rect(test).width <= max_width:
            current_line = test
        else:
            if current_line:
                lines.append(current_line)
            current_line = word
    if current_line:
        lines.append(current_line)
    return lines


def draw_typewriter(surface, text, font, color, y_start, max_width=750, show_cursor=False):
    lines = wrap_text(text, font, max_width)
    y = y_start

    for i, line in enumerate(lines):
        rect = font.get_rect(line)
        x = (WIDTH - rect.width) // 2
        font.render_to(surface, (x, y), line, color)

        # วาดเคอร์เซอร์ที่ท้ายบรรทัดสุดท้าย
        if show_cursor and i == len(lines) - 1 and cursor_visible:
            cursor_x = x + rect.width + 4
            font.render_to(surface, (cursor_x, y), "|", CYAN)

        y += rect.height + 14
    return y


def reset_typewriter():
    global displayed_text, char_index, finished, last_char_time, cursor_visible
    displayed_text = ""
    char_index = 0
    finished = False
    last_char_time = pygame.time.get_ticks()
    cursor_visible = True


# ==================== 7. เกมลูปหลัก ====================
clock = pygame.time.Clock()
running = True

while running:
    dt = clock.tick(60)
    now = pygame.time.get_ticks()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_ESCAPE:
                running = False

            elif event.key == pygame.K_SPACE:
                if not finished:
                    # ข้ามไปจบเลย
                    displayed_text = full_text
                    char_index = len(full_text)
                    finished = True
                else:
                    reset_typewriter()

            elif event.key == pygame.K_r:
                reset_typewriter()

            elif event.key == pygame.K_UP:
                typing_speed = max(15, typing_speed - 10)
            elif event.key == pygame.K_DOWN:
                typing_speed = min(150, typing_speed + 10)

    # ----- Typewriter Logic -----
    if not finished and now - last_char_time >= typing_speed:
        if char_index < len(full_text):
            displayed_text += full_text[char_index]
            char_index += 1
            last_char_time = now

            # เล่นเสียงพิมพ์ดีด (ไม่เล่นตอนเจอช่องว่าง)
            if type_sound and full_text[char_index - 1] not in (" ", "\n"):
                type_sound.play()
        else:
            finished = True

    # ----- เคอร์เซอร์กระพริบ -----
    cursor_timer += dt
    if cursor_timer >= cursor_blink_speed:
        cursor_visible = not cursor_visible
        cursor_timer = 0

    # ----- วาด -----
    screen.fill(BLACK)

    # หัวข้อ
    title = "ระบบพิมพ์ทีละตัวอักษร + เคอร์เซอร์ + เสียง"
    title_rect = font.get_rect(title)
    font.render_to(screen, ((WIDTH - title_rect.width) // 2, 50), title, YELLOW)

    # กล่องข้อความ
    pygame.draw.rect(screen, DARK_GRAY, (60, 130, WIDTH - 120, 320), border_radius=12)
    pygame.draw.rect(screen, (70, 70, 90), (60, 130, WIDTH - 120, 320), width=2, border_radius=12)

    # ข้อความที่กำลังพิมพ์
    draw_typewriter(
        screen,
        displayed_text,
        font,
        WHITE,
        y_start=160,
        max_width=740,
        show_cursor=not finished
    )

    # สถานะด้านล่าง
    if finished:
        status = "พิมพ์เสร็จแล้ว"
        status_color = CYAN
    else:
        status = f"กำลังพิมพ์...  ความเร็ว {typing_speed}ms"
        status_color = GRAY

    status_rect = small_font.get_rect(status)
    small_font.render_to(screen, ((WIDTH - status_rect.width) // 2, HEIGHT - 70), status, status_color)

    # คำแนะนำปุ่ม
    help_text = "SPACE = ข้าม/เริ่มใหม่   |   R = รีเซ็ต   |   ↑↓ = ปรับความเร็ว   |   ESC = ออก"
    help_rect = small_font.get_rect(help_text)
    small_font.render_to(screen, ((WIDTH - help_rect.width) // 2, HEIGHT - 35), help_text, GRAY)

    pygame.display.flip()

pygame.quit()
sys.exit()
```

### สิ่งที่เพิ่มเข้ามาในเวอร์ชันนี้

| ฟีเจอร์ | รายละเอียด |
|--------|-----------|
| **เคอร์เซอร์กระพริบ** | แสดง `|` สีฟ้า กระพริบทุก 0.5 วินาที ตอนยังพิมพ์ไม่จบ |
| **เสียงพิมพ์ดีด** | เล่นเสียงทุกครั้งที่พิมพ์ตัวอักษร (ไม่เล่นตอนช่องว่าง) |
| **ปรับความเร็วได้** | กด ↑ / ↓ เพื่อเปลี่ยนความเร็วขณะรัน |
| **ปุ่มควบคุม** | `SPACE` ข้ามหรือเริ่มใหม่, `R` รีเซ็ต |
| **กล่องข้อความ** | มีกรอบสวยขึ้น |

---

### วิธีใส่เสียงพิมพ์ดีด

1. หาไฟล์เสียงสั้น ๆ (แนะนำ `.wav` หรือ `.ogg`) เช่น:
   - `typewriter.wav`
   - `keypress.wav`
2. วางไฟล์ไว้โฟลเดอร์เดียวกับสคริปต์
3. โปรแกรมจะโหลดให้อัตโนมัติ

---

### สิ่งที่สามารถขยายต่อได้อีก (แนะนำ)

| ระดับ | ไอเดีย | ความยาก |
|------|--------|--------|
| ง่าย | เปลี่ยนสีข้อความทีละตัว / ใส่เงา | ⭐ |
| ปานกลาง | พิมพ์ทีละคำแทนทีละตัว | ⭐⭐ |
| ปานกลาง | มีหลายย่อหน้า เลื่อนขึ้นอัตโนมัติ (เหมือนเกม RPG) | ⭐⭐ |
| ยาก | รองรับการเลือกตัวเลือก (เช่นเกม Visual Novel) | ⭐⭐⭐ |
| ยาก | บันทึกประวัติการสนทนา + เลื่อนดูย้อนหลัง | ⭐⭐⭐ |
| ขั้นสูง | ใช้ฟอนต์หลายตัว + อิโมจิ + markdown ง่าย ๆ | ⭐⭐⭐⭐ |

---

อยากให้ทำเวอร์ชันไหนต่อดีครับ?

1. **แบบ Visual Novel** (มีตัวละคร + กล่องข้อความด้านล่าง)
2. **พิมพ์ทีละคำ** แทนทีละตัว
3. **ระบบหลายย่อหน้า** เลื่อนขึ้นอัตโนมัติ
4. หรืออย่างอื่นที่คุณคิดไว้
https://grok.com/share/c2hhcmQtMg_0a34c6f6-56ee-4bbc-ba23-432648c9391a
**Best Practices** สำหรับระบบ Typewriter Effect + ข้อความภาษาไทยใน Pygame

### 1. การจัดการฟอนต์ (สำคัญมากสำหรับภาษาไทย)

```python
# แนะนำให้โหลดฟอนต์แค่ครั้งเดียวตอนเริ่มต้น
font_cache = {}

def get_font(size, bold=False):
    key = (size, bold)
    if key not in font_cache:
        try:
            font_cache[key] = pygame.freetype.Font("fonts/THSarabunNew.ttf", size)
        except:
            font_cache[key] = pygame.freetype.SysFont("Tahoma", size)
        font_cache[key].strong = bold
    return font_cache[key]
```

**ทำไมต้องทำแบบนี้?**
- โหลดฟอนต์ซ้ำทุกเฟรม = ช้ามาก
- ภาษาไทยต้องใช้ฟอนต์ที่รองรับ OpenType / ครบ glyph

---

### 2. โครงสร้าง Typewriter แบบ Class (Best Practice)

อย่าเขียน logic ยาวใน game loop ให้แยกเป็นคลาส

```python
class Typewriter:
    def __init__(self, text, font, speed=40, sound=None):
        self.full_text = text
        self.font = font
        self.speed = speed
        self.sound = sound
        
        self.displayed = ""
        self.index = 0
        self.finished = False
        self.last_time = pygame.time.get_ticks()
        
        # Cursor
        self.cursor_visible = True
        self.cursor_timer = 0
        self.blink_speed = 500

    def update(self, dt):
        now = pygame.time.get_ticks()
        
        # พิมพ์ตัวอักษร
        if not self.finished and now - self.last_time >= self.speed:
            if self.index < len(self.full_text):
                char = self.full_text[self.index]
                self.displayed += char
                self.index += 1
                self.last_time = now
                
                # เล่นเสียงเฉพาะตัวอักษรจริง
                if self.sound and char not in (" ", "\n", "\t"):
                    self.sound.play()
            else:
                self.finished = True

        # กระพริบเคอร์เซอร์
        self.cursor_timer += dt
        if self.cursor_timer >= self.blink_speed:
            self.cursor_visible = not self.cursor_visible
            self.cursor_timer = 0

    def skip(self):
        self.displayed = self.full_text
        self.index = len(self.full_text)
        self.finished = True

    def reset(self, new_text=None):
        if new_text:
            self.full_text = new_text
        self.displayed = ""
        self.index = 0
        self.finished = False
        self.last_time = pygame.time.get_ticks()
        self.cursor_visible = True

    def draw(self, surface, pos, color=(255, 255, 255), max_width=700):
        # วาดข้อความ + เคอร์เซอร์
        ...
```

**ข้อดีของการใช้ Class**
- ใช้ซ้ำได้หลายกล่องข้อความ
- จัดการ state ง่าย
- ทดสอบและแก้บั๊กง่ายกว่า

---

### 3. Best Practice อื่น ๆ ที่ควรทำ

| หัวข้อ | แนะนำ | เหตุผล |
|--------|------|--------|
| **Sound** | ใช้เสียงสั้นมาก (10-30ms) และ `set_volume(0.3-0.5)` | เสียงยาวหรือดังเกินจะรำคาญ |
| **Speed** | 35-55ms ต่อตัวอักษร | เร็วเกินไปอ่านไม่ทัน ช้าเกินไปน่าเบื่อ |
| **Skip** | กด Space / Enter / คลิก = ข้ามได้เสมอ | ผู้เล่นส่วนใหญ่ต้องการข้าม |
| **Cursor** | แสดงเฉพาะตอนยังพิมพ์ไม่จบ | จบแล้วไม่ต้องมีเคอร์เซอร์ |
| **Text Wrap** | ตัดตามคำ + รองรับ `\n` | ภาษาไทยไม่มีช่องว่างทุกคำ ต้องระวัง |
| **Delta Time** | ใช้ `dt` จาก `clock.tick()` | ทำให้ความเร็วคงที่ทุกเครื่อง |
| **Font Size** | อย่าใช้ขนาดเล็กกว่า 22px กับภาษาไทย | อ่านยากมาก |
| **Color Contrast** | ตัวอักษรสว่างบนพื้นมืด (หรือกลับกัน) | อ่านสบายตา |

---

### 4. สิ่งที่ควรหลีกเลี่ยง

- โหลดฟอนต์ใหม่ทุกเฟรม
- เล่นเสียงทุกช่องว่าง
- ใช้ `pygame.font` แทน `pygame.freetype` กับภาษาไทย (รองรับน้อยกว่า)
- เขียน logic ทั้งหมดใน `while` loop โดยไม่แยกฟังก์ชัน/คลาส
- ลืมจัดการกรณีข้อความว่างหรือสั้นมาก

---

### 5. โครงสร้างโปรเจกต์ที่แนะนำ

```
project/
├── main.py
├── systems/
│   └── typewriter.py      ← Class Typewriter
├── fonts/
│   ├── THSarabunNew.ttf
│   └── NotoSansThai.ttf
├── sounds/
│   └── typewriter.wav
└── assets/
```

---

### สรุป Best Practice สั้น ๆ

1. **แยก Class** สำหรับ Typewriter
2. **Cache ฟอนต์**
3. **มีปุ่ม Skip เสมอ**
4. **ใช้ delta time**
5. **เสียงสั้น + ไม่ดังเกิน**
6. **เคอร์เซอร์แสดงเฉพาะตอนพิมพ์**
7. **รองรับการรีเซ็ตและเปลี่ยนข้อความกลางทาง**

---

ต้องการให้ผมเขียน **เวอร์ชัน Best Practice เต็มรูปแบบ** (เป็น Class สมบูรณ์ + ตัวอย่างการใช้งาน) เลยไหมครับ?