Paulo Laureano Because coding is fun!

Example "drawing sprites & collision" in Python


This example uses python 3 with a Raylib (https://www.raylib.com) wrapper (https://pypi.org/project/raylib/) that uses CFFI API static bindings (this is the fastest approach, and keeps the code as close as possible to the original C, which I feel is the best approach when using a C library).

Create a folder called "resources" (in the same directory as your code) and place the two images (provided bellow) there.

hero_shipufo1


Here is the Python sample code…



from raylib.static import *
from ctypes import *

screenWidth = 800
screenHeight = 600

InitWindow(screenWidth, screenHeight, b"sprites & collision example")

SetTargetFPS(60)

# hero ship
speed = 4.0
ship_size_width = 50
ship_size_height = 75

ship_position={'x': screenWidth/2.0, 'y': screenHeight-ship_size_height}
ship_rectangle = { 'x': ship_position["x"], 'y': ship_position["y"],'width': ship_size_width, 'height': ship_size_height }
image_hero_ship = LoadImage(b"resources/hero_ship.png")

ImageResize(ffi.addressof(image_hero_ship), ship_size_width, ship_size_height)

hero_ship=LoadTextureFromImage(image_hero_ship)


#bad dude ship
baddude_speed = 4.0
baddude_ship_size_width = 100
baddude_ship_size_height = 50

baddude_ship_position={'x': screenWidth/2.0, 'y': 0}
baddude_ship_rectangle = { 'x': baddude_ship_position["x"], 'y': baddude_ship_position["y"], 'width': baddude_ship_size_width, 'height': baddude_ship_size_height }
image_baddude_ship = LoadImage(b"resources/ufo1.png")

ImageResize(ffi.addressof(image_baddude_ship), baddude_ship_size_width, baddude_ship_size_height)

baddude_ship=LoadTextureFromImage(image_baddude_ship)



# detect collision
def my_check_collision_recs(rec1,rec2):
if rec1["x"] < rec2["x"] + rec2["width"] and rec1["x"] + rec1["width"] > rec2["x"] and rec1["y"] < rec2["y"] + rec2["height"] and rec1["y"] + rec1["height"] > rec2["y"]:
return 1
else:
return 0



while not WindowShouldClose():

# control the heroship
if IsKeyDown(KEY_RIGHT):
ship_position["x"] += 2.0
ship_rectangle["x"] += 2.0
if IsKeyDown(KEY_LEFT):
ship_position["x"] -= 2.0
ship_rectangle["x"] -= 2.0
if IsKeyDown(KEY_UP):
ship_position["y"] -= 2.0
ship_rectangle["y"] -= 2.0
if IsKeyDown(KEY_DOWN):
ship_position["y"] += 2.0
ship_rectangle["y"] += 2.0

BeginDrawing()

ClearBackground(RAYWHITE)
DrawTexture(baddude_ship, int(baddude_ship_position["x"]), int(baddude_ship_position["y"]), LIGHTGRAY)
DrawTexture(hero_ship, int(ship_position["x"]), int(ship_position["y"]), LIGHTGRAY)


if my_check_collision_recs(ship_rectangle, baddude_ship_rectangle):
DrawText(b"BOOM", 10, 10, 20, LIGHTGRAY)


EndDrawing()
CloseWindow()


Example "mouse wheel input" in Python

This example uses python 3 with a Raylib (https://www.raylib.com) wrapper (https://pypi.org/project/raylib/) that uses CFFI API static bindings (this is the fastest approach, and keeps the code as close as possible to the original C, which I feel is the best approach when using a C library).

https://www.raylib.com/examples/web/core/loader.html?name=core_input_mouse_wheel

The original C example, edited for easier comparison:


#include "raylib.h"

int main(void)
{
const int screenWidth = 800;
const int screenHeight = 450;

InitWindow(screenWidth, screenHeight, "raylib [core] example - input mouse wheel");

int boxPositionY = screenHeight/2 - 40;
int scrollSpeed = 4; // Scrolling speed in pixels

SetTargetFPS(60); // Set our game to run at 60 frames-per-second

while (!WindowShouldClose()) // Detect window close button or ESC key
{
boxPositionY -= (GetMouseWheelMove()*scrollSpeed);

BeginDrawing();

ClearBackground(RAYWHITE);

DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON);

DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);
DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY);

EndDrawing();
}

CloseWindow(); // Close window and OpenGL context

return 0;
}



The Python version:



from raylib.static import *

screenWidth = 800
screenHeight = 450

InitWindow(screenWidth, screenHeight, b"raylib [core] example - input mouse wheel")

boxPositionX = screenWidth/2 - 40
boxPositionY = screenHeight/2 - 40
scrollSpeed = 4


SetTargetFPS(60)


while not WindowShouldClose():
boxPositionY -= GetMouseWheelMove()*scrollSpeed

BeginDrawing()
ClearBackground(RAYWHITE)
DrawRectangle(int(boxPositionX), int(boxPositionY), 80, 80, MAROON)

DrawText(b"Use mouse wheel to move the cube up and down!", 10, 10, 20, LIGHTGRAY)

yCoord="Box position Y: {}".format(int(boxPositionY))
DrawText(yCoord.encode('ascii'), 10, 40, 20, LIGHTGRAY)

EndDrawing()
CloseWindow()

Example "mouse input" in Python

This example uses python 3 with a Raylib (https://www.raylib.com) wrapper (https://pypi.org/project/raylib/) that uses CFFI API static bindings (this is the fastest approach, and keeps the code as close as possible to the original C, which I feel is the best approach when using a C library).

https://www.raylib.com/examples/web/core/loader.html?name=core_input_mouse

The original C example, edited for easier comparison:


#include "raylib.h"

int main(void)
{
const int screenWidth = 800;
const int screenHeight = 450;

InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");

Vector2 ballPosition = { -100.0f, -100.0f };
Color ballColor = DARKBLUE;

SetTargetFPS(60); // Set our game to run at 60 frames-per-second

while (!WindowShouldClose()) // Detect window close button or ESC key
{
ballPosition = GetMousePosition();

if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME;
else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE;

BeginDrawing();

ClearBackground(RAYWHITE);

DrawCircleV(ballPosition, 40, ballColor);

DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY);

EndDrawing();
}

// De-Initialization
//--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context

return 0;
}



The Python version:



from raylib.static import *

screenWidth = 800
screenHeight = 450

InitWindow(screenWidth, screenHeight, b"raylib [core] example - mouse input")

# Vector2 may be list or tuple or dict or struct-cdata...going with dictionary for ballPosition
ballPosition = {'x': -100, 'y': -100}
ballColor = DARKBLUE


SetTargetFPS(60)


while not WindowShouldClose():
ballPosition = GetMousePosition()

if IsMouseButtonPressed(MOUSE_LEFT_BUTTON):
ballColor = MAROON
elif IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON):
ballColor = LIME
elif IsMouseButtonPressed(MOUSE_RIGHT_BUTTON):
ballColor = DARKBLUE

BeginDrawing()
ClearBackground(RAYWHITE)
DrawText(b"move ball with mouse and click mouse button to change color", 10, 10, 20, LIGHTGRAY)
DrawCircleV(ballPosition, 50, ballColor)
EndDrawing()
CloseWindow()


Example "keyboard input" in Python


This example uses python 3 with a Raylib (https://www.raylib.com) wrapper (https://pypi.org/project/raylib/) that uses CFFI API static bindings (this is the fastest approach, and keeps the code as close as possible to the original C, which I feel is the best approach when using a C library).

https://www.raylib.com/examples/web/core/loader.html?name=core_input_keys

The original C example, edited for easier comparison:


#include "raylib.h"

int main(void)
{
const int screenWidth = 800;
const int screenHeight = 450;

InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");

Vector2 ballPosition = { (float)screenWidth/2, (float)screenHeight/2 };

SetTargetFPS(60); // Set our game to run at 60 frames-per-second

while (!WindowShouldClose()) // Detect window close button or ESC key
{
if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 2.0f;
if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 2.0f;
if (IsKeyDown(KEY_UP)) ballPosition.y -= 2.0f;
if (IsKeyDown(KEY_DOWN)) ballPosition.y += 2.0f;


BeginDrawing();

ClearBackground(RAYWHITE);

DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY);

DrawCircleV(ballPosition, 50, MAROON);

EndDrawing();
}

CloseWindow(); // Close window and OpenGL context

return 0;
}



And now the Python version:



from raylib.static import *

screenWidth = 800
screenHeight = 450

InitWindow(screenWidth, screenHeight, b"raylib [core] example - keyboard input")

# Vector2 may be list or tuple or dict or struct-cdata...going with dictionary for ballPosition
ballPosition = {'x': screenWidth/2, 'y': screenHeight/2}



SetTargetFPS(60)


while not WindowShouldClose():
if IsKeyDown(KEY_RIGHT):
ballPosition["x"] += 2.0
if IsKeyDown(KEY_LEFT):
ballPosition["x"] -= 2.0
if IsKeyDown(KEY_UP):
ballPosition["y"] -= 2.0
if IsKeyDown(KEY_DOWN):
ballPosition["y"] += 2.0

BeginDrawing()
ClearBackground(RAYWHITE)
DrawText(b"move the ball with arrow keys", 10, 10, 20, LIGHTGRAY)
DrawCircleV(ballPosition, 50, MAROON)
EndDrawing()
CloseWindow()



Example "basic window" in Python

This example uses python 3 with a Raylib (https://www.raylib.com) wrapper (https://pypi.org/project/raylib/) that uses CFFI API static bindings (this is the fastest approach, and keeps the code as close as possible to the original C, which I feel is the best approach when using a C library).

Original Raylib C code in example 1 converted to python…

Python version (using https://pypi.org/project/raylib/#description):


from raylib.static import *

screenWidth = 800
screenHeight = 450

InitWindow(screenWidth, screenHeight, b"raylib [core] example - basic window")

SetTargetFPS(60)


while not WindowShouldClose():
BeginDrawing()
ClearBackground(RAYWHITE)
DrawText(b"Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY)
EndDrawing()
CloseWindow()