Welcome our .feature-Files

Hello everyone,

today we want to introduce you our new family members in our use-case-family, the .feature-File. It's much more readable than an Activity Diagram. First, we created them for our two existing use cases, set game rules and calculate score.


Game rules:

Feature: Game rules

       In order to set the game rules

As a triangle

I want to define the events for the different types of fields in the overworld

Scenario: Normal Field

       Given I want to move in any direction

       When I would move on a normal field

       Then I move forward

      

Scenario: Poison Field

       Given I want to move in any direction

       When I would move on a poison field

       Then I move forward

       And my energy consumption becomes higher

      

Scenario: Energy Field

       Given I want to move in any direction

       When I would move on an energy field

       Then I move forward

       And my energy becomes higher

      

Scenario: Wall Field

       Given I want to move in any direction

       When I would move on a poison field

       Then I don't move forward

      

Scenario: Death Field

       Given I want to move in any direction

       When I would move on a death field

       Then I don't move forward

       And I die

Calculate Score:

Feature: Calculate Score

       In order to rate a playthrough of the AI

As a Player

I want to calculate a number named highscore to see immediately if it was good or bad

Scenario: Display the score

       When I finished the game

       Then summarize the distance for every single triangle

       And the score is displayed

      

Scenario: Add score in highscore list

       Given the score is calculated

       When the score is higher then the last entry of the highscore list

       Then add score to correct position in highscore list

Soon you will find them also in our updated versions of the UseCase Specification.

Have a nice day,
TheLearningTriangle-Team

Jira / Burndown

Hey guys,

as you can see in our JIRA-Projectsite we had trouble connecting our github project with the JIRA-Application. We apologize that we can not provide two healthy sprints in our JIRA-Project. This is because we didnt manage ourselfes to update our progress continuously.

But, as a result, we learned that we should have done it well, since it is so much easier to collaborate to a project knowing what the other persons is doing. This would have minimized problems within our communication.

We are looking toward using JIRA or another platform for work tracking in the future.

Have a nice day,
TheLearningTriangle-Team

Use Case Specification - Two examples

Good evening guys,

over this long weekend we specificated two use cases, "Set game rules" and "calculate score". We want to show you our first results in this post. Look for them below.

Set game rules - Use Case Specification
Calculate Score - Use Case Specification

Thank you for visitng us,
LearningTriangleTeam

RUP: Defining roles

Hey Guys,

Today we want to talk about our team, Steven Kovacs and Marco Müller.
In a project it is important to be clear about everyones exercises and tasks next to coding.
Also in our project we want to define roles. We'll use IBM's RUP, a well-known system for business to give different roles to different members. For further information you can look at this site.

In a team with only two people it is really difficult to divorce between each role. But we tried to be as clear as possible, but some roles will be important for both of us. In the following picture you can see our team members and their roles in this project:

Next to our roles, we want to be clear about our technology. We already mentionted that we will use Tensorflow, an Open Source Software developed by researchers from the Google Brain Team. Our structure consists of two main parts (there will be much more parts, but for the explanation of our technology these both are the important ones):

The first part is our AI on a server, programmed in Python with Tensorflow. The other part is our "game", programmed in Java. This includes the game mechanics, the models and the graphical view. Also we want to use the following things:

• We will use the MVC pattern for our Java structure, not only because it keeps our code more organized, but also because structured code is important when using a server-structure.
•  Next to this, clean code is a realy important thing, so we will try to keep our code as simple and clean as possible. This means that we will use clean code patterns.
• One last thing to mention is that we want to develop our porgram test-driven. That means, that every single line of code we will write will be tested before we build our project. To guarantee the functionality of this we use JUnit in combination with Mockito, a Mocking-Framework.

It is a good question to ask why we try to follow these rules. Whoever programmed with clean code patterns and TDD (Test-Driven-Development) knows that it is sometimes really hard to resist the simple way of coding. But this simple way isn't in our opinion a good way. Structure and Overview lack when a project becomes to big and you haven't obey some standards.
Wer know that sometimes it will become really hard, but our goal is to to write good, clean code and resist every single temptation. That's the reason why we program our project this way!

Greets,
TheLearningTriangle-Team

First OpenGL graphics tested

Hello guys!

We just uploaded a test for our graphics library. We are going to use OpenGL (JOGL) to draw our little cute triangles. :)

You can download this test from our git-repository.

It's ugly but it works for now.

You can also move the triangle using wasd. It is moving on all pc's at the same speed, because we are including the time between two draw mechanisims.

We've had some fun moving this thing around. :)

- TheLearningTriangle Team

Setting up Tensorflow on a server

Hello everyone!

We now have setted up a linux server acting like a cloud for our tensorflow application providing same data and neuronal network for all developers!
We followed the instructions of Tensorflow Installation.
We also tested the new environment with the installation test and from the introduction page:

import tensorflow as tf
import numpy as np

# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3

# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but TensorFlow will
# figure that out for us.)
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b

# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)

# Before starting, initialize the variables.  We will 'run' this first.
init = tf.initialize_all_variables()

# Launch the graph.
sess = tf.Session()
sess.run(init)

# Fit the line.
for step in range(201):
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(W), sess.run(b))

# Learns best fit is W: [0.1], b: [0.3]

 by Tensorflow Introduction

Wow! We can learn mathematical rules and patterns!