Игра «Поросенок Петр» на Delphi 7 без VCL

Код (Text):

1.  
2. > strings ./mc | grep CFLAGS
3. ... CFLAGS=-g -O2 -fPIE -fstack-protector-strong -Wformat -Werror=format-security' 'LDFLAGS=-Wl,-Bsymbolic-functions -fPIE -pie -Wl,-z,relro -Wl,-z,now -Wl,--as-needed ...
4.  

Я не гарантирую, что это именно его CFLAGS, а не какой-то статически слинкованной с ним чуши, но всё же.

Я тебе уже ни раз говорил, что не надо поддаваться предвзятости подтверждения. Ну и не надо пытаться многозначительно обобщать с одного примера.

 

Сколько примеров тебе надо?

 

Допустим существует всего X программ, сколько примеров "-О0" нужно, чтобы уверенно говорить, что большинство использует "-О0"? Для "доказательного обгуанивания" достаточно собрать выборку из парочки якобы подтверждающих утверждение примеров и игнорировать X-2 остальных.

 

Вовремя я успел скачать 2000 строк кода. Спасибо!
Можно попробовать в x64-битном формате скомпилировать и ASM-code сгенерировать.

P.S. Проверил EXE-файл, который прилагался к коду - он x64-битный.

 

GRAFik, вчера мысль возникла - сделать отдельный редактор уровней для игры как игру minecraft.

Выбираешь текстуры для карты, строишь, потом сохраняешь все в файл.
Далее загружаешь карту уровня в игре со всеми обьектами из этого файла.

unreal engine на минималках )

 

Ну хорошая идея. А я ещё на Питоновском варианте обратил внимание, что будет много уровней (семь вроде). Блин, с кем поведешься... С вами точно геймером-программистом станешь. Мне уже понравилось...

 

Оказывается из кс 1.6 можно декомпилировать модели и потом загружать их с помощью python в 3d.
Не нужно ничего рисовать. Модели это имхо самая сложная часть игры.

 

Таким образом сколько бы примеров я ни привел, ты просто подставишь в формулу X-N их количество и заявишь, что X это большущий гориллиард, а N многократно меньше и ничего не доказывает. На -o0 я не настаиваю, вообще с легкостью готов признать, что в ряде случаев это -o2, просто хреновое -o2.

 

Загружаем модель из cs 1.6. Не думал что получится...

 

Не знаю у кого как, но у меня на Питоне, вроде, всё работает правильно.

Когда ждать полную версию ?

 

Спасибо за тест. С этими моделями довольно сложная история.
У них там вводится понятие скелета(кости) и все текстуры двигаются за костями.

Даже у автоматов есть кости )



Нужно собирать отдельный проект в нем тестировать бег, стрельбу и т.д.
Вводить дополнительную структуру для бота и менять в ней состояние полей.

Всему свое время. Скоро добавлю звуки в игру (самое легкое для добавления).

 

Немного побаловался, поэксперементировал.

 

# Углы вращения модели и дистанция камеры
angle_y = 0.0
angle_x = 0.0
distance = 30.0 <--- збс

А я чото такими вещами упоролся, можно в начале сделать бегающих по карте скелетов:

Код (Python):

1. import pygame, math, sys
2.  
3. # ---------- КЛАСС КОСТИ ----------
4. class Bone:
5.     def __init__(self, length, angle=0, parent=None):
6.         self.length = length    # длина кости (в пикселях)
7.         self.angle = angle      # угол относительно родителя (в радианах)
8.         self.parent = parent    # ссылка на родительскую кость
9.         self.x = self.y = 0     # позиция (будет вычислена)
10.  
11.     def get_endpoint(self):
12.         """Возвращает (x, y) конечной точки кости"""
13.         rad = self.get_global_angle()
14.         return (self.x + self.length * math.cos(rad),
15.                 self.y + self.length * math.sin(rad))
16.  
17.     def get_global_angle(self):
18.         """Суммирует углы всех родителей (абсолютный угол)"""
19.         if self.parent:
20.             return self.parent.get_global_angle() + self.angle
21.         return self.angle
22.  
23.     def update_position(self, start_x, start_y):
24.         """Рекурсивно обновляет позиции всех дочерних костей"""
25.         self.x, self.y = start_x, start_y
26.         end_x, end_y = self.get_endpoint()
27.         for child in children:  # упрощённо: ищем детей
28.             if child.parent is self:
29.                 child.update_position(end_x, end_y)
30.  
31. # ---------- СОЗДАЁМ СКЕЛЕТ ----------
32. shoulder = Bone(100, 0)          # плечо (угол 0°)
33. elbow = Bone(80, math.radians(45), shoulder)  # локоть (согнут на 45°)
34. children = [shoulder, elbow]     # список всех костей
35.  
36. # ---------- ИНИЦИАЛИЗАЦИЯ PYGAME ----------
37. pygame.init()
38. screen = pygame.display.set_mode((600, 400))
39. clock = pygame.time.Clock()
40.  
41. # ---------- ГЛАВНЫЙ ЦИКЛ ----------
42. while True:
43.     for event in pygame.event.get():
44.         if event.type == pygame.QUIT: sys.exit()
45.  
46.     # Управление: вращаем плечо мышкой
47.     mouse_x, mouse_y = pygame.mouse.get_pos()
48.     shoulder.angle = math.atan2(mouse_y - 200, mouse_x - 100)  # отсчёт от базы
49.  
50.     # Обновляем позиции (база в точке (100, 200))
51.     shoulder.update_position(100, 200)
52.  
53.     # Рисуем
54.     screen.fill((30, 30, 30))
55.  
56.     # Рисуем все кости
57.     for bone in children:
58.         end = bone.get_endpoint()
59.         pygame.draw.line(screen, (0, 255, 200), (bone.x, bone.y), end, 5)
60.         pygame.draw.circle(screen, (255, 100, 100), (int(bone.x), int(bone.y)), 6)
61.  
62.     pygame.display.flip()
63.     clock.tick(60)

Мне иногда кажется все эти координаты точек можно из python конвертировать
при помощи llm в какой-то свой более легкий и понятный формат =)

--- Сообщение объединено, 23 июн 2026 в 05:36 ---

*при помощи подсказок llm

 

Продолжаем баловаться...

Код (Python):

1.  
2. #  PYTHON 3.11  
3. #  Skeletal Walking Leg Demo
4.  
5. import pygame
6. import math
7. import sys
8.  
9. # ---------- КЛАСС КОСТИ (Усовершенствованный) ----------
10. class Bone:
11.     def __init__(self, length, angle=0, parent=None):
12.         self.length = length    # длина кости (в пикселях)
13.         self.angle = angle      # угол относительно родителя (в радианах)
14.         self.parent = parent    # ссылка на родительскую кость
15.         self.x = self.y = 0     # позиция старта кости (вычисляется)
16.     def get_endpoint(self):
17.         """Возвращает (x, y) конечной точки кости"""
18.         rad = self.get_global_angle()
19.         return (self.x + self.length * math.cos(rad),
20.                 self.y + self.length * math.sin(rad))
21.     def get_global_angle(self):
22.         """Суммирует углы всех родителей (абсолютный угол в пространстве)"""
23.         if self.parent:
24.             return self.parent.get_global_angle() + self.angle
25.         return self.angle
26.     def update_position(self, start_x, start_y, all_bones):
27.         """ Рекурсивно обновляет позиции этой кости и всех её "детей" """
28.         self.x, self.y = start_x, start_y
29.         end_x, end_y = self.get_endpoint()
30.        
31.         # Ищем «детей» этой кости в общем списке и обновляем их
32.         for child in all_bones:
33.             if child.parent is self:
34.                 child.update_position(end_x, end_y, all_bones)
35.  
36. # ---------- ИНИЦИАЛИЗАЦИЯ PYGAME ----------
37. pygame.init()
38. SCREEN_WIDTH = 800
39. SCREEN_HEIGHT = 500
40. screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
41. pygame.display.set_caption("Skeletal Walking Leg Demo")
42. clock = pygame.time.Clock()
43. font = pygame.font.Font(None, 24)
44.  
45. # ---------- СОЗДАЁМ ИЕРАРХИЮ НОГИ ----------
46. # Точка крепления (таз) будет находиться в центре экрана
47. LEG_BASE_X = SCREEN_WIDTH // 2
48. LEG_BASE_Y = SCREEN_HEIGHT // 2 - 50
49.  
50. # Создаем кости: Бедро -> Колено -> Стопа
51. hip = Bone(length=90, angle=math.radians(90))  # Направлено изначально вниз
52. knee = Bone(length=80, angle=math.radians(30), parent=hip)
53. foot = Bone(length=40, angle=math.radians(-30), parent=knee)
54.  
55. # Общий список костей для удобного пересчета и отрисовки
56. bones_list = [hip, knee, foot]
57.  
58. # ---------- ГЛАВНЫЙ ЦИКЛ ----------
59. running = True
60. while running:
61.     for event in pygame.event.get():
62.         if event.type == pygame.QUIT:
63.             running = False
64.             pygame.quit()
65.             sys.exit()
66.  
67.     # ВРЕМЯ ДЛЯ АНИМАЦИИ (переводим миллисекунды в секунды для плавности)
68.     time_seconds = pygame.time.get_ticks() / 1000.0
69.    
70.     # СКОРОСТЬ ХОДЬБЫ
71.     walk_speed = 4.0
72.    
73.     # --- БИОМЕХАНИКА ШАГА (Формулы синуса) ---
74.     # 1. Бедро качается вперед-назад вокруг центральной оси (90 градусов)
75.     hip.angle = math.radians(90) + math.sin(time_seconds * walk_speed) * math.radians(25)
76.    
77.     # 2. Колено сгибается только тогда, когда нога уходит назад (создаем естественность)
78.     # Наш синус смещен, чтобы колено реалистично поджималось при подъёме ноги
79.     knee.angle = math.radians(40) + math.sin(time_seconds * walk_speed - 1.0) * math.radians(30)
80.    
81.     # 3. Стопа слегка покачивается, чтобы пружинить при «наступании» на воображаемую землю
82.     foot.angle = math.radians(-20) + math.cos(time_seconds * walk_speed) * math.radians(15)
83.  
84.     # ОБНОВЛЯЕМ ПОЗИЦИИ ВСЕХ СУСТАВОВ (эффект домино от таза к стопе)
85.     hip.update_position(LEG_BASE_X, LEG_BASE_Y, bones_list)
86.  
87.     # --- ОТРИСОВКА ОКРУЖЕНИЯ ---
88.     screen.fill((25, 25, 35)) # Красивый темно-синий фон
89.  
90.     # Рисуем линию «земли», чтобы было видно, как нога шагает по ней
91.     pygame.draw.line(screen, (70, 70, 80), (0, LEG_BASE_Y + 160), (SCREEN_WIDTH, LEG_BASE_Y + 160), 2)
92.  
93.     # Рисуем кости и суставы
94.     for bone in bones_list:
95.         end_point = bone.get_endpoint()
96.        
97.         # Рисуем саму кость (бирюзовая толстая линия)
98.         pygame.draw.line(screen, (0, 210, 255), (bone.x, bone.y), end_point, 8)
99.        
100.         # Рисуем сустав-шарнир (розовый круг в основании кости)
101.         pygame.draw.circle(screen, (255, 90, 120), (int(bone.x), int(bone.y)), 7)
102.        
103.         # Рисуем кончик последней кости (носок стопы)
104.         if bone is foot:
105.             pygame.draw.circle(screen, (255, 90, 120), (int(end_point[0]), int(end_point[1])), 5)
106.  
107.     # Информационный текст на экране
108.     info_text = font.render("Усовершенствованный демо-скелет: Шагающая нога (Бедро -> Колено -> Стопа)", True, (200, 200, 200))
109.     screen.blit(info_text, (15, 15))
110.  
111.     pygame.display.flip()
112.     clock.tick(60)
113.  

 

Версия игры со звуком. Перевел винапи на python, есть глюки (игрока начинает заносить).



Наткнулся на интересный проект игры minecraft в несколько строк на c++ (с исходниками).

 

Доведём ходьбу до логического конца, а то одна нога прям как у одноногого инвалида.

Код (Python):

1.  
2. import pygame
3. import math
4. import sys
5.  
6. # ---------- КЛАСС КОСТИ ----------
7. class Bone:
8.     def __init__(self, length, angle=0, parent=None):
9.         self.length = length    # длина кости (в пикселях)
10.         self.angle = angle      # угол относительно родителя (в радианах)
11.         self.parent = parent    # ссылка на родительскую кость
12.         self.x = self.y = 0     # позиция старта кости
13.     def get_endpoint(self):
14.         """Возвращает (x, y) конечной точки кости"""
15.         rad = self.get_global_angle()
16.         return (self.x + self.length * math.cos(rad),
17.                 self.y + self.length * math.sin(rad))
18.     def get_global_angle(self):
19.         """ Суммирует углы всех "родителей"  """
20.         if self.parent:
21.             return self.parent.get_global_angle() + self.angle
22.         return self.angle
23.     def update_position(self, start_x, start_y, all_bones):
24.         """Рекурсивно обновляет позиции этой кости и всех её  "детей"  """
25.         self.x, self.y = start_x, start_y
26.         end_x, end_y = self.get_endpoint()
27.        
28.         for child in all_bones:
29.             if child.parent is self:
30.                 child.update_position(end_x, end_y, all_bones)
31.  
32. # ---------- ИНИЦИАЛИЗАЦИЯ PYGAME ----------
33. pygame.init()
34. SCREEN_WIDTH = 800
35. SCREEN_HEIGHT = 500
36. screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
37. pygame.display.set_caption("CS 1.6 Style Two-Legged Walking Demo")
38. clock = pygame.time.Clock()
39. font = pygame.font.Font(None, 24)
40.  
41. # Точка таза (центр)
42. LEG_BASE_X = SCREEN_WIDTH // 2
43. LEG_BASE_Y = SCREEN_HEIGHT // 2 - 50
44.  
45. # ---------- СОЗДАЕМ ДВЕ НОГИ ----------
46. # ПРАВАЯ НОГА
47. r_hip = Bone(90, math.radians(90))
48. r_knee = Bone(80, math.radians(30), parent=r_hip)
49. r_foot = Bone(40, math.radians(-30), parent=r_knee)
50.  
51. # ЛЕВАЯ НОГА
52. l_hip = Bone(90, math.radians(90))
53. l_knee = Bone(80, math.radians(30), parent=l_hip)
54. l_foot = Bone(40, math.radians(-30), parent=l_knee)
55.  
56. # Объединяем все кости в один список
57. bones_list = [r_hip, r_knee, r_foot, l_hip, l_knee, l_foot]
58.  
59. # ---------- ГЛАВНЫЙ ЦИКЛ ----------
60. running = True
61. while running:
62.     for event in pygame.event.get():
63.         if event.type == pygame.QUIT:
64.             running = False
65.  
66.     # Время анимации
67.     time_seconds = pygame.time.get_ticks() / 1000.0
68.     walk_speed = 4.0
69.    
70.     # Текущая фаза движения для ПРАВОЙ ноги
71.     phase_right = time_seconds * walk_speed
72.    
73.     # Сдвигаем фазу ЛЕВОЙ ноги ровно на половину цикла (плюс Пи радиан)
74.     phase_left = time_seconds * walk_speed + math.pi
75.  
76.     # --- УПРАВЛЕНИЕ ПРАВОЙ НОГОЙ ---
77.     r_hip.angle = math.radians(90) + math.sin(phase_right) * math.radians(25)
78.     r_knee.angle = math.radians(40) + math.sin(phase_right - 1.0) * math.radians(30)
79.     r_foot.angle = math.radians(-20) + math.cos(phase_right) * math.radians(15)
80.  
81.     # --- УПРАВЛЕНИЕ ЛЕВОЙ НОГОЙ ---
82.     l_hip.angle = math.radians(90) + math.sin(phase_left) * math.radians(25)
83.     l_knee.angle = math.radians(40) + math.sin(phase_left - 1.0) * math.radians(30)
84.     l_foot.angle = math.radians(-20) + math.cos(phase_left) * math.radians(15)
85.  
86.     # Обновляем позиции обеих ног
87.     r_hip.update_position(LEG_BASE_X, LEG_BASE_Y, bones_list)
88.     l_hip.update_position(LEG_BASE_X, LEG_BASE_Y, bones_list)
89.  
90.     # --- ОТРИСОВКА ---
91.     screen.fill((25, 25, 35))
92.  
93.     # Земля
94.     pygame.draw.line(screen, (70, 70, 80), (0, LEG_BASE_Y + 160), (SCREEN_WIDTH, LEG_BASE_Y + 160), 2)
95.  
96.     # Рисуем кости
97.     for bone in bones_list:
98.         end_point = bone.get_endpoint()
99.        
100.         # Визуально разделяем ноги (левая темнее)
101.         if bone in [l_hip, l_knee, l_foot]:
102.             color_bone = (0, 140, 180)     # Темно-бирюзовый
103.             color_joint = (180, 50, 80)    # Бордовый
104.         else:
105.             color_bone = (0, 210, 255)     # Ярко-бирюзовый
106.             color_joint = (255, 90, 120)   # Розовый
107.            
108.         pygame.draw.line(screen, color_bone, (bone.x, bone.y), end_point, 8)
109.         pygame.draw.circle(screen, color_joint, (int(bone.x), int(bone.y)), 7)
110.        
111.         # Исправленный блок отрисовки носков стопы
112.         if bone in [r_foot, l_foot]:
113.             feat_x = int(end_point[0])
114.             feat_y = int(end_point[1])
115.             pygame.draw.circle(screen, color_joint, (feat_x, feat_y), 5)
116.  
117.     info_text = font.render("Синхронизированный шаг двух ног (Сдвиг фазы на математический Pi)", True, (200, 200, 200))
118.     screen.blit(info_text, (15, 15))
119.  
120.     pygame.display.flip()
121.     clock.tick(60)
122.  
123. pygame.quit()
124. sys.exit()
125.