# Collision Detection Part-1

Introduction
This tutorial is an introduction about collision detection and in this first part we will see how to detect collision between two circles. I will be using Python programming language to write the code and hope you are already familiar with Python language đź™‚

Collision between two circles
Here we will take two circles as our input, for each circle we will take the position and radius. Using this three values from each of the circle we can easily check the collision.

• Calculate the horizontal distance between the circle centers
• Calculate the vertical distance between the circle centers
• Form a right angle triangle using the horizontal distance as base and vertical distance as height
• Calculate the length of the hypotenuse using the base and height
• Calculate the distance between the center of the circles
• If hypotenuse calculated is less than the distance between the center of the circles we can say a collision occurred.

The below given image describes three different cases of collision between two circles

How can we make use of the circle collision detection
Consider two objects having random shapes and you have to do some collision collision check between this two objects. Yes the exact collision detection between random shaped objects are not easy to achieve. But you can do the collision detection between this two with circles

• Define a mask for each of the shapes. Let the mask be a circle of a specific radius. The radius selected should be enough to cover (at least 80%) the random shaped object. Do the same for the second object
• Now all you have to do is processing this mask while checking collision. Since the mask defined for each object is circular in shape and cover 80% of the area, the collision checking will be easy and enough. đź™‚

The Program
The below given program is written in Python language and the things that we saw above is written step by step.

```import math

# Find the absolute value of a variable
def absolute_value(x):
if x < 0:
return 0 - x
return x

x_position = int(input("Enter circle " + str(number) + " x position: "))
y_position = int(input("Enter circle " + str(number) + "y position: "))
print()

# Create a right angle triangle and check for collision
# Take two circles as arguments and do the calculation
def check_collision(circle1, circle2):
base = absolute_value(circle1[1] - circle2[1])
height = absolute_value(circle1[2] - circle2[2])
hypotenuse = math.sqrt(base * base + height * height)
center_distance = circle1[0] + circle2[0]
if hypotenuse <= center_distance:
return True
return False

# The main method
# Print success message on collision
def main():

collision_status = check_collision(circle1, circle2)
if collision_status:
print("Success")
else:
print("Failed")

main()
```

Hope this tutorial was helpful đź™‚

# Developing a Mini Calculator Part -4

Hello, this is the final part of article on Developing a Mini Calculator. Here we will see how different modules interact with each other and the importance of central module called “Core” in detail.

As I mentioned in the previous topics this module is most important part of our calculator application, because it maintain the application state and do connect other modules with each other using messaging system. Input service, output service, calculation logic and history recorder send message to and receive message from core module. Core module do the state change using the messages received from input service and calculation logic.

How Core and other modules work together ?

Input Service generate message based on the key pressed by the user and send the message to core module. The message will have identifier to identify the message, key details. Core will process the message, do some state change and send required messages based on the state change to other modules. Below I will give you a example simple scenario.c

Example: “65+56=”

So once user press “=” operator key calculator should display result “121”.

1. User enter key 6: This will send message to core module. It will be store as first operand
2. User enter key 5: Since no operator is entered, core will append “5” to previously entered number “6” and make “65” the first operand
3. User enter “+” operator key: When processing this key press, core will do a state Â that tell operator is entered now it will accept the second operand. If user press any other operator key to change the operation, this will be taken care by core module using the previous state change.
4. The same way “56” will be accepted
5. Now core have first operand, operator and second operand. If user press the next operator key (-,+,*,/), core will send a message to calculation logic including this details. Calculation logic do the required calculation and send back the result to core.
6. The result given by calculation logic will be the new first operand. The same can be treated as final result as well based on the past input.
7. In the above steps, core will send the state changes to output service. Output service will display the state changes received to screen.

THE END

Hope you liked the final part đź™‚ .

Please access the previous topics here
Developing a Mini Calculator Part – 1
Developing a Mini Calculator Part – 2
Developing a Mini Calculator Part – 3

# Developing a Mini Calculator Part-3

Hello, this is third part of Developing a Mini Calculator. Today’s topic will cover Input Service and Output service module. Please read Developing a Mini Calculator Part-2 for understanding about Calculation logic.

Input Service

Like I said in the first section, input service is responsible for two things and they are accepting right input and preventing user from entering an input that may cause application behavior inconsistent. Input service alone can take someÂ decisions for preventing user inputs. But sometimes it is not possible and that decision making require application state.

Consider an example scenario “user pressing period or dot key”. I will explain how the decision making works

How input service alone take decisions?

• When application start input service will unlock period key
• If user press period keyÂ input service will lock the period key
• When user press period key it will send a message to core module saying user pressed period key

How input service take decision with the help of core module

• When user press backspace key after pressing period key, input service will send a message to core module. Core module will understand that user pressed backspace key and so do a state change and send back a message to input service. So by identifying this message from core, input service can enable or unlock the period key.

Output Service

Output service is responsible for managing the screen and doing this by showing allowed application state to the screen. Output service will do this with the help of core, because core manage the application state.

Consider an example scenario “userÂ entering number ‘6.’ and press backspace key to delete the dot character”

Hitting backspace key will initiate a message from input service to core. Core do the necessary state change and send a message to input service. After this core will send a message to output service Â to delete the dot character from screen.

• Once messages are defined we can use it uniquely across all modules
• Each module can be managed independently
• Since communication across modules are achieved using messages, so maintenance is easy

Here ends the third session on mini calculator development. Hope you liked it đź™‚ . In next topic I will explain about core module and communication between different modules using messages đź™‚

# Creating Slide Show using Java

Today i was doing some search in my personal computer prior to formatting the hard disk and to take backup of important files and I came across a small java source code file. I wrote this code during my collage days and did it as part of the technical exhibition conducted by my college. As part of it I got a chance to prepare some presentation on game development basics and created some slides. All I wanted was to run this slides (images) in an equal interval of time, so it will run continuously in circular fashion without any user intervention. The program will load the predefined images using the file name and display it for three seconds and move it to next image. After reaching the the last image, it will start again from the first image. I would like to share the code here đź™‚

Source Code

```import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

class JavaSlider extends JPanel implements Runnable {

private boolean active;
private JFrame parent;

public JavaSlider(JFrame parent) {
super();
active = false;
println("Panel created...");
this.parent = parent;
}

public void setActive(boolean status) {
active = true;
}

}

public void start() {
setActive(true);
}

@Override
public void run() {
int counter = 1;
String name = "";
while (active) {
try {
name = "slide" + counter + ".png";
println("Loaded file " + name + "...");
parent.setSize(image.getWidth() + 4, image.getHeight() + 32);
getGraphics().drawImage(image, 0, 0, image.getWidth(), image.getHeight(), this);
if (++counter > 23) {
println("Reseting counter...");
counter = 1;
}
} catch (IOException | InterruptedException ex) {
println("Interrupted...");
}
}
}

public static void main(String[] args) throws InterruptedException {
JFrame frame = new JFrame("Java Slider");
JavaSlider panel = new JavaSlider(frame);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(960, 720);
frame.setContentPane(panel);
frame.setResizable(false);
frame.setVisible(true);
frame.setLocation(0, 0);
public void windowClosing(WindowEvent we) {
panel.setActive(false);
};
});
panel.start();
}

public static void println(String message) {
System.out.println(message);
}
}
```

# Game Development Season 1

Hello, today I am going to show you how to develop a computer game where character run continuously along a straight road collecting points and avoiding obstacles.

What are the things required while developing this type of game?

Character development

The game have a main character. We have to give a proper behavior.

• Character can jump left or right, jump over the obstacles, slide under obstacles.
• Character will die when hit the obstacles and so game will end.
• Character can collect points from the road by hitting them.

World

World is where we have everything in picture. The road, points, obstacles and main character. The obstacles are vehicles and hurdles. The main character have to jump over vehicles and slide under the hurdles. Or simply jump left or right. The road will have three lines. Where vehicles move towards main character.

If you look close to such games you will see the main character is not moving forward or backward. That is the magic. The other things are actually moving. Got it?

Getting in to the Picture

The objects are created and placed in the world continuously in equal time interval in different patterns. This includes points or coins and obstacles. If you look at any such game you will find this pattern and the same pattern can come more than once.

Each time interval a pattern generator create patterns and based on the pattern objects will be placed in the world. At first the pattern is created for obstacles. Secondly the pattern is created for coins or points. While generating the second pattern we have to consider the pattern of obstacles. Got it?

The reason we are doing this is simple. When coins are placed in the world, ten or less coins can be placed in the line in an interval. We place coins continuously one by one. Say if the next position is occupied by an obstacle, we can place coin over the obstacle if it is a vehicle or do like this for hurdles by placing coins under hurdles. You got the picture right?

Once we finalize the patterns for the current time interval we can use the pattern to place the objects in the world and they will move towards main character đź™‚ . In these type of games pattern generation is important. Patterns must be created without continuously repetition. If we generate same pattern continuously, it will be boring. We can customize the patterns on demand by giving behaviors and look and feel.

Hope this tutorial gave you a small idea about running games đź™‚

# Developing a Mini Calculator Part-2

Hello, this is a continuation of article on Developing a Mini CalculatorÂ Part-1. In the first part I have explained about the components required for this application. TodayÂ we will see the implementation ofÂ Calculation Logic.

Note: I will be using Java programming language to demonstrate the examples

Calculation Logic

SinceÂ our calculator only support four operations and each of them take two operands and one operator it will be easy for us to write one single procedure or method which do all the necessary operation and return the result

```public static double doCalculate(double operand1, char operator, double operand2) {
double result = 0.0;
switch (operator) {
case '+': result = operand1 + operand2; break;
case '-': result = operand1 - operand2; break;
case '/': result = operand1 / opernad2; break;
case '*': result = operand1 * operand2; break;
}
return result;
}```

The above given method is seems good but what will happen if you divide a number with zero. Yes of course division by zero is not possible. In that case what we will do. One way is to insert an error handling code that do the required when such and error comes. Again think of other scenario where the result is infinity or not a number. What we will do again insert some logic to handle that scenario.

Instead of keeping all calculations in one method we can separate them, like one method for addition, one four subtraction etc. Each of them will take three arguments and return the expected result.

```public static double doCalculate(double operand1, char operator, double operand2) {
double result = 0.0;
switch (operator) {
case '+': result = doAddition(operand1, operand2); break;
case '-': result = doSubtraction(operand1, operand2); break;
case '/': result = doDivision(operand1, operand2); break;
case '*': result = doMultiplication(operand1 * operand2); break;
}
return result;
}

private static double doAddition(double operand1, double operand2) {
return (operand1) + (operand2);
}

private static double doSubtraction(double operand1, double operand2) {
return (operand1) - (operand2);
}

private static double doDivision(double operand1, double operand2) {
return (operand1) / (operand2);
}

private static double doMultiplication(double operand1, double operand2) {
return (operand1) * (operand2);
}```

Now we can manage each operation logic separately, say for division we can add extra error handling code

```private static double doDivision(double operand1, double operand2) {
double result = 0.0;
try {
result = operand1 / operand2;
catch (ArithmeticExceptionÂ ex) {
// set some flag to indicate this error
}
if (new Double(result).isNaN()) {
// set some flag to indicate this
result = 0.0;
} else if (!Double.isFinite(result)) {
// set some flag to indicate this
result = 0.0;
}
return result;
}```

If we look at the above program we will see two things. If the division leads to error we will set some flag and return zero. If the result is not a number or infinite we do the same. The flag might be some where else in the program. We have to introduce a state change some where out side the calculation logic. This is okay! because it doesn’t harm anything.

Instead of changing the state out side the calculation logic we can simply return the entire result out side the calculation logic. Say, the result, is it valid?, is it infinite?, is it an error. How we will do this?

```public class Result {
private double value;
private boolean error;
private boolean finite;
private boolean nan;

public Result() {
// initialize to default
}
// get and set methods will come here
}```

We can create a new Result object to do this. This object will keep all the information related to the operation carried out. The Calculation Logic simply return the final result with necessary information to process the result. So an external module say Core can process the result as required without worrying about the calculations đź™‚

Calculation Logic: Do the required calculations and return the result
Core: Process the result and take the necessary actions

```private static Result doDivision(double operand1, double operand2) {
Result result = new Result();
double value = 0.0;
try {
value = operand1 / operand2;
catch (ArithmeticExceptionÂ ex) {
result.setError(true);
}
result.setValue(value);
if (new Double(value).isNaN()) {
result.setNaN(true);
} else if (!Double.isFinite(result)) {
result.setFinite(false);
}
return result;
}```

Here ends the second part.Â Hope you like it đź™‚

In the next part we will see the implementation of other modules.

# Developing a Mini Calculator Part-1

Hello, today I will be talking about writing a simple mini calculator application which is capable of performing basic operations like addition, subtraction, multiplication and division.

The following are theÂ application requirements

• Addition, Subtraction, Multiplication and Division
• Support for negative numbers and fractions
• Record the operations performed by the user
• Clear screen or history at any moment

Below is the possible structure of our calculator application based on the above requirement

In the above image we canÂ see five modules and two end points. To give user the expected result a best possible connection or cooperation or communication between this five modules are required. Below we canÂ find the details of each module

Calculation Logic

This is one of the main application modules. It contain a set of calculation logic. Since our calculator only have four operations defined which require two operands and one operator, the calculation logic will have three inputs.This will do the required calculation using the inputs and return theÂ final result to Core module

Core

This is where we maintain the application state. By state we mean the set of variables which makes application functional and so to give expected results. It will tell other modules do that or do this on demand. This is done by the use of state maintained in the core. Next application state will be a result of current application state and current user input. Simply states are memory of this application.

Input Service

This is responsible mainly for two related things, accepting user input and preventing user from giving a bad input. By bad input we mean any key press that will push the application into an abnormal state. Say for example you are entering a real number ‘65.06’. After entering six and five user may enter the period ‘.’ character twice. This is wrong because ’65..06 is not a valid number. So the second period is not valid and so we have prevent this. This service also manage the UI. All are done with the help of Core module.

Output Service

This module manage the state of screen or display and that is where we see the expected output based on our input. Core module will give the content to Output Service. By content we mean the state changes that are allowed to be on the display. Output Service is responsible to filter thisÂ public information from the content given by Core module

History Recorder

Responsible for recording the calculator history or simply it logs every right input which end up giving an expected result. Say ‘a + b = c’. it will record this as an entry in the log table

Here ends the first part. Hope You like it đź™‚

In the next part we will seeÂ how to represent this things inÂ to object oriented program đź™‚