More programming.

So, due to difficulties outside of our teams control, not all the programming tasks that were assigned were completed. So we needed to take a step back and reassign the programming tasks so that the prototype could be ready for the client meeting, since it was too late for presenting to the programmers. But we also needed to move on with the other tasks that needed to be done now, since we were running behind schedule. To take care of this, I took on the task of finishing the programming tasks allowing the rest of the team to work together to look after the programmers and adjusting the holes in our programming.


So. Programming. The things that Still needed to be done was creating all of the patchbay functionality, and integrating the potentiometer. To start this, i took what had been done with the potentiometer and pulled it appart. The parts that had been made were all focussed on world space, so I needed to take it and then integrate it into the ui, where the rest of the game had been made. After I was able to rotate a UI object like the previously made piece could, I needed to be able to do something with that rotation. So I put a limiter on the flow of the shapes through the lines, so that when the object was receiving, if it had a potentiometer, the potentiometer needed to be turned up for it to flow. There was a few issues with getting the rotational value out of the object because of the way unity handles quaternions. This resulted in only half of the potentiometer working. The other half resulted in a negative rotation number.


The next thing that I needed to create had no work towards it. The patchbay. To start this, I had to first create a method of opening the patchbay. I decided to make it open when you double click the node. This is something that we hadn’t planned, and so after I was done creating the patchbay, I went and wrote it into the documentation, along with a few other adjustments. Within the patchbay, I made three new types of nodes, outputs, inputs, and internal patchbay nodes(which I named inouts). These needed to have special connections made for them to suit the situations they can be used in. Once the patch bay could appear and disappear while keeping its connections, I needed to let the patchbay accept inputs. When it was able to accept inputs, they needed to be assigned to the outputs within the patchbay. I did this with a for loop with the signal number arrays and an array of outputs. Next I needed to create checks on whether or not there was a signal reaching the end, and allow the signals to then be taken out of the patchbay when it is connected. I didn’t create any more functionality of the patchbay, and after making it and presenting it to the client, we did rework our approach to the patchbay, but any more functions would have been unnecessary for the level of detail we needed and the time that we had to produce these results. It wasn’t fun having to do work that other members of my team were meant to do, but at least it was work that I knew I could do. We as a team will need to put some time aside to figure out how we’re going to avoid this happening again.


One comment

  1. Pingback: Noah Seymour

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s