pong-cli 1.0.1

Play pong from the command-line!
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use super::system_prelude::*;

#[derive(Default)]
pub struct BallBounceSystem;

impl<'a> System<'a> for BallBounceSystem {
    type SystemData = (
        ReadExpect<'a, Settings>,
        ReadStorage<'a, Ball>,
        ReadStorage<'a, Collider>,
        WriteStorage<'a, Velocity>,
    );

    fn run(
        &mut self,
        (settings, balls, colliders, mut velocities): Self::SystemData,
    ) {
        let velocity_increase = (
            settings.ball.velocity_increase.0.abs(),
            settings.ball.velocity_increase.1.abs(),
        );

        for (_, collider, velocity) in
            (&balls, &colliders, &mut velocities).join()
        {
            let mut should_increase_x_velocity = false;

            // Bounce off paddles
            let paddle_collision_info = if velocity.x < 0.0 {
                if let Some(collision_info) = collider
                    .collision_info_with(&CollisionType::Paddle(Side::Left))
                {
                    velocity.x = velocity.x.abs();
                    should_increase_x_velocity = true;
                    Some(collision_info)
                } else {
                    None
                }
            } else if velocity.x > 0.0 {
                if let Some(collision_info) = collider
                    .collision_info_with(&CollisionType::Paddle(Side::Right))
                {
                    velocity.x = -velocity.x.abs();
                    should_increase_x_velocity = true;
                    Some(collision_info)
                } else {
                    None
                }
            } else {
                None
            };

            // Bounce off vertical walls
            if velocity.y < 0.0
                && collider.in_collision_with(&CollisionType::Wall(Side::Top))
            {
                velocity.y = velocity.y.abs();
            } else if velocity.y > 0.0
                && collider
                    .in_collision_with(&CollisionType::Wall(Side::Bottom))
            {
                velocity.y = -velocity.y.abs();
            }

            // Manipulate y velocity if collision with paddle top/bottom thirds
            if let Some(collision_info) = paddle_collision_info {
                match collision_info {
                    CollisionInfo::PaddleThird(PaddleThird::Top) => {
                        velocity.y -= velocity_increase.1;
                    }
                    CollisionInfo::PaddleThird(PaddleThird::Middle) => {
                        // Do nothing...
                    }
                    CollisionInfo::PaddleThird(PaddleThird::Bottom) => {
                        velocity.y += velocity_increase.1;
                    }
                    CollisionInfo::None => panic!(
                        "CollisionType::Paddle shoudn't have \
                         CollisionInfo::None"
                    ),
                }
            }

            // Increase x velocity
            if should_increase_x_velocity {
                match velocity.x {
                    x if x > 0.0 => velocity.x += velocity_increase.0,
                    x if x < 0.0 => velocity.x -= velocity_increase.0,
                    _ => velocity.x = velocity_increase.0,
                }
            }
        }
    }
}