What on earth are Signal Flominos?

We needed to explain to the programmers how our connection system worked. Because it’s super specific and also very flexible. So, while wrestling with this and trying to find the best way to efficiently demonstrate it for the programmers, Adrian Forest pointed us towards Kate Compton’s Generominos. The Generonimos are used for designing and teaching the flow of data as it is transformed in a generative system. It uses symbols and small portions of text to describe each point that data can be transformed from one type to another. These are positioned on the cards so that the modules inputs are on the top and the outputs are on the bottom. So many pieces of this systems design can be transferred into our needs and we would be foolish to not be inspired by the Generonimos when trying to explain our system design to our programmers. Suitably naming them, Signal Flominos, a name that stuck super glue. 

Cate Kompton’s Generonimos

Since the Generonimos were describing a flow of data as it is transformed, we could use the idea and method to describe the flow of a signal as it is transformed and altered through the modules. The Generonimos use symbols to represent the specific connections that can be made, so I used different shapes to demonstrate what modules could connect to what. This was a solution to the initial problem of trying to explain the connections to the programmers, but we also realised that these cards could be used for much more than that. We started using them to prototype our levels by using a whiteboard and some markers and it became clear that these could also be used as a teaching tool with some refinement. After realising the new uses, I suddenly had more reason to continue refining the cards, and so I did.


Our Flominos

I spent some of my time after that working on refining the cards. I ran some of the earlier versions by our audio contact, who informed me of some of the big mistakes I had made in the ordering of certain pieces and how the connections worked. I also tried to streamline the sorting process by making certain elements that would need to be found quickly a different shape. This resulted in 4, 6, and 8 sided cards for different purposes. The next step of the improvement is to ask a graphic designer to come in and give some advice and work on some symbols for the cards to better describe the goal, instead of just having google drawings. After this fourth version that I have just finished creating, I will almost definitely need to make even more adjustments. But for now I can only wait until I’ve got them printed and laminated to start testing.


I hate anxiety

So, about a week and a half ago, I made the decision to defer one of my classes. That is not a small decision to make, at least for me. I had been dealing with a large amount of stress for the previous month or so that fluctuated in it’s intensity. It regularly hit it’s peak on a Monday night/ Tuesday morning, which I regularly got little sleep on and was faced with large amounts of work for the next day. When it came time for this, I often was left with little to no contact with team members for help or had found that the things that had been completed needed to be reworked or adjusted. When this happened, I was often overwhelmed with the weight of work that was left for me to do. This then carried over to the next day, where I would often need to do a presentation for my team. This shouldn’t have been left for me alone, but it often was due to poor communication with my team and me deciding to take on the weight instead of ask for help. This happened on loop for about 4 weeks, steadily increasing in weight, peaking on Tuesday morning. After those weeks, I couldn’t do it anymore.


The monday night of week 6 was when I finally reached out for help from someone. I sent an email to my lecturer for the class that was causing my the most panic. This was the best step that I could have made to help me in this situation. I went into uni the next day not knowing how much that email was going to help me. Upon arriving at uni, it didn’t take long before I was taken aside and spoken to by one of my lecturers about how to fix this stress. This was when I realised why those people talk about how important it is to reach out when you’re struggling. I’d heard so many stories from people who talk about how it’s so important to talk to someone and how you should reach out if you’re struggling, but boy did I underestimate how much I’d need that. After talking to the lecturers about how I was doing, I came to the decision to defer my final project preparation class.


This was so relieving for me, I could finally breath again. It took some time to fully understand how much I was stressing over it. There were many points that my mind jumped back to thinking about the workload that I had and I had to take a step back and remind myself that I didn’t have to do it anymore. It’s a strange feeling, a moment of panic so close to a moment of relief. I do not want to go back. So in an attempt to avoid ever experiencing that again, I need to remember to take a step back regularly to examine how I’m doing and to see how well I’m coping. I need to make sure that I’m still connecting with my friends and enjoying my life, because I know that if I don’t, I’ll get caught up quickly in work.


So now that I’m doing less work, there’s only really one thing I’m concerned about. That is that after having taken a step back from work, I’m concerned that I’ve stepped too far back and might be doing too little work now. I hope that this is not the case, and that it is just my brain trying to find something new to worry about. But at the moment, I feel that I should pick up my game a little bit. I need to consider how well I’m communicating with my team and how well they are doing their share of the work. Because while I need to do my parts, I need to know that I’m not doing someone else’s as well.

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.

I did some coding. What a mess.

So, we had to make a prototype for our game, before we gave it to our programmers. This was… fun. To start, we divided the tasks between us. My first main task was to get the connections working. I wasn’t entirely sure where to start this. So i began with being able to draw the lines with my mouse. Starting with a standard unity UI button, I created a system that would spawn a bar shaped button. I then made a system that would position it so that it was pointed towards the mouse cursor and would its width would be scaled to reach it. One issue I found with this was that the scale for the width will always be the same, but the mouse’s distance from the button will depend on the screen resolution. This was something that I didn’t have time to fix and so I left it to only work at one resolution, but created a scaling variable that lets you adjust it to suit the resolution. Once i could draw the lines, I created a thing to let you drag the lines after they were created, and also made systems to allow the lines to connect to new points. When this was done, I created systems to remove the lines if they weren’t connected to anything.


Now things were connected, I needed to make our shapes flow down the lines. To do this, since the lines were straight, I just made shapes spawn at the lines origin and made them move towards the end. However, these needed to only be sent if the origin is receiving shapes. To do this, the shapes needed to send information to the connection points, and the connection points needed to send information to the lines, which were spawning the shapes. So the shapes were flowing. But it was all one colour, we couldn’t use different signals. Now here’s where it gets messy. I started by numbering the signals, this was mostly simple, since it was just a number that could be passed between the points when they were connected, Getting them to reset when they disconnect was a little trickier, but that’s nothing compared to the mess that became the colouring of each line and connection point. This was a nightmare of if statements and multiple different points to do almost the same thing. But, it kind of worked. What I should have done was get the colours to be based off of the signal numbers, but that would have been the smart thing to do.


After this, I created the channel functionality. This could have been done better than it was, and it doesn’t entirely function correctly in it’s current state. I piggybacked off of the standard connection methods, but forgot to stop it from advancing the shape type and did not allow it to connect twice (which may or may not be good). Once I had done that, I needed to create the systems to allow connection points to accept multiple coloured inputs. This is where the train derailed. Because I hadn’t got the colours based off of the signal number, getting a colour to continue from the connection point would not work properly, since the connection point did not have a colour. I still need to fix this before we show our prototype to our programmers this tuesday, but there’s still time.


The rest of my team spent their time focusing on other areas of the game, such as UI or more in detail interactions with the connection points. After each of our parts are complete, the next more complex part is to try and combine them without breaking it. Fingers crossed it will work.