Class started off with a brief discussion of what we have to look forward to this semester. This led to our first assignment, setting up a personal Linux powered workstation for upcoming projects and assignments. I decided to use the “garbage corner” as my workspace for this semester. While many may scoff at the idea of working in the garbage corner it has some benefits…

1. Distance from distractions
2. First “dibs” on the discard pile
3. Super quick escape in case of fire

Upon getting a table set up i decided to get my workstation in order. My machine is a glorious Dell Optiplex 755. After giving the machine a test boot i decided that it needed some tweaking. This is when garbage corner benefit #2 came to my aid. From the pile of broken PCs i was able to salvage 2 gigabytes of DDR2 memory, a PCI NIC, and a 160GB SATA II HDD. This morphed my sweet innocent Optiplex 755 into a powerful Linux workstation boasting features such as dual Gbit NICs, 4GB RAM, and dual 160GB HDDs (do i smell software raid?)

After getting the hardware portion of my workstation squared away i moved on to installing the operating system. I decided to go with a minimal install of Debian 8 (Jessie) and install what i need on top of the basic image. This led me to discover that my machine had a BIOS password. After a quick read over of this webpage i was able to quickly over come the issue and proceed with my installation. With Debian installed and updates downloading i decided to lend my time to help others overcome hardware issues.

This past week i took the time to get my machine completely tweaked and ready to start the linux from scratch process. I missed class on Thursday due to sickness..

Well here we are at week 3 and i have already found that this will be the one class i neglect the most. I have started Linux from scratch on a machine at my house. I remotely connect and work on it when i can. I decided to go the systemd route. Blah.

This week i finally made some progress on linux from scratch. Instead of using my school machine i started using an old computer i had at home. I set up ssh access so i am able to access it from the lair and work during class time. i was able to get half way into chapter 5 in one night! This sudden surge of productivity stemmed from two students demoing bootable LFS systems in class. Getting some what caught up is making me feel much better about this course. Matt has started mentioning that we will be using these LFS installations to set up and test different programs/services within our own network. This made me feel like using my own pc was a bad choice. I will probably just bring it in and set it up on my “desk” and remove it once the semester is complete or the project is done.

Break Week!

So i found some problems with my home computer plan… IT IS SLOW… like really slow… compiling is just not fun on a 1.7ghz Pentium 4. Remote reboots suck as well. This pushed me to make a plan of attack to complete Linux From Scratch in the limited time i have. I decided on a virtual machine. This will allow me to back up and revert to working copies if i break things while learning. This went much better than the remote Linux box from hell that i was using prior. Here is a linkto a copy of my virtual machine if anyone would like to use it.

I am very interested to see what we dive into once everyone gets a working copy of LFS. Matt was talking about setting up our own subnet for the class to use as a test network. This would allow us to all host a different service and teach/learn from really cool things!

This week we dove into getting out LFS machines networked! Matt gave us a crash course in basic networking starting with subnets and how to calculate them.

What is a subnet/subnetting? “A subnetwork, or subnet, is a logical, visible subdivision of an IP network. The practice of dividing a network into two or more networks is called subnetting. Computers that belong to a subnet are addressed with a common, identical, most-significant bit-group in their IP address.”

After getting assigned our own personal subnet we were instructed to configure our LFS machines to use our new networking settings. This was an easy task for all class members who sit at the main workstation table. As for 3 others and myself this is going to be a harder task. The workstation table has been switched over to the projects router allowing for everyone to use there subnet on the 10.80.3.xxx network. Mine however is a much larger task that is going to involve running an extremely long cable across the classroom or in the ceiling =( But to get started we must be able to take the first step… FINDING THE BOX OF CABLE! Lets see what this week brings.

Linux From Scratch seems to be dragging on for many people! While almost everyone in the class has set up there own subnet, only a few of us seem to have a working Linux From Scratch system. This is okay! This gives me time to play catch up in some other classes and get a head in this one. The best part of this week was finally getting my cable ran! Presley filled us in on the top secret location of the box of cable! Brian, Matt, and i ran the cable in just a short time and got my network up and running!

One problem i am trying to over come is getting a virtual box network interface card to work with my Linux From Scratch virtual Machine. I will have to use an external storage device to pass the driver to the vm and build it myself. This will be challenging but it is definitely not impossible.

Matt has also been pushing us to upgrade the bios of our work machines to the newest version available. Upon checking out my bios version i realized i already had the latest bios version! This saved me the headache of having to make a dos boot-able USB drive.

Next week i hope we move on to hosting services! I would really like to try and run a web server from my Linux From Scratch virtual machine. My first choice of web server would be Nginx but i would also consider Apache. I have a feeling that Apache would be the easiest web server to get set up due to it having a ton more documentation.

This week was a lazy week for EVERYONE! We spent most of our time talking and catching up with on another on a personal level. This was a very much needed refreshing week.

This week Matt introduced some potential projects that we could use to complete the objectives of the course. One that peaked my interest was updating/recreating the lair database server. Currently the server is a Xen virtual machine with 192MB of RAM, 1 vCPU, and 4GB of disk space running Debian 6.0 (squeeze). The current database is MySQL. Matt wants to update this server to Debian 8.0 (jessie) and move the database to MariaDB. This would be my first time setting up a database server! Hopefully this coming Monday i can get started.

This week Kyle Lockwood and i have been preparing machines to dive into the world of OpenStack. We decided that using Canonical Ubuntu OpenStack would be a good way to learn some of the basic workings of OpenStack before building our own installation. In order to use Canonical's OpenStack release we need to have seven machines with two hard drives each. Two of these machines need to have dual NICs (hypervisors). Kyle came up with the brilliant plan of using the CIST servers as our hypervisors as they have dual nics, TONS of ram, and hardware raid. The most challenging part of gathering the machines has been finding extra SATA cables. The Dell Optiplex 745 boxes we are using need extra long stat cables that have angled sata connectors on at least one end.

So after much research i have decided to abandon the OpenStack idea. I feel that learning OpenStack wouldn't be a wise use of my time. I have since decided to benchmark and compare multiple type 1 and type 2 hypervisors. Tomorrow i plan on installed debian on one of the old CIST servers and setting up Xen. This will also serve as a great platform for me to start building a test VM for working on the DB server. My goal is to have both the Xen benchmark and the DB server done for Thursday next week. I am looking forward to learning about MariaDB!

This past week i have been spending some time learning about the DB server and how to make the move to Debian 8 and MariaDB as smooth as possible. I learned quickly that backing up all of the databases will be an easy task to accomplish. This can be achieved with something along the lines of this command:

mysqldump --all-databases > all_databases.sql

Where the real problem lies is the compatibility between older versions of MySQL and MariaDB. Because we are running MySQL 5.1 we can only move our database back up to MariaDB 5.5… While this shouldn't be to much of an issue we are really shooting to use MariaDB 10. This is the latest stable version and is packaged in the Debian repos. I have encountered some methods of moving 5.5 database backups to 10 but it looks like a long tedious process. NOT FUN.

This week i helped Matt set up four machines to build a Linux cluster. Each machine needed 4gb of ram and had to be the same model. After testing many machines i discovered that finding 4 WORKING machines of the same model in the lair is actually a challenge by itself. Upon getting 4 working machines i went on to install debian 8 (jessie). This was done by utilizing the pxe server in the lair. While doing the debian installations i discovered from Matt that we had an internal debian update server. This helps cut down on getting the same pakages from the internet every time some one installs debian (which is quite often in the lair) I also realized kyle was using the old cist servers for a very cool bit coin project. This puts my hypervisor testing project on hold for now!

Break Week!

I need to come up with some cool ideas to start completing and documenting. I'm thinking about building a small Linux penetration testing virtual machine networking to learn about some popular tools such as metasploit and nessus. Documenting one penetration method a week would be a great way to learn about securing some popular services. This could also benefit others in the lair that express interest in security and penetration testing!

I have also started learning about web hosting/web development. I was able to obtain a free domain thanks to github! I plan to set up some sort of style sheet this week as well as register a SSL certificate. I plan to document setting up SSL for a web site when i do this!

Matt let me know over break that out of necessity he had to updated the database server. I was sad to hear this as it was a project i had interest in :/ But this also pushed me to come up with my own ideas for projects that interest me as well.

Jan 28, 2014

I have decided to document the setup, usage, and performace differences of multiple hypervisors. The intent of this document is to help other Lab46 users ch

Hypervisors can be broken down into two types:

• Type-1: Native or bare metal hypervisors
• Type-2: Hosted hypervisors

Type-1 hypervisors run directly on the host hardware allowing for hardware control and guest OS managability. Guest operating systmes are then run as processes on the host.

Examples of Type-1 hypervisors:

• Xen
• VMware ESX & ESXi
• Microsoft HyperV

Type-2 hypervisors run on top of existing operating systems much like web browsers or email clients. the hypervisor is then completely dependent upon the host operating system for its functionality.

Examples of Type-2 hypervisors:

• VMware Workstation
• Oracle Virtualbox

To get this project going i decided to use one of my personal servers. This is the system i will be using for all testing as to keep a consistent approach to each hypervisor i test. System:

• Opteron 1385 Quadcore CPU
• 16GB of 800mhz DDR2
• 6x1TB 7200RPM HDDs
• Software Raid 10

OS:

• Debian 8 (Jessie)

The first hypervisor i will be testing is KVM (Kernal Based Virtual Machine)

Step 1. Install KVM from Debian Repository

apt-get install qemu-kvm libvirt-bin

Step 2. To be able to manage virtual machines as a non-root user we will need to add our account to the groups kvm and libvirt

adduser "username" kvm
adduser "username" libvirt

Thats it! Now KVM is ready!

/*PLEASE READ
 THIS LATCH IS NOT A CLOCKED LATCH SO IT IS POSSIBLE TO EVALUATE VALUES THAT RESULT IN AN INVALID STATE!
*/
/*
Usage: To first use the RSNandLatch, just create a new RSNandObject
and send two Bitts that will be evaluated in the constructor.
To use different values after creating the object, change the r and s value properties
in the RSNandLatch object that was created and then call
the RSNandObject evaluate( ); method for that object.

Remember that the outputs from the RSNandLatch are q and qnot,
which should always have opposite state values EXCEPT in the invalid state.
*/

class RSNandLatch {

        //declaring some variables and objects that will be properties in our RSNandLatch object
        //s is the set input, r is the reset input, q is the first nand output, qnot is the second nand output
    Bitt s, r, q, qnot;
        //slastval and rlastval were needed because we needed some way to save the last input for checking which nand to evaluate first
        State slastval, rlastval;
        Nandd nandobject1, nandobject2;

        //creating constructor for initializing things in RSNandLatch
        //note that qnot and s must be initialized as 1 while r is initialized as 0 so that the latch is always started in a valide state
    public RSNandLatch(Bitt inp1, Bitt inp2) {
        qnot = new Bitt(State.PREFERRED);
                s = new Bitt(State.PREFERRED);
                nandobject1 = new Nandd( s, qnot );
                q = nandobject1.output;
                r = new Bitt(State.OTHER);
                nandobject2 = new Nandd( q, r );

                //change qnot to now point to nandobject2's output since the latch has now been built once around
                qnot = nandobject2.output;

                //needed slastval and rlastval for comparison to see what changed in selection statement below
                slastval = s.value;
                rlastval = r.value;

                //now that the latch should be in a completely valid state (note I said it SHOULD be XD - hopefully I dont have a logic error)
                //the actual values that were supposed to be evaluated can be evalutated, so re-evaluate the latch with the inputs given to constructor

                //set the actual input that we wanted to be evaluated and then evaluate
 s = inp1;
                r = inp2;
                evaluate ();
        }

    //evaluates the first nand object in the latch
        public void nandeval1( ) {
                        nandobject1.input1 = s;
                        nandobject1.input2 = qnot;
                        nandobject1.evaluate( );
                        q = nandobject1.output;
        }

        //evaluates the second nand object in the latch
        public void nandeval2( ) {
                        nandobject2.input1 = q;
                        nandobject2.input2 = r;
                        nandobject2.evaluate( );
                        qnot = nandobject2.output;
        }

        //set method simulates the case for if the first nand in the latch should be evaluated first.
        //this is used whenever the set bit value is changed whether the reset bit value is changed or not (covers both cases)
        public void set( ) {
                nandeval1( );
                nandeval2( );
        }

        //reset method simulates the case for if the second nand in the latch should be evaluated first.
        //this is used whenever the reset bit value is changed and the set bit is the same
        public void reset( ) {
                nandeval2( );
                nandeval1( );
        }

        //Evaluate function for the entire RSNandLatch
        public void evaluate( ) {
                //simple selection statement to decide which nand evaluate method to use
                if( s.value != slastval ) {
                        set( );
                }
                else if ( r.value != rlastval ) {
                        reset( );
                }

                //need to set slastval and rlastval to the new s and r values that may exist for future evaluations
                 slastval = s.value;
                rlastval = r.value;
    }

}

This is the code that has been consuming my life and making this semester the worst college experience i have had.

This past week has been very unproductive. I have been learning about some great pen testing tool sets but i still need to document how to use them. W3af is a new web exploit framework made by the creators of the widely known Metasploit Framework. Upon discovering this new tool i was puzzled as to why they would not make this a part of Metasploit its self? I soon learned this was due to is size! The amount of exploits available in w3af are almost equal to that of its older brother Metasploit. THIS IS INSANE! Metasploit encompasses all types of attacks where as W3af only focuses on web based attacks. W3af in conjunction with something like OWASP is a great way to find vulnerabilities in any website you need to pen test!

i have also been toying with the idea of building large Linux penetration testing tools in docker containers and using them as “appliances”. This would contain all of the programs dependencies inside the container! This keeps the host OS nice and clean. Segmentation is a great security tool all by itself ;)

http://www.6502.org/ http://nesdev.com/6502.txt

I missed class last week after getting super sick. This left me feeling very scared and intimidated by the course. I took a look a some of the code that is up for grabs. I feel that my skill set will be best applied to the shell scripting portion of this large project. Part of me knows that this course will be a great learning experience but it is also a lot to wrap me head around. =/

Last weeks class made me feel much more confident in my ability to contribute to this class project. Matt put my mind at easy as he breezed through TAX, showing us that the main goal is completeness by any means possible. The idea of learning from unconventional programming methods really appeals to my learning style. As i write this i am working on completing both TXS and TSX instruction scripts. While i haven't seen many contributions over the past week i am looking forward to next class to see what people are working on! I hope to have both instructions submitted to the repository before Wednesday.

# !/bin/bash                                                                                                                                                 │·················································
#                                                                                                                                                            │·················································
# INSTRUCTION:                                                                                                                                               │·················································
#       0x9A - Transfer X to S                                                                                                                               │·················································
#                                                                                                                                                            │·················································
# FUNCTION:                                                                                                                                                  │·················································
#       copy the contents of the X register to the stack pointer register                                                                                    │·················································
#                                                                                                                                                            │·················································
# FLAGS FLIPPED:                                                                                                                                             │·················································
#       N/A                                                                                                                                                  │·················································
#                                                                                                                                                            │·················································
                                                                                                                                                             │·················································
# Initialize Simulator Environment                                                                                                                           │·················································
source ../etc/simvar.sh                                                                                                                                      │·················································
                                                                                                                                                             │·················································
REGSRC="x"      # obtain from the X reg                                                                                                                      │·················································
REGDST="sp"      # copy into the SP reg                                                                                                                      │·················································
                                                                                                                                                             │·················································
# Copy the contents of source register into                                                                                                                  │·················································
# destination register                                                                                                                                       │·················································
cat ../reg/${REGSRC}.reg > ../reg/${REGDST}.reg                                                                                                              │·················································
                                                                                                                                                             │·················································
exit 0                   

This is just one of the complete instruction codes i am working on. Matt showed us how to complete more of these this week in class. Commits to the repository are looking pretty grim… BUT things will pick up I'm sure. This class makes me feel lost and unsure of what I'm doing. This maybe a feeling others share and could be a reason the repository isn't getting much love. This week I'm hoping we can regroup and feel out how everyone is feeling and what we need to address.

Break Week!

I finally finished up another instruction program. This one is TXS.

# !/bin/bash
#
# INSTRUCTION:
#       0xBA - Transfer X to S
#
# FUNCTION:
#       copy the contents of the X register to the stack pointer register
#
# FLAGS FLIPPED:
#       N/A
#

# Initialize Simulator Environment
source ../etc/simvar.sh

REGSRC="x"      # obtain from the X reg
REGDST="s"      # copy into the S reg

# Check to see if the MSB in A is 1
VALUE=$(cat ../reg/${REGDST}.reg | cut -c1)
if [ "${VALUE}" -eq 1 ]; then

        # There is a 1 there, set the sign flag
        setSign
else

        # There is not a 1, clear the sign flag
        clearSign
fi

#set zero
if [ "${REGSRC}" -eq 0 ]; then

        # There is a zero there, set the zero flag
        setZero
els 

        # There is not a zero, clear the zero flag
        clearZero
fi

# Copy the contents of source register into 
# destination register
cat ../reg/${REGSRC}.reg > ../reg/${REGDST}.reg

exit 0

Aside from this we learned all about SCROT. Hows it hanging?

# !/bin/bash
#
# INSTRUCTION:
#       0x2D - Bitwise-AND against accumulator and byte at absolute
#          address in memory (store result in accumulator)
#
# FUNCTION:
# 
#       Logically AND each bit against its corresponding bit
#       position, storing that result.
#
#               A[0] = A[0] & address[0]
#       ...
#       A[7] = A[7] & address[7]
#
# FLAGS FLIPPED:
#       Zero
#       Sign
#

# Initialize Simulator Environment
source ../etc/simvar.sh

REGSRC="a"      # subtract values from the accumulator
REGDST="a"      # store the result in the accumulator
LVALUE=${1}     # lower order byte of the absolute address
UVALUE=${2} # upper order byte of the absolute address

# Grab byte of memory from specified address
MEMBYTE=$(memget.sh ../mem/ram.mem ${LVALUE} ${UVALUE})

# Convert the data in the accumulator to a hex value
HEXREG=$(cat ../reg/${REGSRC}.reg | reg2hex)

# Convert the data obtained from memory (currently in octal)
# into a hex value
#
HEXMEM=$(echo ${MEMBYTE} | oct2hex)

# Perform the bitwise AND (two hex arguments, outputs the 
# result to STDOUT in hex)
result=$(bitwiseAND ${HEXREG} ${HEXMEM})

# Store resulting value to destination
echo "${result}" | hex2reg > ../reg/${REGDST}.reg

# Check to see if the current value in A is 0
VALUE=$(cat ../reg/${REGDST}.reg | reg2dec)
if [ "${VALUE}" -eq 0 ]; then

        # There is a zero there, set the zero flag
        setZero
else

        # There is not a zero, clear the zero flag
        clearZero
fi

# Check to see if the MSB in A is 1
VALUE=$(cat ../reg/${REGDST}.reg | cut -c1)
if [ "${VALUE}" -eq 1 ]; then

        # There is a 1 there, set the sign flag
        setSign
else

        # There is not a 1, clear the sign flag
        clearSign
fi

exit 0

# !/bin/bash
#
# INSTRUCTION:
#       0x41 - Bitwise-exclusive OR between accumulator and
#          byte of memory accessed indirectly via X register
#
# FUNCTION:
#       
#       Logically XOR each bit against its corresponding bit
#       position, storing that result.
#
#               A[0] = A[0] ^ *address[0]
#       ...
#       A[7] = A[7] ^ *address[7]
#
# FLAGS FLIPPED:
#       Zero
#       Sign
#

# Initialize Simulator Environment
source ../etc/simvar.sh

REGSRC="a"      # subtract values from the accumulator
REGDST="a"      # store the result in the accumulator
VALUE=${1}      # immediate value (in hex)

# Convert immediate value into register format
echo ${VALUE} | hex2reg > ../reg/tmp.reg

# Add VALUE and HEXREG values together, get lower-order 
# zero page address from adding things thusly
result=$(add.sh x tmp | reg2oct)

# Obtain absolute memory address from calculated address
# (indirection FTW)
#
LOB=$(memget ../ram.mem ${result} 0)
let result=${result}+1
UOB=$(memget ../ram.mem ${result} 0)

# Grab byte of memory from specified address
MEMBYTE=$(memget.sh ../mem/ram.mem ${LOB} ${UOB} | oct2hex)

# Convert the data in the accumulator to a hex value
HEXREG=$(cat ../reg/${REGSRC}.reg | reg2hex)

# Perform the bitwise AND (two hex arguments, outputs the 
# result to STDOUT in hex)
result=$(bitwiseXOR ${HEXREG} ${MEMBYTE})

# Store resulting value to destination
echo "${result}" | hex2reg > ../reg/${REGDST}.reg

# Check to see if the current value in A is 0
VALUE=$(cat ../reg/${REGDST}.reg | reg2dec)
if [ "${VALUE}" -eq 0 ]; then

        # There is a zero there, set the zero flag
        setZero
else

        # There is not a zero, clear the zero flag
clearZero
fi

# Check to see if the MSB in A is 1
VALUE=$(cat ../reg/${REGDST}.reg | cut -c1)
if [ "${VALUE}" -eq 1 ]; then

        # There is a 1 there, set the sign flag
        setSign
else

        # There is not a 1, clear the sign flag
        clearSign
fi

# clean up temp registers
rm -f ../reg/tmp.reg

exit 0

Today was the first day of class! Matt discussed what we will focusing on and how we will aproach the material/concepts of the class. The idea is to learn the courses material through game development. This was a breath of fresh air after finishing a semester filled with courses that took the R.T.F.M. route. We will by shooting for 3 total game projects across the entire semster. We split into groups of three and started brainstorming. Matt Page, Zack Golden, and myself decided upon Donky Kong as our first 8-bit game to recreate. We settled on using SDL 2.0 after Matt introduced us to the lazyfoo SDL tutorials! I am looking forward to collaborating with Matt and Zack!

HW: Think about the collaborative work platform to use for the development process as well as any other tools and resources that may be of help.

We now have a working git repository that all team members haves access to. After getting the repository set up we moved on to discussing the basics of Donkey Kong's first level. Some of the things we took note of:

1. barrel path randomization
2. map layout
3. differences across platforms (NES, Colecovision, Amiga 500, c64, etc)
4. map animations

The development of Donkey Kong is going much better than expected. Matt and Zack figured out how to create shapes in SDL 2.0 on Thursday while i was sick. This prompted them to create a basic map layout out of geometric shapes. I was delighted to do a git pull and find the map! This made me feel awful for being sick and made me want to catch up. Matt and i had a long code session on Saturday where we discussed the direction of the course/project, our frustrations, and long term goals. We accomplished a lot! We were able to get mario moving on the map! We now face an issue with trailing.

Over the last week development of Donkey Kong as been on my personal back burner. I feel as if a lot of time has been contributed to this project by Zack, Matt, and i and we need to focus some energy on our other courses. We did over come our trailing issue and were able to hammer out some of the ladder mechanics! Tomorrow during class i will propose to the group that we set aside 2 days during break week to get a head on the game. While i feel that development of this project is important this week is already pulling me in far too many directions to want to designate time to the game.

Donkey Kong is coming along at a good pace. we were able to overcome some obstacles as a group.

/************************************************************
 *
 * Super Mega Awesome Donkey Kong
 * a.k.a. Dankey Kang
 * a.k.a. Dunkey Kung
 * a.k.a. Kunkey Dung
 *
 * Developers:      Zack Golden
 *                  Matthew Page me@matthewjpage.com
 *                  Dan Shadeck
 *
 ***********************************************************/

#include <SDL2/SDL.h>

int main(int argc, char ** argv)
{
    bool quit = false;
    SDL_Event event;

    SDL_Init(SDL_INIT_VIDEO);

    SDL_Window * window = SDL_CreateWindow("Super Mega Awesome Donkey Kong", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 640, 480, 0);

    SDL_Renderer * renderer = SDL_CreateRenderer(window, -1, 0);

    while (!quit)
    {
        SDL_WaitEvent(&event);

        switch(event.type)
        {
        case SDL_QUIT:
            quit = true;
            break;
        }

                //Clear screen
                SDL_SetRenderDrawColor( renderer, 0x00, 0x00, 0x00, 0x00 );
                SDL_RenderClear( renderer );

                //Donkey Kong Floors and Ladders
                SDL_Rect Floor1 = { 20, 440, 600, 10 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0xFF, 0xFF, 0xFF );


                SDL_RenderFillRect( renderer, &Floor1 );

                SDL_Rect Ladder1_2 = { 560, 340, 20, 100 };
                SDL_SetRenderDrawColor( renderer, 0x55, 0xDD, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Ladder1_2 );

                SDL_Rect Floor2 = { 20, 340, 600, 10 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0xFF, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Floor2 );

                SDL_Rect Ladder2_3 = { 60, 240, 20, 100 };
                SDL_SetRenderDrawColor( renderer, 0x55, 0xDD, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Ladder2_3 );

                SDL_Rect Floor3 = { 20, 240, 600, 10 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0xFF, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Floor3 );

                SDL_Rect Ladder3_4 = { 560, 140, 20, 100 };
                SDL_SetRenderDrawColor( renderer, 0x55, 0xDD, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Ladder3_4 );

                SDL_Rect Floor4 = { 20, 140, 600, 10 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0xFF, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Floor4 );

                SDL_Rect Ladder4_5 = { 240, 60, 20, 80 };
                SDL_SetRenderDrawColor( renderer, 0x55, 0xDD, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Ladder4_5 );

                SDL_Rect Floor5 = { 200, 60, 100, 10 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0xFF, 0xFF, 0xFF );
                SDL_RenderFillRect( renderer, &Floor5 );

                //Mario block
                SDL_Rect Mario = { 310, 405, 20, 35 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0x00, 0x00, 0xFF );
                SDL_RenderFillRect( renderer, &Mario );

                //Donkey Kong himself
                SDL_Rect Donkey = { 60, 40, 60, 100 };
                SDL_SetRenderDrawColor( renderer, 0xDD, 0x51, 0x00, 0xFF );
                SDL_RenderFillRect( renderer, &Donkey );

                //Princess Peach (win condition)
                SDL_Rect Peach = { 210, 25, 20, 35 };
                SDL_SetRenderDrawColor( renderer, 0xFF, 0xAA, 0xDD, 0xFF );
                SDL_RenderFillRect( renderer, &Peach );

                //Update screen
                SDL_RenderPresent( renderer );

    }

    SDL_RenderPresent(renderer);

    SDL_Quit();

    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);

    return 0;
}

I feel that at this point worrying about game appearance would be a waste of time. Adding as many features to demonstrate/build our game building skills would, in my eyes, be the most important aspect of this project right now. My team members also feel this way. Working with one another has been a great experience.

Break Week!

The deadline for the game is coming up! (THIS WEDNESDAY :/) While i feel that we have worked very hard and diligent on the game there is still so much to complete. Come to find out building a game is not a easy and quick task. I am very confident that we will have a functioning game by the deadline but i wish we had more time to work on completing and polishing what we have done. Rumor is going about that the deadline is NOT actually going to be a due date but more of a progress check day. If this is the case i will feel much more comfortable about what we have. This project as tough me many things but the most important thing i have pulled from all of this is that there is power in numbers. If we didn't have 3 brains thinking about this game i don't know how far along it would be. Lets see what tomorrow brings…