The Engines Update is being worked. It will retain the same functionality with better UI.

 https://itch.io/t/4514927/3d-game-with-pyopengl-tutorial

Creating a 3D Game with PyOpenGL

Step 1: Install Required Libraries

Before starting, make sure you have PyGame and PyOpenGL installed. These libraries will assist with window management and rendering 3D objects.

Run the following command in your terminal or command prompt to install the required libraries:

pip install pygame PyOpenGL

Step 2: Folder Structure

Here is the folder structure for your game project:

3d_game/

│

├── assets/              # For storing textures, models, sounds

│

├── src/                 # Source code for the game

│   ├── main.py          # Main game loop

│   ├── engine.py        # Contains camera and movement logic

│   ├── player.py        # Handles user input (WASD, mouse)

│   └── physics.py       # Handles physics (e.g., preventing falling)

│

└── README.md            # Game info (optional)

Step 3: engine.py - Setting Up OpenGL and Camera

In this file, we’ll set up OpenGL, initialize the camera, and handle basic camera movements.

import pygame

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

# Window settings

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT), DOUBLEBUF | OPENGL)

# Camera settings

camera_pos = [0, 0, -5]  # Camera's position in 3D space (x, y, z)

camera_angle = [0, 0]    # Camera's angle (yaw, pitch)

# Initialize OpenGL and set up the camera

def init_camera():

    glMatrixMode(GL_PROJECTION)

    glLoadIdentity()

    gluPerspective(45, (WIDTH / HEIGHT), 0.1, 50.0)  # Perspective projection

    glTranslatef(camera_pos[0], camera_pos[1], camera_pos[2])  # Position the camera

def update_camera():

    glRotatef(camera_angle[0], 1, 0, 0)  # Rotate around X-axis (pitch)

    glRotatef(camera_angle[1], 0, 1, 0)  # Rotate around Y-axis (yaw)

# Handle keyboard input for movement (WASD keys)

def handle_keys():

    global camera_pos

    keys = pygame.key.get_pressed()

    # Move forward, backward, left, right

    if keys[pygame.K_w]:

        camera_pos[2] += 0.1  # Move forward

    if keys[pygame.K_s]:

        camera_pos[2] -= 0.1  # Move backward

    if keys[pygame.K_a]:

        camera_pos[0] += 0.1  # Move left

    if keys[pygame.K_d]:

        camera_pos[0] -= 0.1  # Move right

Step 4: player.py - Handling Mouse Look

This file handles mouse movement for looking around.

import pygame

from engine import camera_pos, camera_angle

# Mouse sensitivity for camera rotation

MOUSE_SENSITIVITY = 0.1

def handle_mouse():

    global camera_angle

    mouse_x, mouse_y = pygame.mouse.get_pos()

    # Calculate the movement of the mouse from the center

    delta_x = mouse_x - (WIDTH // 2)

    delta_y = mouse_y - (HEIGHT // 2)

    # Update camera angles (yaw and pitch)

    camera_angle[1] += delta_x * MOUSE_SENSITIVITY  # Rotate left/right (yaw)

    camera_angle[0] -= delta_y * MOUSE_SENSITIVITY  # Rotate up/down (pitch)

    # Restrict pitch angle (up/down) to prevent flipping

    if camera_angle[0] > 90:

        camera_angle[0] = 90

    if camera_angle[0] < -90:

        camera_angle[0] = -90

    # Center the mouse in the window

    pygame.mouse.set_pos(WIDTH // 2, HEIGHT // 2)

def update():

    handle_mouse()  # Control camera with mouse

    handle_keys()   # Control movement with WASD

Step 5: physics.py - Basic Physics  (Collision)

This file ensures the player doesn’t fall through the ground.

# Simple collision check for the ground

def check_collision(player_pos, ground_level=0):

    if player_pos[1] < ground_level:

        player_pos[1] = ground_level  # Prevent player from falling below ground

Step 6: main.py - The Main Game Loop

This is where everything comes together: initializing the game, running the game loop, and rendering objects.

import pygame

from engine import init_camera, update_camera

from player import update

from physics import check_collision

# Window settings

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT), DOUBLEBUF | OPENGL)

# Game loop

def game_loop():

    clock = pygame.time.Clock()

    running = True

    while running:

        for event in pygame.event.get():

            if event.type == pygame.QUIT:

                running = False

        # Clear the screen before drawing

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # Initialize the camera

        init_camera()

        # Update the player input (movement, mouse look)

        update()

        # Basic collision (prevent falling through the ground)

        check_collision(camera_pos)

        # Draw a rotating cube (just an example)

        draw_cube()

        # Update the display

        pygame.display.flip()

        # Control the frame rate

        clock.tick(60)

    pygame.quit()

# Function to draw a simple cube

def draw_cube():

    vertices = [

        (1, -1, -1), (1, 1, -1), (-1, 1, -1), (-1, -1, -1),

        (1, -1, 1), (1, 1, 1), (-1, -1, 1), (-1, 1, 1)

    ]

    edges = [

        (0, 1), (1, 2), (2, 3), (3, 0),

        (4, 5), (5, 6), (6, 7), (7, 4),

        (0, 4), (1, 5), (2, 6), (3, 7)

    ]

    glBegin(GL_LINES)

    for edge in edges:

        for vertex in edge:

            glVertex3fv(vertices[vertex])

    glEnd()

# Run the game

if __name__ == "__main__":

    pygame.mouse.set_visible(False)  # Hide the mouse cursor

    pygame.mouse.set_pos(WIDTH // 2, HEIGHT // 2)  # Center the mouse

    game_loop()

was to be named 3d PyOpenGL Tutorial

Creating a 3D Game with PyOpenGL

Step 1: Install Required Libraries

Before starting, make sure you have PyGame and PyOpenGL installed. These libraries will assist with window management and rendering 3D objects.

Run the following command in your terminal or command prompt to install the required libraries:

pip install pygame PyOpenGL

Step 2: Folder Structure

Here is the folder structure for your game project:

3d_game/

│

├── assets/              # For storing textures, models, sounds

│

├── src/                 # Source code for the game

│   ├── main.py          # Main game loop

│   ├── engine.py        # Contains camera and movement logic

│   ├── player.py        # Handles user input (WASD, mouse)

│   └── physics.py       # Handles physics (e.g., preventing falling)

│

└── README.md            # Game info (optional)

Step 3: engine.py - Setting Up OpenGL and Camera

In this file, we’ll set up OpenGL, initialize the camera, and handle basic camera movements.

import pygame

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import math

# Window settings

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT), DOUBLEBUF | OPENGL)

# Camera settings

camera_pos = [0, 0, -5]  # Camera's position in 3D space (x, y, z)

camera_angle = [0, 0]    # Camera's angle (yaw, pitch)

# Initialize OpenGL and set up the camera

def init_camera():

    glMatrixMode(GL_PROJECTION)

    glLoadIdentity()

    gluPerspective(45, (WIDTH / HEIGHT), 0.1, 50.0)  # Perspective projection

    glTranslatef(camera_pos[0], camera_pos[1], camera_pos[2])  # Position the camera

def update_camera():

    glRotatef(camera_angle[0], 1, 0, 0)  # Rotate around X-axis (pitch)

    glRotatef(camera_angle[1], 0, 1, 0)  # Rotate around Y-axis (yaw)

# Handle keyboard input for movement (WASD keys)

def handle_keys():

    global camera_pos

    keys = pygame.key.get_pressed()

    # Move forward, backward, left, right

    if keys[pygame.K_w]:

        camera_pos[2] += 0.1  # Move forward

    if keys[pygame.K_s]:

        camera_pos[2] -= 0.1  # Move backward

    if keys[pygame.K_a]:

        camera_pos[0] += 0.1  # Move left

    if keys[pygame.K_d]:

        camera_pos[0] -= 0.1  # Move right

Step 4: player.py - Handling Mouse Look

This file handles mouse movement for looking around.

import pygame

from engine import camera_pos, camera_angle

# Mouse sensitivity for camera rotation

MOUSE_SENSITIVITY = 0.1

def handle_mouse():

    global camera_angle

    mouse_x, mouse_y = pygame.mouse.get_pos()

    # Calculate the movement of the mouse from the center

    delta_x = mouse_x - (WIDTH // 2)

    delta_y = mouse_y - (HEIGHT // 2)

    # Update camera angles (yaw and pitch)

    camera_angle[1] += delta_x * MOUSE_SENSITIVITY  # Rotate left/right (yaw)

    camera_angle[0] -= delta_y * MOUSE_SENSITIVITY  # Rotate up/down (pitch)

    # Restrict pitch angle (up/down) to prevent flipping

    if camera_angle[0] > 90:

        camera_angle[0] = 90

    if camera_angle[0] < -90:

        camera_angle[0] = -90

    # Center the mouse in the window

    pygame.mouse.set_pos(WIDTH // 2, HEIGHT // 2)

def update():

    handle_mouse()  # Control camera with mouse

    handle_keys()   # Control movement with WASD

Step 5: physics.py - Basic Physics  (Collision)

This file ensures the player doesn’t fall through the ground.

# Simple collision check for the ground

def check_collision(player_pos, ground_level=0):

    if player_pos[1] < ground_level:

        player_pos[1] = ground_level  # Prevent player from falling below ground

Step 6: main.py - The Main Game Loop

This is where everything comes together: initializing the game, running the game loop, and rendering objects.

import pygame

from engine import init_camera, update_camera

from player import update

from physics import check_collision

# Window settings

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT), DOUBLEBUF | OPENGL)

# Game loop

def game_loop():

    clock = pygame.time.Clock()

    running = True

    while running:

        for event in pygame.event.get():

            if event.type == pygame.QUIT:

                running = False

        # Clear the screen before drawing

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # Initialize the camera

        init_camera()

        # Update the player input (movement, mouse look)

        update()

        # Basic collision (prevent falling through the ground)

        check_collision(camera_pos)

        # Draw a rotating cube (just an example)

        draw_cube()

        # Update the display

        pygame.display.flip()

        # Control the frame rate

        clock.tick(60)

    pygame.quit()

# Function to draw a simple cube

def draw_cube():

    vertices = [

        (1, -1, -1), (1, 1, -1), (-1, 1, -1), (-1, -1, -1),

        (1, -1, 1), (1, 1, 1), (-1, -1, 1), (-1, 1, 1)

    ]

    edges = [

        (0, 1), (1, 2), (2, 3), (3, 0),

        (4, 5), (5, 6), (6, 7), (7, 4),

        (0, 4), (1, 5), (2, 6), (3, 7)

    ]

    glBegin(GL_LINES)

    for edge in edges:

        for vertex in edge:

            glVertex3fv(vertices[vertex])

    glEnd()

# Run the game

if __name__ == "__main__":

    pygame.mouse.set_visible(False)  # Hide the mouse cursor

    pygame.mouse.set_pos(WIDTH // 2, HEIGHT // 2)  # Center the mouse

    game_loop()

• Add 3D models: Use glBindTexture() to add textures to objects or load external models like .obj files.
• Advanced Physics: Integrate more realistic physics using libraries like PyBullet or Pymunk.
• Lighting: Use glEnable(GL_LIGHTING) and glLightfv() to add lighting effects to your scene.

bash

copyedit are just there to show you can copy

3d_game/

│

├── assets/              # For storing textures, models, sounds

│

├── src/                 # Source code for the game

│   ├── main.py          # Main game loop

│   ├── engine.py        # Contains camera and movement logic

│   ├── player.py        # Handles user input (WASD, mouse)

│   └── physics.py       # Handles physics (e.g., preventing falling)

│

└── README.md            # Game info (optional)

The symbols │, ├──, and similar lines in the folder structure are used to visually represent the hierarchy of directories and files. They are a way to show how folders and files are organized within a project. Here’s what each symbol means:

• │: This vertical line is used to continue the tree structure vertically, indicating that the items below it are part of the same hierarchy.
• ├──: This is used to show a branch in the tree. It means that there’s a file or folder at this level, and it might have subdirectories or files below it.
• └──: This symbol indicates the last item in a branch, showing the end of a directory or file path.

it may or may not be in the next update

i got you ill get you a linux dist

Tutorial: Creating a 3D Game with PyOpenGL

Step 1: Install Required Libraries

Before you begin, make sure you have PyGame and PyOpenGL installed. These libraries will help with window management and rendering 3D objects.

In your terminal or command prompt, run:

bash
CopyEdit
pip install pygame PyOpenGL 

Step 2: Basic Folder Structure

Here is the folder structure we'll use:

bash
CopyEdit
3d_game/ │ ├── assets/               # For storing any textures, models, sounds ├── src/                  # Source code for the game │   ├── main.py           # Main game loop │   ├── engine.py         # Contains camera and movement logic │   ├── player.py         # Handles user input (WASD, mouse) │   └── physics.py        # Handles physics, e.g., preventing falling └── README.md             # Game info (optional) 

Step 3: engine.py - Setting Up OpenGL and Camera

In this file, we’ll set up OpenGL, initialize the camera, and handle basic camera movement.

python
CopyEdit
import pygame from pygame.locals import * from OpenGL.GL import * from OpenGL.GLU import * import math  # Window settings WIDTH, HEIGHT = 800, 600 screen = pygame.display.set_mode((WIDTH, HEIGHT), DOUBLEBUF | OPENGL)  # Camera settings camera_pos = [0, 0, -5]  # Camera's position in 3D space (x, y, z) camera_angle = [0, 0]    # Camera's angle (yaw, pitch)  # Initialize OpenGL and set up the camera def init_camera():     glMatrixMode(GL_PROJECTION)     glLoadIdentity()     gluPerspective(45, (WIDTH / HEIGHT), 0.1, 50.0)  # Perspective projection     glTranslatef(camera_pos[0], camera_pos[1], camera_pos[2])  # Position the camera  def update_camera():     glRotatef(camera_angle[0], 1, 0, 0)  # Rotate around X-axis (pitch)     glRotatef(camera_angle[1], 0, 1, 0)  # Rotate around Y-axis (yaw)  # Handle keyboard input for movement (WASD keys) def handle_keys():     global camera_pos     keys = pygame.key.get_pressed()      # Move forward, backward, left, right     if keys[pygame.K_w]:         camera_pos[2] += 0.1  # Move forward     if keys[pygame.K_s]:         camera_pos[2] -= 0.1  # Move backward     if keys[pygame.K_a]:         camera_pos[0] += 0.1  # Move left     if keys[pygame.K_d]:         camera_pos[0] -= 0.1  # Move right 

Step 4: player.py - Handling Mouse Look

The player file will handle mouse movement for looking around.

python
CopyEdit
import pygame from engine import camera_pos, camera_angle  # Mouse sensitivity for camera rotation MOUSE_SENSITIVITY = 0.1  def handle_mouse():     global camera_angle     mouse_x, mouse_y = pygame.mouse.get_pos()      # Calculate the movement of the mouse from the center     delta_x = mouse_x - (WIDTH // 2)     delta_y = mouse_y - (HEIGHT // 2)      # Update camera angles (yaw and pitch)     camera_angle[1] += delta_x * MOUSE_SENSITIVITY  # Rotate left/right (yaw)     camera_angle[0] -= delta_y * MOUSE_SENSITIVITY  # Rotate up/down (pitch)      # Restrict pitch angle (up/down) to prevent flipping     if camera_angle[0] > 90:         camera_angle[0] = 90     if camera_angle[0] < -90:         camera_angle[0] = -90      # Center the mouse in the window     pygame.mouse.set_pos(WIDTH // 2, HEIGHT // 2)  def update():     handle_mouse()  # Control camera with mouse     handle_keys()   # Control movement with WASD 

Step 5: physics.py - Basic Physics (Collision)

This file handles simple physics, like making sure the player doesn’t fall through the ground.

python
CopyEdit
# Simple collision check for the ground def check_collision(player_pos, ground_level=0):     if player_pos[1] < ground_level:         player_pos[1] = ground_level  # Prevent player from falling below ground 

Step 6: main.py - The Main Game Loop

This is where everything comes together: initializing the game, running the game loop, and rendering objects.

python
CopyEdit
import pygame from engine import init_camera, update_camera from player import update from physics import check_collision  # Window settings WIDTH, HEIGHT = 800, 600 screen = pygame.display.set_mode((WIDTH, HEIGHT), DOUBLEBUF | OPENGL)  # Game loop def game_loop():     clock = pygame.time.Clock()     running = True      while running:         for event in pygame.event.get():             if event.type == pygame.QUIT:                 running = False          # Clear the screen before drawing         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)          # Initialize the camera         init_camera()          # Update the player input (movement, mouse look)         update()          # Basic collision (prevent falling through the ground)         check_collision(camera_pos)          # Draw a rotating cube (just an example)         draw_cube()          # Update the display         pygame.display.flip()          # Control the frame rate         clock.tick(60)      pygame.quit()  # Function to draw a simple cube def draw_cube():     vertices = [         (1, -1, -1), (1, 1, -1), (-1, 1, -1), (-1, -1, -1),         (1, -1, 1), (1, 1, 1), (-1, -1, 1), (-1, 1, 1)     ]      edges = [         (0, 1), (1, 2), (2, 3), (3, 0),         (4, 5), (5, 6), (6, 7), (7, 4),         (0, 4), (1, 5), (2, 6), (3, 7)     ]      glBegin(GL_LINES)     for edge in edges:         for vertex in edge:             glVertex3fv(vertices[vertex])     glEnd()  # Run the game if __name__ == "__main__":     pygame.mouse.set_visible(False)  # Hide the mouse cursor     pygame.mouse.set_pos(WIDTH // 2, HEIGHT // 2)  # Center the mouse     game_loop() 

Step 7: Run the Game

1. Open the folder containing your game files in your terminal.
2. Run the game by typing:

   bash
   CopyEdit
   python src/main.py 
   

This will open a window with a rotating cube in 3D space. You can use the WASD keys to move the camera around and the mouse to look around.

What’s Happening in the Code?

• engine.py: Initializes OpenGL, sets up the camera, and handles basic movement (WASD).
• player.py: Uses the mouse to look around (pitch and yaw).
• physics.py: Ensures the player doesn’t fall below the ground (very basic physics).
• main.py: Contains the main game loop and rendering logic (including drawing a rotating cube).

Next Steps

Once you have the basic setup running, you can:

• Add 3D models: Use glBindTexture() to add textures to objects or load external models like .obj files.
• Advanced Physics: Integrate more realistic physics (e.g., using PyBullet or Pymunk).
• Lighting: Use glEnable(GL_LIGHTING) and glLightfv() to add lighting effects to your scene.

to import a graphics engine

import library as libraryalias

Infinity Engine: Creating a Realistic Human Body Using Code

This guide shows you how to create a realistic humanoid body using basic 3D shapes in the Infinity Engine (using Ursina for 3D rendering). We will aim for a simple yet more realistic look, focusing on proportions and proper alignment for a human body.

Step 1: Install Required Libraries

Before starting, ensure that the Ursina library is installed.

bash
Copy code
pip install ursina 

Step 2: Set Up Your Environment

python
Copy code
from ursina import *  # Initialize Ursina Engine app = Ursina()  # Set the window size and parameters window.title = "Realistic Human Body" window.size = (800, 600) 

Step 3: Create the Head

We will use a sphere for the head. This sphere will be placed at the top of the body and will represent the person's head.

python
Copy code
# Create the head (sphere) head = Entity(model='sphere', color=color.peach, scale=(0.45, 0.45, 0.45), position=(0, 2.6, 0)) 

• Model: The head is a sphere.
• Scale: The sphere’s scale is (0.45, 0.45, 0.45) to resemble a realistic head size.
• Position: The head is positioned above the torso at (0, 2.6, 0).

Step 4: Create the Torso

The torso is the central body part. We will use a cube with the right proportions to represent the body.

python
Copy code
# Create the torso (cube) torso = Entity(model='cube', color=color.blue, scale=(0.7, 1.5, 0.5), position=(0, 1.2, 0)) 

• Model: A cube represents the torso.
• Scale: The scale of (0.7, 1.5, 0.5) gives the torso a more realistic, elongated shape.
• Position: The torso is placed just below the head at (0, 1.2, 0).

Step 5: Create the Arms

We will use cylinders for the arms, starting with the upper arms and then creating the lower arms. The arm proportions will be realistic based on human anatomy.

Upper Arms:

python
Copy code
# Create the upper arms (cylinders) upper_arm_left = Entity(model='cylinder', color=color.green, scale=(0.25, 0.8, 0.25), position=(-0.9, 1.7, 0)) upper_arm_right = Entity(model='cylinder', color=color.green, scale=(0.25, 0.8, 0.25), position=(0.9, 1.7, 0)) 

• Model: Cylinders represent the upper arms.
• Scale: The upper arm cylinders have a scale of (0.25, 0.8, 0.25) to match realistic upper arm proportions.
• Position: These are positioned just below the torso to simulate the shoulder joint.

Lower Arms:

python
Copy code
# Create the lower arms (cylinders) lower_arm_left = Entity(model='cylinder', color=color.green, scale=(0.2, 0.8, 0.2), position=(-0.9, 0.3, 0)) lower_arm_right = Entity(model='cylinder', color=color.green, scale=(0.2, 0.8, 0.2), position=(0.9, 0.3, 0)) 

• Model: The cylinders represent the lower arms.
• Scale: The scale is slightly smaller, (0.2, 0.8, 0.2), to simulate the more slender look of forearms.
• Position: These are placed below the upper arms to complete the arm structure.

Step 6: Create the Hands

We’ll use small spheres for the hands. These will give a basic, but more realistic, representation of the hands.

python
Copy code
# Create the hands (small spheres) hand_left = Entity(model='sphere', color=color.brown, scale=(0.2, 0.2, 0.2), position=(-0.9, -0.3, 0)) hand_right = Entity(model='sphere', color=color.brown, scale=(0.2, 0.2, 0.2), position=(0.9, -0.3, 0)) 

• Model: Spheres represent the hands.
• Scale: The hands are small with a scale of (0.2, 0.2, 0.2).
• Position: The hands are placed at the end of the lower arms.

Step 7: Create the Legs

The legs will also be created using cylinders, starting with the upper legs and then creating the lower legs. The proportions are similar to the arms, but the upper legs will be slightly thicker.

Upper Legs:

python
Copy code
# Create the upper legs (cylinders) upper_leg_left = Entity(model='cylinder', color=color.red, scale=(0.35, 1, 0.35), position=(-0.5, -0.5, 0)) upper_leg_right = Entity(model='cylinder', color=color.red, scale=(0.35, 1, 0.35), position=(0.5, -0.5, 0)) 

• Model: Cylinders represent the upper legs.
• Scale: The upper legs are a bit thicker, with a scale of (0.35, 1, 0.35).
• Position: The upper legs are positioned below the torso to resemble the pelvis.

Lower Legs:

python
Copy code
# Create the lower legs (cylinders) lower_leg_left = Entity(model='cylinder', color=color.red, scale=(0.25, 1, 0.25), position=(-0.5, -2, 0)) lower_leg_right = Entity(model='cylinder', color=color.red, scale=(0.25, 1, 0.25), position=(0.5, -2, 0)) 

• Model: The lower legs are also cylinders.
• Scale: The scale is smaller, (0.25, 1, 0.25), to simulate the slimmer shape of lower legs.
• Position: These are positioned just below the upper legs.

Step 8: Create the Feet

We’ll use small spheres for the feet as well. This gives a basic foot representation.

python
Copy code
# Create the feet (small spheres) foot_left = Entity(model='sphere', color=color.brown, scale=(0.25, 0.25, 0.25), position=(-0.5, -3, 0)) foot_right = Entity(model='sphere', color=color.brown, scale=(0.25, 0.25, 0.25), position=(0.5, -3, 0)) 

• Model: Spheres represent the feet.
• Scale: The feet are slightly larger than the hands, with a scale of (0.25, 0.25, 0.25).
• Position: The feet are placed below the lower legs to simulate a standing position.

Step 9: Combining and Animating the Model

At this point, the model is composed of all major body parts. You can combine them and animate specific parts. For example, you can rotate the arms or legs to simulate walking.

python
Copy code
def update():     # Simple animation: rotate the arms     upper_arm_left.rotation_x += 10 * time.dt     upper_arm_right.rotation_x += 10 * time.dt     upper_leg_left.rotation_x += 5 * time.dt     upper_leg_right.rotation_x += 5 * time.dt 

This update function animates the arms and legs slightly to create movement over time.

Complete Example

Here’s the complete code to create a simple yet realistic humanoid character:

python
Copy code
from ursina import *  # Initialize Ursina Engine app = Ursina()  # Create the head head = Entity(model='sphere', color=color.peach, scale=(0.45, 0.45, 0.45), position=(0, 2.6, 0))  # Create the torso torso = Entity(model='cube', color=color.blue, scale=(0.7, 1.5, 0.5), position=(0, 1.2, 0))  # Create the upper arms upper_arm_left = Entity(model='cylinder', color=color.green, scale=(0.25, 0.8, 0.25), position=(-0.9, 1.7, 0)) upper_arm_right = Entity(model='cylinder', color=color.green, scale=(0.25, 0.8, 0.25), position=(0.9, 1.7, 0))  # Create the lower arms lower_arm_left = Entity(model='cylinder', color=color.green, scale=(0.2, 0.8, 0.2), position=(-0.9, 0.3, 0)) lower_arm_right = Entity(model='cylinder', color=color.green, scale=(0.2, 0.8, 0.2), position=(0.9, 0.3, 0))  # Create the hands hand_left = Entity(model='sphere', color=color.brown, scale=(0.2, 0.2, 0.2), position=(-0.9, -0.3, 0)) hand_right = Entity(model='sphere', color=color.brown, scale=(0.2, 0.2, 0.2), position=(0.9, -0.3, 0))  # Create the upper legs upper_leg_left = Entity(model='cylinder', color=color.red, scale=(0.35, 1, 0.35), position=(-0.5, -0.5, 0)) upper_leg_right = Entity(model='cylinder', color=color.red, scale=(0.35, 1, 0.35), position=(0.5, -0.5, 0))  # Create the lower legs lower_leg_left = Entity(model='cylinder', color=color.red, scale=(0.25, 1, 0.25), position=(-0.5, -2, 0)) lower_leg_right = Entity(model='cylinder', color=color.red, scale=(0.25, 1, 0.25), position=(0.5, -2, 0))  # Create the feet foot_left = Entity(model='sphere', color=color.brown, scale=(0.25, 0.25, 0.25), position=(-0.5, -3, 0)) foot_right = Entity(model='sphere', color=color.brown, scale=(0.25, 0.25, 0.25), position=(0.5, -3, 0))  # Animation def update():     # Simple animation for the arms and legs     upper_arm_left.rotation_x += 10 * time.dt     upper_arm_right.rotation_x += 10 * time.dt     upper_leg_left.rotation_x += 5 * time.dt     upper_leg_right.rotation_x += 5 * time.dt  # Run the application app.run() 

Step 10: Final Thoughts

By adjusting the proportions, scale, and adding movement to different body parts, you can achieve a simple yet realistic humanoid model. For true realism, however, 3D modeling tools would be required to design detailed models, and then you can import them into your engine.

Infinity Engine 2D Platformer Game Tutorial

Welcome to the Infinity Engine 2D Platformer Game Tutorial! In this guide, we will cover the steps needed to create a basic 2D platformer game using Infinity Engine. You will learn to set up the environment, create a player character, add platforms, and implement basic physics for jumping and movement.

Getting Started

Prerequisites

Before starting, ensure you have the following:

• Infinity Engine Installed Make sure your Infinity Engine setup is working without any errors. Refer to the installation guide if needed.
• Python Installed You will need Python 3.x installed on your system. If you haven't already, install Python from the official website: Python.
• Libraries Install the required libraries using pip. Open your terminal or command prompt and run the following:

bash
Copy code
pip install pygame ursina 

Step 1: Setting Up the Game Environment

1. Initialize Infinity Engine and Import Libraries

Start by importing the necessary libraries and initializing the game window.

python
Copy code
import pygame as Infinity2D from ursina import *  # Initialize Ursina Engine app = Ursina()  # Set up the game window size WIDTH, HEIGHT = 800, 600 screen = Infinity2D.display.set_mode((WIDTH, HEIGHT)) Infinity2D.display.set_caption("Infinity Engine 2D Platformer") 

2. Create the Player Character

We’ll create a simple player character using a basic cube entity.

python
Copy code
player = Entity(model='cube', color=color.red, scale=(1, 2), position=(0, 1, 0)) 

• Model: The player is represented as a cube.
• Color: The color is set to red.
• Scale: The scale is adjusted to make the player taller than wide.
• Position: The player starts at coordinates (0, 1, 0).

Step 2: Create Platforms

Next, let’s create platforms for the player to jump on. Platforms are simply static entities that the player can collide with.

python
Copy code
platform1 = Entity(model='cube', color=color.green, scale=(5, 0.5), position=(0, -1, 0)) platform2 = Entity(model='cube', color=color.green, scale=(5, 0.5), position=(7, -3, 0)) 

We created two platforms:

• platform1: Positioned at (0, -1, 0)
• platform2: Positioned at (7, -3, 0)

Step 3: Add Player Movement and Jumping

We will use basic keyboard inputs to allow the player to move left and right, as well as jump.

1. Define Movement Speed

Let’s define how fast the player can move.

python
Copy code
player_speed = 5 

2. Update the Player’s Position

We will add the ability to move the player left and right using the arrow keys, and make the player jump using the spacebar.

python
Copy code
def update():     if held_keys['right arrow']:         player.x += player_speed * time.dt  # Move right     if held_keys['left arrow']:         player.x -= player_speed * time.dt  # Move left          if held_keys['space'] and player.y == 1:  # Check if on the ground         player.y += 5  # Make the player jump 

In the above code:

• held_keys['right arrow']: Moves the player to the right.
• held_keys['left arrow']: Moves the player to the left.
• held_keys['space']: Makes the player jump if they’re on the ground.

Step 4: Apply Gravity

To simulate gravity, we will slowly decrease the player's vertical position to simulate falling, unless the player is on the ground.

python
Copy code
gravity = 9.8  def update():     # Handle horizontal movement     if held_keys['right arrow']:         player.x += player_speed * time.dt     if held_keys['left arrow']:         player.x -= player_speed * time.dt          # Jumping and gravity     if held_keys['space'] and player.y == 1:         player.y += 5          if player.y > 1:         player.y -= gravity * time.dt  # Apply gravity to fall 

1. Collision with Ground

We will add a condition to stop the player’s downward movement when they reach the ground.

python
Copy code
    if player.y <= 1:         player.y = 1  # Stop falling when the player touches the ground 

This keeps the player grounded once they land after a jump.

Step 5: Add a Camera and Finalize

Now, let’s add a camera to follow the player and make sure everything looks good.

python
Copy code
camera.parent = player camera.position = Vec3(0, 3, -10)  # Position the camera behind the player camera.rotation = Vec3(20, 0, 0)  # Slight angle to view the player 

Now that the camera is attached to the player, it will follow their movements. The camera’s position is offset a bit to give a better perspective.

Step 6: Run the Game

Finally, start the game loop to run the game.

python
Copy code
app.run() 

Complete Code Example

Here’s the full code to create your simple 2D platformer game:

python
Copy code
from ursina import * import pygame as Infinity2D  # Initialize the Ursina Engine app = Ursina()  # Game window setup WIDTH, HEIGHT = 800, 600 screen = Infinity2D.display.set_mode((WIDTH, HEIGHT)) Infinity2D.display.set_caption("Infinity Engine 2D Platformer")  # Create the player character player = Entity(model='cube', color=color.red, scale=(1, 2), position=(0, 1, 0))  # Create platforms platform1 = Entity(model='cube', color=color.green, scale=(5, 0.5), position=(0, -1, 0)) platform2 = Entity(model='cube', color=color.green, scale=(5, 0.5), position=(7, -3, 0))  # Define movement speed player_speed = 5 gravity = 9.8  # Update function to handle movement and jumping def update():     if held_keys['right arrow']:         player.x += player_speed * time.dt     if held_keys['left arrow']:         player.x -= player_speed * time.dt          if held_keys['space'] and player.y == 1:         player.y += 5  # Jumping      if player.y > 1:         player.y -= gravity * time.dt  # Apply gravity to fall      if player.y <= 1:         player.y = 1  # Stop falling when the player touches the ground  # Add a camera to follow the player camera.parent = player camera.position = Vec3(0, 3, -10) camera.rotation = Vec3(20, 0, 0)  # Run the game app.run() 

Conclusion

Now you have a basic 2D platformer set up in Infinity Engine! You can move the player left and right, jump on platforms, and experience simple gravity effects. This tutorial can be expanded with more features like animations, additional levels, enemies, and more! Happy coding!

Infinity Engine 3D Game Tutorial

Welcome to the Infinity Engine 3D Game Tutorial! This guide will walk you through building a 3D game from scratch using Infinity Engine. You’ll learn to set up the environment, load a 3D model, add interactions, and render a basic 3D world.

Getting Started

Before you begin, make sure you have the following:

Infinity Engine Installed

Ensure your engine setup is installed and functioning correctly. Refer to the Infinity Engine installation guide for troubleshooting.

A 3D Model

You’ll need a .glb, .obj, or .fbx file for your game. Free models are available on platforms like Sketchfab and CGTrader.

Python Installed

Install Python 3.x on your system. You may need additional libraries for enhanced functionality. Run this command to install required dependencies:

bash
Copy code
pip install ursina pygame 

Step 1: Setting Up the Environment

1. Initialize the Engine Start by importing necessary libraries and initializing Infinity Engine.

   Text: import pygame as Infinity2D from ursina import * app = Ursina()

2. Set Up the Game Window Create a window for your game using Infinity Engine's display module.

   Text: WIDTH, HEIGHT = 800, 600 screen = Infinity2D.display.set_mode((WIDTH, HEIGHT)) Infinity2D.display.set_caption("Infinity Engine 3D Game")

Step 2: Importing a 3D Model

1. Load the Model Import a 3D model into the game.

   Text: model = Entity(model='path_to_model.glb', scale=(1, 1, 1), position=(0, 0, 0))

2. Adjust Model Properties Customize the model’s size and position in the 3D world.

   Text: model.position = Vec3(0, 1, 0) model.scale = 2

Step 3: Adding Lighting and Environment

1. Add Lighting Use a directional light to illuminate the scene.

   Text: light = DirectionalLight() light.look_at(Vec3(0, -1, -1))

2. Add a Ground Plane Add a plane to represent the ground.

   Text: ground = Entity(model='plane', scale=(10, 1, 10), color=color.green)

Step 4: Player Movement

1. Add Player Controls Use Ursina's FirstPersonController for player movement.

   Text: player = FirstPersonController()

2. Attach Camera to Player Ensure the camera follows the player’s movements.

   Text: camera.parent = player

Step 5: Running the Game

1. Add Sky Background Use a skybox for the game’s background.

   Text: sky = Sky()

2. Start the Game Loop Run the game using app.run().

   Text: app.run()

Complete Example Code

Here’s the full example in plain text:

Text: from ursina import * import pygame as Infinity2D

app = Ursina()

WIDTH, HEIGHT = 800, 600 screen = Infinity2D.display.set_mode((WIDTH, HEIGHT)) `Infinity2D.display.set_caption

bash
Copy code
pip install ursina pygame 

python
Copy code
import pygame as Infinity2D from ursina import *  # Initialize Ursina Engine app = Ursina() 

python
Copy code
WIDTH, HEIGHT = 800, 600 screen = Infinity2D.display.set_mode((WIDTH, HEIGHT)) Infinity2D.display.set_caption("Infinity Engine 3D Game") 

python
Copy code
model = Entity(model='path_to_model.glb', scale=(1, 1, 1), position=(0, 0, 0)) 

python
Copy code
model.position = Vec3(0, 1, 0)  # Position the model at (x, y, z) model.scale = 2  # Double the model size 

python
Copy code
light = DirectionalLight() light.look_at(Vec3(0, -1, -1)) 

python
Copy code
ground = Entity(model='plane', scale=(10, 1, 10), color=color.green) 

python
Copy code
player = FirstPersonController() 

python
Copy code
camera.parent = player 

python
Copy code
sky = Sky() 

python
Copy code
app.run() 

python
Copy code
from ursina import * import pygame as Infinity2D  # Initialize the Ursina Engine app = Ursina()  # Main Screen WIDTH, HEIGHT = 800, 600 screen = Infinity2D.display.set_mode((WIDTH, HEIGHT)) Infinity2D.display.set_caption("Infinity Engine 3D Game")  # Add Environment light = DirectionalLight() light.look_at(Vec3(0, -1, -1)) ground = Entity(model='plane', scale=(10, 1, 10), color=color.green) sky = Sky()  # Add 3D Model model = Entity(model='path_to_model.glb', scale=(1, 1, 1), position=(0, 0, 0))  # Add Player player = FirstPersonController() camera.parent = player  # Run Game app.run() 

What would you like to see in the next updates?

if you have sigs or a repository please link

adding more sig

IE IS NOT OPEN SOURCE.

IE is FREE.

You can mod the engine for your own use to make a game but not to sell  any thing other than the game you make. 

Pre - Order is gone FREE to download

can you add a exe

this is good

Can you make a apk