I have the following code:
import javax.sqing.JOptionPane;
public class DebugTwo4
{
public static void main(String[] args)
{
string costString;
double cost;
final double TAX = 0.06;
costString = JOptionPane.showInputDialog("Enter price of item you are buying", "Purchases", JOptionPane.INFORMATION_MESSAGE);
cost = double.parsecost (coststring);
JOptionPane.showMessageDialog(null,"With " + TAX * 100 + "% tax, purchase is $" + (cost - cost * TAX));
}
}
I am getting the following errors:
DebugTwo4.java:11: error: class expected
cost = double.parsecost (coststring);
DebugTwo4.java:11: error: ';' expected
cost = double.parsecost (coststring);
Please help!
Not sure what parsecost is supposed to do since I don't see a definition for it anywhere, but from what I understand could you not change this line:
cost = double.parsecost (coststring);
To something like this:
cost = Double.parseDouble(coststring);
I want to swap numbers of four digits number that enter users. And I wrote that codes
private void btnSwap_Click(object sender, EventArgs e)
{
int number, digit1, digit2, digit3, digit4;
number = Convert.ToInt32(txtNumber.Text);
digit1 = number % 10;
digit2 = (number / 10) % 10;
digit3 = (number / 100) % 10;
digit4 = (number / 1000) % 10;
digit4 = digit1;
digit1 = digit3;
digit3 = digit2;
digit2 = digit1;
lbReserved.Text = number.ToString();
}
But that codes return same number ? How to do it?
Theay are already reversed due to your maths, no need to swap the variables. So you just need to create a new int if you want:
int reversedNumber = int.Parse(string.Concat(digit1, digit2, digit3, digit4));
If you want an even more concise version without maths:
int reversedNumber = int.Parse(string.Concat(txtNumber.Text.TrimStart('0').Reverse()));
You can do it swapping chars of string recursively.
Here's the example.
private void btnSwap_Click(object sender, EventArgs e)
{
string number = txtNumber.Text;
lbReserved.Text = reverseString(number);
}
private string reverseString(string str)
{
string result = "";
if (str.length() == 1)
{
result = str;
}
else
{
result += str.charAt(str.length() - 1) + reverseString(str.substring(0, str.length() - 1));
}
return result;
}
I have a cassandra table with user name, latitude and longitude. I would like to get a list of users who are inside the circle with a given latitude, longitude and distance.
For example: my input Lat= 78.3232 and Long = 65.3234 and distance = 30 miles.
I would like to get a list of users who are within 30 miles distance from the point 78.3232 and 65.3234. Is it possible to solve this with single CQL3 query? Or can anyone give me a hint start solving this query?
There was no geospatial support for cassandra so I found a way to Implement it mathematically to generate box coordinates around the point (That was good enough for my work) and use query to get coordinates within boundary.
I'll post the code for others reference.
public class GeoOperations {
public static final int UPPER_LATITUDE = 0;
public static final int LOWER_LATITUDE = 1;
public static final int UPPER_LONGITUDE = 2;
public static final int LOWER_LONGITUDE = 3;
private static final double KM_TO_MILES = 0.621371;
private final double Latitude;
private final double Longitude;
double Boundary[];
public GeoOperations(double init_latitude, double init_longitude) {
Latitude = init_latitude;
Longitude = init_longitude;
Boundary = new double[4];
}
public void GenerateBoxCoordinates(double Distance) {
Distance = Distance * KM_TO_MILES;
double Lat_Factor = (Distance) / 69;
Boundary[UPPER_LATITUDE] = Latitude + Lat_Factor;
Boundary[LOWER_LATITUDE] = Latitude - Lat_Factor;
double Long_Factor = (Distance) / (3960 * 2 * Math.PI / 360 * Math.cos(Latitude));
Boundary[UPPER_LONGITUDE] = Longitude + Long_Factor;
Boundary[LOWER_LONGITUDE] = Longitude - Long_Factor;
for (double x : Boundary) {
System.out.println(x);
}
}
}
And then Used Simple CQL to find coordinates within ranges
if values are like this
UPPER_LATITUDE = 60
LOWER_LATITUDE = 40
UPPER_LONGITUDE = 10
LOWER_LONGITUDE = 5
Query will be something like this (actually I used kundera with Hibernate and used a JPA query. So I havent tested it but it should work)
SELECT * FROM Points_Tablle
WHERE LATITUDE > 40
AND LATITUDE < 60
AND LONGITUDE > 5
AND LONGITUDE < 10;
If you're using DataStax enterprise, you get Geospatial out of the box. Check out Patrick's Demo:
https://github.com/PatrickCallaghan/datastax-geospatial-demo
I'm working on a code to count the amount of spaces/digits/letters inside a given input using a loop. I am trying to use the .isdigit() and .isalpha() method to see if each letter in the string is a letter or number, and if true, adding it to the count. My code looks perfect to me, but when I run it, I only get the count for length and spaces (Which is not using the .isspace() method)
Perhaps I am messing up when updating the count within my loop but again.. it all looks good to me, could anyone help steer me in the right direction?
def main():
sentence = input('Enter a sentence: ')
printStats(sentence)
def printStats(input):
print('Statistics on your sentence: ')
print(' Characters:', charCount(input))
print(' Letters:', letterCount(input))
print(' Digits:', digitCount(input))
print(' Spaces:', spaceCount(input))
def charCount(input):
for char in input:
return len(input)
#Section below is where I need help
def letterCount(input):
count=0
for letter in input:
if input.isalpha():
count += 1
return count
def digitCount(input):
count=0
for digit in input:
if input.isdigit():
count += 1
return count
#Section above is where I need help
def spaceCount(input):
for space in input:
return input.count(" ")
main()
Thanks for your time
package com.drools;
public class TEST {
public static void main(String[] args) {
int charCount = 0;
int digitCount = 0;
String word = "NEW YORK 1";
String data[];
int k = 0;
data = word.split("");
int data1 = word.length();
char temp;
for (int i1 = 0; i1 < word.length(); i1++) {
temp = word.charAt(i1);
if (Character.isLetter(temp)) {
charCount++;
} else if (Character.isDigit(temp)) {
digitCount++;
for (int i = 0; i < data.length; i++) {
if (data[i].equals(" ")) {
k++;
}
}
System.out.println("total count "+ data1 + "||number of spaces in the entire word "+ k + " ||characters " + charCount+ " || digits" + digitCount);
}
}}
}
**Out put:**
total count 10||number of spaces in the entire word 2 ||characters 7 || digits1
You need to do letter.isalpha() and digit.isdigit() instead of calling them on the entire input.
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class LettersDigitsSpace {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Pattern pletter = Pattern.compile("[a-zA-Z]");
Pattern pdigit = Pattern.compile("\\d");
Pattern pwhitespace = Pattern.compile("\\s");
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println("--- Letters, Digits, and White Spaces counter ---");
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("Enter String: ");
String val = input.nextLine();
Matcher mletter = pletter.matcher(val);
Matcher mdigit = pdigit.matcher(val);
Matcher mspace = pwhitespace.matcher(val);
int countl = 0, countd = 0, counts = 0;
while (mletter.find()) {
countl++;
}
while (mdigit.find()) {
countd++;
}
while (mspace.find()) {
counts++;
}
System.out.println("\nLetter count: "+countl+"\nDigit count: " + countd + "\nWhite Space count: " + counts);
}
}
I am making a simplified version of the ball physics app found at this SO question. I gained a lot from reading through the code and links provided at that question, but in my program I do not use vectors, I just update the coordinates of my balls (each of which has a random angle and speed) with trigonometry functions when they hit the walls.
There is info all over the place for how to handle ball to ball collisions without trigonometry, but I have found none that explain how it can be done with trigonometry.
--EDIT 9/13/2010--
Success... kind of... I got done what I wanted to do, but I was unable to do it how I wanted. If there is a way to calculate ball to ball collisions without the use of vectors it has eluded me. Even so, vectors do seem to be an easier way to handle collisions of all types... I just wish I would have known that when I started my program... would have saved me two or three days of work :) All the code for my (complete?) program is below. I added some neat features like shadows and a decreasing ball radius which really lets you see the difference in the mass of two balls when a big ball hits a small ball. In total there are five class files, AddLogic.java, Ball.java, BallBuilder.java, MouseEventHandler.java, and Vector2D.java.
AddLogic.java
import java.awt.*;
import java.awt.Graphics2D;
import java.awt.image.BufferStrategy;
import java.util.ArrayList;
public class AddLogic implements Runnable {//Make AddLogic a runnable task.
private BallBuilder ballBuilder;
private BufferStrategy strategy;
private static ArrayList objectsToDraw = new ArrayList();
private int floorHeight = 33;
public AddLogic(BallBuilder ballBuilder, BufferStrategy strategy) {
this.ballBuilder = ballBuilder;
this.strategy = strategy;
}
private void logic(BallBuilder ballBuilder, BufferStrategy strategy) {
this.ballBuilder = ballBuilder;
this.strategy = strategy;
while (true) {//Main loop. Draws all objects on screen and calls update methods.
Graphics2D g = (Graphics2D) strategy.getDrawGraphics();//Creates the Graphics2D object g and uses it with the double buffer.
g.setColor(Color.gray);
g.fillRect(0, 0, ballBuilder.getWidth(), ballBuilder.getHeight());//Draw the wall.
g.setColor(Color.lightGray);
g.fillRect(0, ballBuilder.getHeight() - floorHeight, ballBuilder.getWidth(), floorHeight);//Draw the floor.
g.setColor(Color.black);
g.drawLine(0, ballBuilder.getHeight() - floorHeight, ballBuilder.getWidth(), ballBuilder.getHeight() - floorHeight);//Draw the line between the wall and floor.
if (objectsToDrawIsEmpty() == true) {//If no balls have been made display message telling users how to make new ball.
g.setColor(Color.red);
g.drawString("Click Mouse For New Ball", (ballBuilder.getWidth() / 2) - 70, ballBuilder.getHeight() / 2);
}
for (int i = 0; i < objectsToDraw.size(); i++) {//Draw shadows for all balls.
Ball ball = (Ball) objectsToDraw.get(i);
g.setColor(Color.darkGray);
g.fillOval(
(int) ball.ballPosition.getX() - (int) ((ball.ballPosition.getY() / (350 / ball.getBallRadius())) / 2),
ballBuilder.getHeight() - (floorHeight / 2) - (int) ((ball.ballPosition.getY() / (1250 / ball.getBallRadius())) / 2),
(int) ball.ballPosition.getY() / (350 / ball.getBallRadius()),
(int) ball.ballPosition.getY() / (1250 / ball.getBallRadius()));
}
for (int i = 0; i < objectsToDraw.size(); i++) {//Draw all balls by looping through them and checking for any vector or collision updates that need to be made.
Ball ball = (Ball) objectsToDraw.get(i);
g.setColor(ball.getBallColor());
g.fillOval(
(int) ball.ballPosition.getX() - ball.getBallRadius(),
(int) ball.ballPosition.getY() - ball.getBallRadius(),
ball.getBallRadius() * 2,
ball.getBallRadius() * 2);
vectorUpdate(ball);//Update ball vector coordinates.
collisionCheck(ball);//Check ball to ball and ball to wall collisions.
}
if (MouseEventHandler.mouseEventCheck() == true) {// Creates a new ball when mouse is clicked.
Ball ball = new Ball(ballBuilder);
objectsToDraw.add(ball); //Adds the new ball to the array list.
MouseEventHandler.mouseEventUpdate(); //Resets the mouse click event to false.
}
g.dispose();//To aid Java in garbage collection.
strategy.show();//Show all graphics drawn on the buffer.
try {//Try to make thread sleep for 5ms. Results in a frame rate of 200FPS.
Thread.sleep(5);
}
catch (Exception e) {//Catch any exceptions if try fails.
}
}
}
private void vectorUpdate(Ball ball) {//Update the ball vector based upon the ball's current position and its velocity.
ball.ballPosition.setX(ball.ballPosition.getX() + ball.ballVelocity.getX());
ball.ballPosition.setY(ball.ballPosition.getY() + ball.ballVelocity.getY());
}
private void collisionCheck(Ball ball) {//Check for ball to wall collisions. Call check for ball to ball collisions at end of method.
if (ball.ballPosition.getX() - ball.getBallRadius() < 0) {//Check for ball to left wall collision.
ball.ballPosition.setX(ball.getBallRadius());
ball.ballVelocity.setX(-(ball.ballVelocity.getX()));
ball.decreaseBallRadius(ball);//Decrease ball radius by one pixel. Called on left, top, and right walls, but not bottom because it looks weird watching shadow get smaller during bottom bounce.
}
else if (ball.ballPosition.getX() + ball.getBallRadius() > ballBuilder.getWidth()) {//Check for ball to right wall collision.
ball.ballPosition.setX(ballBuilder.getWidth() - ball.getBallRadius());
ball.ballVelocity.setX(-(ball.ballVelocity.getX()));
ball.decreaseBallRadius(ball);//Decrease ball radius by one pixel. Called on left, top, and right walls, but not bottom because it looks weird watching shadow get smaller during bottom bounce.
}
if (ball.ballPosition.getY() - ball.getBallRadius() < 0) {//Check for ball to top wall collision.
ball.ballPosition.setY(ball.getBallRadius());
ball.ballVelocity.setY(-(ball.ballVelocity.getY()));
ball.decreaseBallRadius(ball);//Decrease ball radius by one pixel. Called on left, top, and right walls, but not bottom because it looks weird watching shadow get smaller during bottom bounce.
}
else if (ball.ballPosition.getY() + ball.getBallRadius() + (floorHeight / 2) > ballBuilder.getHeight()) {//Check for ball to bottom wall collision. Floor height is accounted for to give the appearance that ball is bouncing in the center of the floor strip.
ball.ballPosition.setY(ballBuilder.getHeight() - ball.getBallRadius() - (floorHeight / 2));
ball.ballVelocity.setY(-(ball.ballVelocity.getY()));
}
for (int i = 0; i < objectsToDraw.size(); i++) {//Check to see if a ball is touching any other balls by looping through all balls and checking their positions.
Ball otherBall = (Ball) objectsToDraw.get(i);
if (ball != otherBall && Math.sqrt(Math.pow(ball.ballPosition.getX() - otherBall.ballPosition.getX(), 2.0) + Math.pow(ball.ballPosition.getY() - otherBall.ballPosition.getY(), 2.0)) < ball.getBallRadius() + otherBall.getBallRadius()) {
resolveBallToBallCollision(ball, otherBall);//If the ball is hitting another ball calculate the new vectors based on the variables of the balls involved.
}
}
}
private void resolveBallToBallCollision(Ball ball, Ball otherBall) {//Calculate the new vectors after ball to ball collisions.
Vector2D delta = (ball.ballPosition.subtract(otherBall.ballPosition));//Difference between the position of the two balls involved in the collision.
float deltaLength = delta.getLength();//The (x, y) of the delta squared.
Vector2D minimumTranslationDistance = delta.multiply(((ball.getBallRadius() + otherBall.getBallRadius()) - deltaLength) / deltaLength);//The minimum distance the balls should move apart once they.
float ballInverseMass = 1 / ball.getBallMass();//half the ball mass.
float otherBallInverseMass = 1 / otherBall.getBallMass();//half the other ball mass.
ball.ballPosition = ball.ballPosition.add(minimumTranslationDistance.multiply(ballInverseMass / (ballInverseMass + otherBallInverseMass)));//Calculate the new position of the ball.
otherBall.ballPosition = otherBall.ballPosition.subtract(minimumTranslationDistance.multiply(otherBallInverseMass / (ballInverseMass + otherBallInverseMass)));//Calculate the new position of the other ball.
Vector2D impactVelocity = (ball.ballVelocity.subtract(otherBall.ballVelocity));//Find the veloicity of the impact based upon the velocities of the two balls involved.
float normalizedImpactVelocity = impactVelocity.dot(minimumTranslationDistance.normalize());//
if (normalizedImpactVelocity > 0.0f) {//Returns control to calling object if ball and other ball are intersecting, but moving away from each other.
return;
}
float restitution = 2.0f;//The constraint representing friction. A value of 2.0 is 0 friction, a value smaller than 2.0 is more friction, and a value over 2.0 is negative friction.
float i = (-(restitution) * normalizedImpactVelocity) / (ballInverseMass + otherBallInverseMass);
Vector2D impulse = minimumTranslationDistance.multiply(i);
ball.ballVelocity = ball.ballVelocity.add(impulse.multiply(ballInverseMass));//Change the velocity of the ball based upon its mass.
otherBall.ballVelocity = otherBall.ballVelocity.subtract(impulse.multiply(otherBallInverseMass));//Change the velocity of the other ball based upon its mass.
}
public static boolean objectsToDrawIsEmpty() {//Checks to see if there are any balls to draw.
boolean empty = false;
if (objectsToDraw.isEmpty()) {
empty = true;
}
return empty;
}
public void run() {//Runs the AddLogic instance logic in a new thread.
logic(ballBuilder, strategy);
}
}
Ball.java
import java.awt.*;
public class Ball {
private int ballRadius;
private float ballMass;
public Vector2D ballPosition = new Vector2D();
public Vector2D ballVelocity = new Vector2D();
private Color ballColor;
public Ball(BallBuilder ballBuilder) {//Construct a new ball.
this.ballRadius = 75;//When ball is created make its radius 75 pixels.
this.ballMass = ((float)(4 / 3 * Math.PI * Math.pow(ballRadius, 3.0)));//When ball is created make its mass that the volume of a sphere the same size.
this.ballPosition.set(ballRadius, ballBuilder.getHeight() - ballRadius);//When ball is created make its starting coordinates the bottom left hand corner of the screen.
this.ballVelocity.set(randomVelocity(), randomVelocity());//When ball is created make its (x, y) velocity a random value between 0 and 2.
if (AddLogic.objectsToDrawIsEmpty() == true) {//If the ball being created is the first ball, make it blue, otherwise pick a random color.
this.ballColor = Color.blue;
} else {
this.ballColor = randomColor();
}
}
public void decreaseBallRadius(Ball ball){//Decrease the ball radius.
if(ball.getBallRadius() <= 15){//If the ball radius is less than or equal to 15 return control to calling object, else continue.
return;
}
ball.setBallRadius(ball.getBallRadius() - 1);//Decrease the ball radius by 1 pixel.
ball.setBallMass((float)(4 / 3 * Math.PI * Math.pow(ballRadius, 3.0)));//Recalcualte the mass based on the new radius.
}
public int getBallRadius() {
return ballRadius;
}
public float getBallMass(){
return ballMass;
}
public Color getBallColor() {
return ballColor;
}
private void setBallRadius(int newBallRadius) {
this.ballRadius = newBallRadius;
}
private void setBallMass(float newBallMass){
this.ballMass = newBallMass;
}
private float randomVelocity() {//Generate a random number between 0 and 2 for the (x, y) velocity of a ball.
float speed = (float)(Math.random() * 2);
return speed;
}
private Color randomColor() {//Generate a random color for a new ball based on the generation of a random red, green, and blue value.
int red = (int) (Math.random() * 255);
int green = (int) (Math.random() * 255);
int blue = (int) (Math.random() * 255);
ballColor = new Color(red, green, blue);
return ballColor;
}
}
BallBuilder.java
import java.awt.*;
import java.awt.image.*;
import java.util.concurrent.*;
import javax.swing.*;
public class BallBuilder extends Canvas{
private int frameHeight = 600;
private int frameWidth = 800;
private static BufferStrategy strategy;//Create a buffer strategy named strategy.
public BallBuilder(){
setIgnoreRepaint(true);//Tell OS that we will handle any repainting manually.
setBounds(0,0,frameWidth,frameHeight);
JFrame frame = new JFrame("Bouncing Balls");
JPanel panel = new JPanel();
panel.setPreferredSize(new Dimension(frameWidth, frameHeight));
panel.add(this);
frame.setContentPane(panel);
frame.pack();
frame.setResizable(false);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
addMouseListener(new MouseEventHandler());
createBufferStrategy(2);//Create a double buffer for smooth graphics.
strategy = getBufferStrategy();//Apply the double buffer to the buffer strategy named strategy.
}
public static void main(String[] args) {
BallBuilder ballBuilder = new BallBuilder(); // Creates a new ball builder.
ExecutorService executor = Executors.newSingleThreadExecutor();//Creates a thread executor that uses a single thread.
executor.execute(new AddLogic(ballBuilder, strategy));//Executes the runnable task AddLogic on the previously created thread.
}
}
MouseEventHandler.java
import java.awt.event.*;
public class MouseEventHandler extends MouseAdapter{
private static boolean mouseClicked = false;
public void mousePressed(MouseEvent e){//If either of the mouse buttons is pressed the mouse clicked variable is set to true.
mouseClicked = true;
}
public static void mouseEventUpdate(){//When called, sets the mouse clicked variable back to false.
mouseClicked = false;
}
public static boolean mouseEventCheck(){//Returns the state of the mouse clicked variable.
if(mouseClicked){
return true;
}
else{
return false;
}
}
}
Vector2D
public class Vector2D {//A class that takes care of ball position and speed vectors.
private float x;
private float y;
public Vector2D() {
this.setX(0);
this.setY(0);
}
public Vector2D(float x, float y) {
this.setX(x);
this.setY(y);
}
public void set(float x, float y) {
this.setX(x);
this.setY(y);
}
public void setX(float x) {
this.x = x;
}
public void setY(float y) {
this.y = y;
}
public float getX() {
return x;
}
public float getY() {
return y;
}
public float dot(Vector2D v2) {//Speciality method used during calculations of ball to ball collisions.
float result = 0.0f;
result = this.getX() * v2.getX() + this.getY() * v2.getY();
return result;
}
public float getLength() {
return (float) Math.sqrt(getX() * getX() + getY() * getY());
}
public Vector2D add(Vector2D v2) {
Vector2D result = new Vector2D();
result.setX(getX() + v2.getX());
result.setY(getY() + v2.getY());
return result;
}
public Vector2D subtract(Vector2D v2) {
Vector2D result = new Vector2D();
result.setX(this.getX() - v2.getX());
result.setY(this.getY() - v2.getY());
return result;
}
public Vector2D multiply(float scaleFactor) {
Vector2D result = new Vector2D();
result.setX(this.getX() * scaleFactor);
result.setY(this.getY() * scaleFactor);
return result;
}
public Vector2D normalize() {//Speciality method used during calculations of ball to ball collisions.
float length = getLength();
if (length != 0.0f) {
this.setX(this.getX() / length);
this.setY(this.getY() / length);
} else {
this.setX(0.0f);
this.setY(0.0f);
}
return this;
}
}
The speed angle changes when the ball bounces, you should change it after each bounce.
Also, as you'll see later, the speed VALUE (called "modulus") also changes when two balls collide.
EDIT:::
It seems to me that you are accelerating the balls
The
int x = (int) (ball.getBallTempX() +
(ball.getBallPathLength() * Math.cos(ball.getBallAngle())));
Seems to correspond to
int x = (int) (ball.getBallTempX() +
(ball.getBallSpeed() * Math.cos(ball.getBallAngle())));
And the same for "y"
Am I right?
Edit 2::
In fact, you don't need the TempX,TempY,PreviousCenterX and PreviousCenterY either.
Try these methods
private int xCoordinateUpdate(Ball ball) {
int x = (int) (ball.getBallCenterX()+ (ball.Speed()
* Math.cos(ball.getBallAngle())));
return x;
(the same for Y)
Edit 3 ::
One more ... :)
What you need is to code is this formula (any other will fail when you attempt to collide balls):
Pseudocode >
BallCenterX = BallCenterX + BallSpeed * Math.cos(angle)
BallCenterY = BallCenterY + BallSpeed * Math.sin(angle)
Forget any "temp" and "old" values. They will impair your ball colliding feature.
I'll start this answer and keep editing it step by step until we are done. I'll try to guide you to a "semi-vectorized" version of the program, trying to minimize the effort.
Please keep updating the code as you progress, and commenting on my suggestions.
First, a few things:
In
private double randomBallAngle(){
ballAngle = Math.toRadians((Math.random()*90));
return ballAngle;
}
You are working in radians, but in yCoordinateUpdate and yCoordinateUpdate it seems that you are using the same angle in grads (because you are comparing with 90).
Using radians is easier for all the math involved.
Also, the vars GoingUp, etc are not needed since the speed angle will take care of that.
You may set the initial random angle in the interval (0 ... 2 Pi).
You should change (in fact reflect) the speed angle after each border collission (and afterwards, when we are done, after each inter-ball caollission too).
For this reflection, the laws are:
Upper or lower wall: New Angle = - OldAngle
For Right or left wall: New Angle = Pi - OldAngle
We'll keep reflections on the vertex for later ...