evan/ludum-dare-48
Archived
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into assets

Browse Source
This commit is contained in:
rsninja722 2021-04-24 17:07:51 -04:00
commit 43c383ed70
17 changed files with 293 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -1,5 +1,5 @@
[package]
name = "ludum-dare-48"
name = "one-breath"
version = "0.1.0"
authors = ["Evan Pratten <ewpratten@gmail.com>"]
edition = "2018"

2
assets/img/map/cave.json
View File

File diff suppressed because one or more lines are too long

13
assets/worlds/mainworld.json
View File

File diff suppressed because one or more lines are too long

8
bundle/create-releases.sh
View File

@ -9,10 +9,10 @@ set -e
# Make a uni-bundle
echo "Creating a fat bundle for all platforms"
rm -rf ./bundle/release
rm -rf ./bundle/ludum-dare-48.zip
rm -rf ./bundle/one-breath.zip
mkdir -p ./bundle/release
cp -r ./assets ./bundle/release
cp ./bundle/linux/release/ludum-dare-48 ./bundle/release/ludum-dare-48
cp ./bundle/windows/release/ludum-dare-48.exe ./bundle/release/ludum-dare-48.exe
cp ./bundle/linux/release/one-breath ./bundle/release/one-breath
cp ./bundle/windows/release/one-breath.exe ./bundle/release/one-breath.exe
cd ./bundle/release
zip -r ../ludum-dare-48.zip ./
zip -r ../one-breath.zip ./

2
bundle/linux/create-release.sh
View File

@ -12,7 +12,7 @@ rm -rf ./bundle/linux/release-x86_64-unknown-linux-gnu.zip
mkdir -p ./bundle/linux/release
echo "Copying binary"
cp ./target/x86_64-unknown-linux-gnu/release/ludum-dare-48 ./bundle/linux/release
cp ./target/x86_64-unknown-linux-gnu/release/one-breath ./bundle/linux/release
echo "Copying assets"
cp -r ./assets ./bundle/linux/release

2
bundle/windows/create-release.sh
View File

@ -11,7 +11,7 @@ rm -rf ./bundle/windows/release-x86_64-pc-windows-gnu.zip
mkdir -p ./bundle/windows/release
echo "Copying binary"
cp ./target/x86_64-pc-windows-gnu/release/ludum-dare-48.exe ./bundle/windows/release
cp ./target/x86_64-pc-windows-gnu/release/one-breath.exe ./bundle/windows/release
echo "Copying assets"
cp -r ./assets ./bundle/windows/release

129
src/entities/fish.rs
View File

@ -1,30 +1,51 @@
use rand::{Rng, prelude::ThreadRng};
use rand::{prelude::ThreadRng, Rng};
use raylib::prelude::*;
use crate::{gamecore::GameCore, lib::utils::triangles::rotate_vector, player::Player};
use crate::{
gamecore::GameCore, lib::utils::triangles::rotate_vector, player::Player, world::World,
};
const FISH_FOLLOW_PLAYER_DISTANCE: f32 = 30.0;
const FISH_FOLLOW_PLAYER_SPEED: f32 = 1.8;
const FISH_FOLLOW_PLAYER_SPEED_FAST: f32 = FISH_FOLLOW_PLAYER_SPEED * 3.0;
const FISH_ATTACH_RADIUS: f32 = 20.0;
const FISH_VISION: f32 = 25.0;
const FISH_MAX_SPEED: f32 = 2.0;
const FISH_MAX_FORCE: f32 = 0.05;
const FISH_FACTOR_ATTRACTION: f32 = 1.0;
const FISH_FACTOR_PLAYER: f32 = 0.1;
const FISH_FACTOR_COHESION: f32 = 0.1;
const FISH_SEPARATION_DISTANCE: f32 = 15.0;
const FISH_FACTOR_SEPARATION: f32 = 1.5;
#[derive(Debug, Clone)]
pub struct FishEntity {
position: Vector2,
direction: Vector2,
velocity: Vector2,
pub following_player: bool,
size: Vector2,
rng: ThreadRng
rng: ThreadRng,
color: Color,
}
impl FishEntity {
pub fn new(position: Vector2) -> Self {
let mut rng = rand::thread_rng();
Self {
position: position,
direction: Vector2::zero(),
velocity: Vector2::zero(),
following_player: false,
size: Vector2 { x: 5.0, y: 8.0 },
rng: rand::thread_rng()
color: Color {
r: rng.gen_range(128..225),
g: rng.gen_range(128..225),
b: rng.gen_range(128..225),
a: 140,
},
rng,
}
}
@ -36,34 +57,81 @@ impl FishEntity {
return output;
}
pub fn handle_follow_player(&mut self, player: &Player, dt: f64) {
// Distance and direction to player
let dist_to_player = player.position - self.position;
let dist_to_player_lin = self.position.distance_to(player.position);
let mut direction_to_player = dist_to_player;
direction_to_player.normalize();
pub fn handle_follow_player(&mut self, player: &Player, dt: f64, other_fish: &Vec<FishEntity>) {
let mut acceleration: Vector2 = Vector2::zero();
// Fish movement
let movement;
// Random variance
let variance = self.rng.gen_range(500.0..1000.0) / 1000.0;
// If the fish is double its follow distance from the player
if dist_to_player_lin.abs() > (FISH_FOLLOW_PLAYER_DISTANCE * 2.0) {
movement = direction_to_player * FISH_FOLLOW_PLAYER_SPEED_FAST * variance;
} else {
// Move slowly in the direction of the player unless too close
if dist_to_player_lin.abs() > FISH_FOLLOW_PLAYER_DISTANCE {
movement = direction_to_player * FISH_FOLLOW_PLAYER_SPEED * variance;
} else {
movement = Vector2::zero();
let mut steer: Vector2 = Vector2::zero();
let mut count1: u16 = 0;
let mut sum1: Vector2 = Vector2::zero();
let mut count2: u16 = 0;
let mut sum2: Vector2 = Vector2::zero();
let mut count3: u16 = 0;
// separation
for i in other_fish {
let dist = (self.position - i.position).length();
if dist < FISH_SEPARATION_DISTANCE && dist > 0.0 {
let mut diff: Vector2 = self.position - i.position;
diff.normalize();
diff /= dist;
steer += diff;
count1 += 1;
}
if dist < FISH_VISION && dist > 0.0 {
sum1 += i.direction;
count2 += 1;
sum2 += i.position;
count3 += 1;
}
}
if count1 > 0 {
steer /= count1 as f32;
}
if steer.x != 0.0 || steer.y != 0.0 {
steer.normalize();
steer *= FISH_MAX_SPEED;
steer -= self.velocity;
steer.x = f32::min(f32::max(steer.x, -FISH_MAX_FORCE), FISH_MAX_FORCE);
steer.y = f32::min(f32::max(steer.y, -FISH_MAX_FORCE), FISH_MAX_FORCE);
acceleration += steer * FISH_FACTOR_SEPARATION;
}
// attraction
if count2 > 0 {
sum1 /= count2 as f32;
sum1.normalize();
sum1 *= FISH_MAX_SPEED;
sum1 -= self.velocity;
sum1.x = f32::min(f32::max(sum1.x, -FISH_MAX_FORCE), FISH_MAX_FORCE);
sum1.y = f32::min(f32::max(sum1.y, -FISH_MAX_FORCE), FISH_MAX_FORCE);
acceleration += sum1 * FISH_FACTOR_ATTRACTION;
}
// cohesion
if count3 > 0 {
sum2 /= count3 as f32;
let mut desired: Vector2 = sum2 - self.position;
desired.normalize();
desired *= FISH_MAX_SPEED;
desired.x = f32::min(f32::max(desired.x, -FISH_MAX_FORCE), FISH_MAX_FORCE);
desired.y = f32::min(f32::max(desired.y, -FISH_MAX_FORCE), FISH_MAX_FORCE);
acceleration += desired * FISH_FACTOR_COHESION;
}
// turn to player
let mut player_factor: Vector2 = player.position - self.position;
player_factor.normalize();
acceleration += player_factor * FISH_FACTOR_PLAYER;
// Move the fish
self.direction = direction_to_player;
self.position += movement;
self.direction = self.velocity.normalized();
self.velocity += acceleration;
self.velocity.x = f32::min(f32::max(self.velocity.x, -FISH_MAX_SPEED), FISH_MAX_SPEED);
self.velocity.y = f32::min(f32::max(self.velocity.y, -FISH_MAX_SPEED), FISH_MAX_SPEED);
self.position += self.velocity;
}
pub fn handle_free_movement(&mut self, player: &mut Player, dt: f64) {
@ -76,6 +144,7 @@ impl FishEntity {
// Handle player picking up fish
if player.position.distance_to(self.position).abs() <= player.size.y * 2.2 {
self.following_player = true;
self.velocity = self.direction.normalized();
// Add currency to the player
player.coins += 1;
@ -86,9 +155,9 @@ impl FishEntity {
self.direction = direction_to_player;
}
pub fn update_position(&mut self, player: &mut Player, dt: f64) {
pub fn update_position(&mut self, player: &mut Player, dt: f64, other_fish: &Vec<FishEntity>) {
if self.following_player {
self.handle_follow_player(player, dt);
self.handle_follow_player(player, dt, other_fish);
} else {
self.handle_free_movement(player, dt);
}
@ -127,7 +196,7 @@ impl FishEntity {
self.position + fish_front,
self.position + fish_bl,
self.position + fish_br,
Color::BLACK,
self.color,
);
}
}

5
src/gamecore.rs
View File

@ -107,6 +107,7 @@ impl GameCore {
world: World,
progress: GameProgress,
) -> Self {
let player = Player::new(&world.player_spawn);
Self {
state: GameState::Loading,
last_state: GameState::Loading,
@ -117,13 +118,13 @@ impl GameCore {
.expect("Failed to load game assets. Can not launch!"),
master_camera: Camera2D {
offset: Vector2::zero(),
target: Vector2::zero(),
target: world.player_spawn,
rotation: 0.0,
zoom: 2.0,
},
show_simple_debug_info: false,
world: world,
player: Player::new(),
player,
progress: progress,
}
}

55
src/logic/ingame/mod.rs
View File

@ -6,6 +6,7 @@ use raylib::prelude::*;
use crate::{
gamecore::{GameCore, GameState},
lib::wrappers::audio::player::AudioPlayer,
pallette::{SKY, WATER},
};
use super::screen::Screen;
@ -31,7 +32,48 @@ impl InGameScreen {
context_2d: &mut RaylibMode2D<RaylibDrawHandle>,
game_core: &mut GameCore,
) {
context_2d.draw_circle(0, 0, 10.0, Color::BLACK);
// Build source bounds
let source_bounds = Rectangle {
x: 0.0,
y: 0.0,
width: game_core.resources.cave_mid_layer.width as f32,
height: game_core.resources.cave_mid_layer.height as f32,
};
let world_bounds = Rectangle {
x: 0.0,
y: 0.0,
width: game_core.resources.cave_mid_layer.width as f32,
height: game_core.resources.cave_mid_layer.height as f32,
};
// Clear the background
context_2d.draw_rectangle_rec(world_bounds, WATER);
// Render the world texture
context_2d.draw_texture_rec(
&game_core.resources.cave_mid_layer,
source_bounds,
Vector2 {
x: world_bounds.x,
y: world_bounds.y,
},
Color::WHITE,
);
}
fn render_colliders(
&mut self,
context_2d: &mut RaylibMode2D<RaylibDrawHandle>,
game_core: &mut GameCore,
) {
// Render every collider
for collider in game_core.world.colliders.iter() {
context_2d.draw_rectangle_lines_ex(
collider,
1,
Color::RED,
);
}
}
}
@ -47,7 +89,7 @@ impl Screen for InGameScreen {
let dt = draw_handle.get_time() - game_core.last_frame_time;
// Clear frame
draw_handle.clear_background(Color::BLUE);
draw_handle.clear_background(Color::BLACK);
// Handle the pause menu being opened
if draw_handle.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
@ -72,11 +114,14 @@ impl Screen for InGameScreen {
// Render the world
self.render_world(&mut context_2d, game_core);
if game_core.show_simple_debug_info{
self.render_colliders(&mut context_2d, game_core);
}
// Render entities
let mut fish = &mut game_core.world.fish;
for fish in fish.iter_mut() {
fish.update_position(&mut game_core.player, dt);
let fish_clone = game_core.world.fish.clone();
for fish in game_core.world.fish.iter_mut() {
fish.update_position(&mut game_core.player, dt, &fish_clone);
fish.render(&mut context_2d);
}

26
src/logic/ingame/playerlogic.rs
View File

@ -129,8 +129,20 @@ pub fn update_player_movement(
// Only do this if the mouse is far enough away
let player_real_movement = game_core.player.direction * speed_multiplier;
if raw_movement_direction.distance_to(Vector2::zero()) > game_core.player.size.y / 2.0 {
game_core.player.position += player_real_movement;
game_core.player.is_moving = true;
game_core.player.position += player_real_movement;
// Check for any collisions
for collider in game_core.world.colliders.iter() {
if game_core.player.collides_with_rec(collider) {
game_core.player.is_moving = false;
break;
}
}
if !game_core.player.is_moving {
game_core.player.position -= player_real_movement;
}
} else {
game_core.player.is_moving = false;
}
@ -142,9 +154,19 @@ pub fn update_player_movement(
draw_handle.get_world_to_screen2D(game_core.player.position, game_core.master_camera);
// Camera only moves if you get close to the edge of the screen
if player_screen_position.distance_to(window_center).abs() > (window_center.y - 40.0) {
if player_screen_position.distance_to(window_center).abs() > 100.0 {
game_core.master_camera.target += player_real_movement;
}
// If the player is not on screen, snap the camera to them
if player_screen_position.distance_to(window_center).abs() > window_center.y {
game_core.master_camera.target = game_core.player.position - (window_center / 2.0);
}
// // Clamp camera target y to 0
// if game_core.master_camera.target.y < -100.0 {
// game_core.master_camera.target.y = -100.0;
// }
}
pub fn render_player(context_2d: &mut RaylibMode2D<RaylibDrawHandle>, game_core: &mut GameCore) {

4
src/logic/mainmenu.rs
View File

@ -28,11 +28,11 @@ impl Screen for MainMenuScreen {
let win_width = draw_handle.get_screen_width();
// Clear frame
draw_handle.clear_background(Color::WHITE);
draw_handle.clear_background(Color::BLUE);
// Render title
draw_handle.draw_text(
"TMP TITLE",
"ONE BREATH",
(win_height / 2) - 80,
win_width / 4,
40,

11
src/logic/pausemenu.rs
View File

@ -7,7 +7,7 @@ use crate::{
use super::screen::Screen;
const SCREEN_PANEL_SIZE: Vector2 = Vector2 { x: 300.0, y: 300.0 };
const SCREEN_PANEL_SIZE: Vector2 = Vector2 { x: 300.0, y: 380.0 };
pub struct PauseMenuScreen {}
@ -118,6 +118,15 @@ impl Screen for PauseMenuScreen {
}
}
// Render credits
draw_handle.draw_text(
"Credits:\n\t- @ewpratten\n\t- @rsninja722\n\t- @wm-c\n\t- @catarinaburghi",
(win_width / 2) - (SCREEN_PANEL_SIZE.x as i32 / 2) + 10,
(win_height / 2) - (SCREEN_PANEL_SIZE.y as i32 / 2) + 120,
20,
Color::BLACK,
);
// Close and quit buttons
let bottom_left_button_dimensions = Rectangle {
x: (win_width as f32 / 2.0) - (SCREEN_PANEL_SIZE.x / 2.0) + 5.0,

9
src/main.rs
View File

@ -13,14 +13,14 @@ use lib::{utils::profiler::GameProfiler, wrappers::audio::player::AudioPlayer};
use log::info;
use logic::{gameend::GameEndScreen, ingame::InGameScreen, loadingscreen::LoadingScreen, mainmenu::MainMenuScreen, pausemenu::PauseMenuScreen, screen::Screen};
use raylib::prelude::*;
use world::World;
use world::{World, load_world_colliders};
// Game Launch Configuration
const DEFAULT_WINDOW_DIMENSIONS: Vector2 = Vector2 {
x: 1080.0,
y: 720.0,
};
const WINDOW_TITLE: &str = r"Ludum Dare 48";
const WINDOW_TITLE: &str = r"One Breath";
const MAX_FPS: u32 = 60;
fn main() {
@ -32,7 +32,7 @@ fn main() {
.size(
DEFAULT_WINDOW_DIMENSIONS.x as i32,
DEFAULT_WINDOW_DIMENSIONS.y as i32,
)
).msaa_4x()
.title(WINDOW_TITLE)
.build();
raylib.set_target_fps(MAX_FPS);
@ -41,7 +41,8 @@ fn main() {
raylib.set_exit_key(None);
// Load the world
let world = World::load_from_json("./assets/worlds/mainworld.json".to_string()).expect("Failed to load main world JSON");
let world_colliders = load_world_colliders("./assets/img/map/cave.json".to_string()).expect("Failed to load world colliders");
let world = World::load_from_json("./assets/worlds/mainworld.json".to_string(), world_colliders).expect("Failed to load main world JSON");
// Load the game progress
let game_progress = GameProgress::try_from_file("./assets/savestate.json".to_string());

14
src/pallette.rs
View File

@ -20,3 +20,17 @@ pub const TRANSLUCENT_WHITE_64: Color = Color {
b: 255,
a: 64,
};
pub const SKY: Color = Color {
r: 15,
g: 193,
b: 217,
a: 255
};
pub const WATER: Color = Color {
r: 24,
g: 66,
b: 143,
a: 255
};

46
src/player.rs
View File

@ -1,6 +1,6 @@
use raylib::math::Vector2;
use raylib::math::{Rectangle, Vector2};
use crate::lib::utils::triangles::rotate_vector;
#[derive(Debug, Default)]
pub struct Player {
@ -12,20 +12,48 @@ pub struct Player {
pub breath_percent: f32,
pub is_moving: bool,
pub is_boosting: bool,
pub is_boost_charging: bool
pub is_boost_charging: bool,
}
impl Player {
pub fn new() -> Self {
pub fn new(spawn: &Vector2) -> Self {
Self {
boost_percent: 1.0,
size: Vector2 {
x: 11.0,
y: 21.0
},
size: Vector2 { x: 11.0, y: 21.0 },
breath_percent: 1.0,
position: spawn.clone(),
..Default::default()
}
}
}
pub fn collides_with_rec(&self, rectangle: &Rectangle) -> bool {
// // Build a bounding box of the player by their corners
// let top_left_corner = self.position - (self.size / 2.0);
// let bottom_right_corner = self.position + (self.size / 2.0);
// let top_right_corner = Vector2 {
// x: bottom_right_corner.x,
// y: top_left_corner.y,
// };
// let bottom_left_corner = Vector2 {
// x: top_left_corner.x,
// y: bottom_right_corner.y,
// };
// // Get the rotation
// let rotation = Vector2::zero().angle_to(self.direction);
// // Rotate the bounds
// let top_left_corner = rotate_vector(top_left_corner, rotation);
// let bottom_right_corner = rotate_vector(bottom_right_corner, rotation);
// let top_right_corner = rotate_vector(top_right_corner, rotation);
// let bottom_left_corner = rotate_vector(bottom_left_corner, rotation);
// // Check for collisions
// return rectangle.check_collision_point_rec(top_left_corner)
// || rectangle.check_collision_point_rec(bottom_right_corner)
// || rectangle.check_collision_point_rec(top_right_corner)
// || rectangle.check_collision_point_rec(bottom_left_corner);
return rectangle.check_collision_circle_rec(self.position, (self.size.y * 0.5) / 2.0);
}
}

7
src/resources.rs
View File

@ -16,6 +16,9 @@ pub struct GlobalResources {
pub player_animation_regular: FrameAnimationWrapper,
pub player_animation_boost_charge: FrameAnimationWrapper,
pub player_animation_boost: FrameAnimationWrapper,
// Cave
pub cave_mid_layer: Texture2D
}
impl GlobalResources {
@ -56,6 +59,10 @@ impl GlobalResources {
21,
30,
),
cave_mid_layer: raylib.load_texture_from_image(
&thread,
&Image::load_image("./assets/img/map/cave.png")?,
)?,
})
}
}

31
src/world.rs
View File

@ -1,6 +1,6 @@
use std::{fs::File, io::BufReader};
use raylib::math::Vector2;
use raylib::math::{Rectangle, Vector2};
use serde::{Deserialize, Serialize};
use std::io::Read;
use failure::Error;
@ -10,16 +10,20 @@ use crate::entities::fish::FishEntity;
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct World {
pub end_position: Vector2,
pub player_spawn: Vector2,
#[serde(rename = "fish")]
pub fish_positions: Vec<Vector2>,
#[serde(skip)]
pub fish: Vec<FishEntity>
pub fish: Vec<FishEntity>,
#[serde(skip)]
pub colliders: Vec<Rectangle>
}
impl World {
pub fn load_from_json(file: String) -> Result<Self, Error> {
pub fn load_from_json(file: String, colliders: Vec<Rectangle>) -> Result<Self, Error> {
// Load the file
let file = File::open(file)?;
let reader = BufReader::new(file);
@ -30,6 +34,17 @@ impl World {
// Init all fish
result.fish = FishEntity::new_from_positions(&result.fish_positions);
// Init colliders
result.colliders = Vec::new();
for collider in colliders.iter(){
result.colliders.push(Rectangle {
x: collider.x - (collider.width / 2.0),
y: collider.y - (collider.height / 2.0),
width: collider.width,
height: collider.height,
});
}
Ok(result)
}
@ -45,3 +60,13 @@ impl World {
}
}
}
pub fn load_world_colliders(file: String) -> Result<Vec<Rectangle>, Error> {
// Load the file
let file = File::open(file)?;
let reader = BufReader::new(file);
// Deserialize
Ok(serde_json::from_reader(reader)?)
}