## Inspiration

We were inspired by apps such as GamePigeon (which allows you to play games together over text messages) and Gather (which allows you to have virtual interactions RPG style). We also drew inspiration from Discord’s voice chat activity feature that allows you to play games together in a call.

## What it does

RoundTable is a virtual meeting platform that allows people to connect in the same way they would at a real-life round table discussion: everyone in a room can manipulate and interact with objects or games on the table as they please. However, we take this a step further by providing an easy-to-use API for any developer to create an activity plugin by submitting a single JavaScript file.

## How we built it

We built the client using React and MUI, with Markdown being used to render chat messages. The client is mainly responsible for rendering events that happen on the roundtable and reporting the user’s actions to the server through Socket.io. The server is built with Typescript and also uses Socket.io to establish communication with the client. The server is responsible for managing the game states of specific instances of plugins as well as controlling all aspects of the rooms.

## Challenges we ran into

One challenge we ran into was balancing participating in events and workshops during the hackathon with working on our project. Initially, we had a very ambitious idea for the final product and thought that it was possible if we worked on it as much as possible. However, it soon became clear that in doing so, we would be jeopardizing our own experiences at HTN and we should aim to have a compromise instead. So, we scaled down our idea and in return, were able to participate in many of the amazing events such as real-life among us and the silent disco.

Another challenge was that our team members had a few disagreements about the design and implementation of RoundTable. For example, we had two proposed ideas for how custom plugins could work. One of our group members insisted that we should go with an implementation involving the use of embedded iframes while the others wanted to use direct source files manipulating a canvas. Although we wasted a lot of time debating these issues, eventually a collective decision was reached.

## Accomplishments that we're proud of

We’re proud of the fact that we managed our time much better this time around than in previous hackathons. For example, we were able to decide on an idea ahead of time, flesh it out somewhat, and learn some useful technologies as opposed to previous hackathons when we had to rush to come up with an idea on the day of. Also, we clearly divided our duties and each worked on an equally important part of the application.

## What we learned

Through doing this project, we learned many technical things about creating an RTC web application using SocketIO (which most of us hadn’t used before), React, and Typescript. We also learned to use Material UI together with CSS stylesheets to develop an attractive front-end for the app and to design a robust plugin system that integrates with p5.js to create responsive modules.

In addition, we learned many things about collaboration and how to work better as a team. Looking back, we would not spend as much time debating the advantages and disadvantages of a specific design choice and instead pick one and prepare to implement it as much as possible.

## What's next for RoundTable

Although we are satisfied with what we were able to accomplish in such a short time span, there are still many things that we are looking to add to RoundTable in the future. First of all, we will implement a voice and video chat to improve the level of connection between the participants of the roundtable. Also, we will improve our plugin API by making it more flexible (allowing for modules such as playing a shared video) and an account system so that rooms can be organized easily. Finally, we will improve the security of the application by sandboxing custom modules and doing end-to-end encryption.
## Inspiration

Rumor has it, if you're good at basketball, you can easily get into CIT. Penn admits many outgoing girls. UChicago likes admitting artists. MIT is excited to see science olympiad recipients.
Some people spend thousands of dollars hiring professional agencies to help with college application. Others post "Chance me" posts desperately on College Confidential.
How do colleges decide who to admit? We are all curious, but no one actually knows.

## What it does

AdmitMe has its unique machine learning algorithm to generate your chances of getting into top US colleges. Students can either log in through their common application account, or manually fill in a form of their personal information. Our web app will provide you a list of colleges of your choice that you are likely to be accepted (in order). You can check detailed statistic information on all the properties. We also provide you with personalized guidance on how you can most efficiently improve your chances, through improving parts of your application and the way you describe your extracurricular activities.

## How we built it

We aggregated over 8000 detailed application information for the top 25 US colleges. The data comes from scraping "Chance" thread in College Confidential and a lot of data processing. The model is trained through diverse standard exam scores, senior course load, extracurricular activities and personal background. We used MongoDB as our database for all the data needed. The web app uses Python, Django, Javascript and html.

## Challenges we ran into

Only one person on the team is familiar with the Django framework, which made it difficult to chain everything together. We ran into compatibility issues with Python 2.7 and Python 3 on the last day of the Hackathon, having to modify the whole algorithm. Natural language processing of self-reported data is challenging as well.

## Accomplishments that we're proud of

We're unique. None of the other college counseling apps are using detailed natural language processing and machine leaning like us. We're able to process 8000 valid and detailed student data from nothing. We developed a 70% accuracy algorithm on top college prediction. We were also able to put a full stack website together in less than 36 hours.

## What we learned

* Django is difficult
* Processing raw data to a good dataset is really time consuming. If we can find better data source in the future, that's a much easier way
* Collaboration is very important for full stack programming, especially using Django

## What's next for AdmitMe

* We will develop a business plan to make our product more complete. (It's more of a prototype right now) The scalability needs to be improved.
* Talk to colleges and agencies to aggregate more complete data to develop a more accurate algorithm
* Market for our product, we are considering B to B (selling to agencies) or B to C (directly to students). We realized there is a huge market in China as well, where 3 out of our 4 team members are from.
## Inspiration

Reflecting on 2020, we were challenged with a lot of new experiences, such as online school. Hearing a lot of stories from our friends, as well as our own experiences, doing everything from home can be very distracting. Looking at a computer screen for such a long period of time can be difficult for many as well, and ultimately it's hard to maintain a consistent level of motivation. We wanted to create an application that helped to increase productivity through incentives.

## What it does

Our project is a functional to-do list application that also serves as a 5v5 multiplayer game. Players create a todo list of their own, and each completed task grants "todo points" that they can allocate towards their attributes (physical attack, physical defense, special attack, special defense, speed). However, tasks that are not completed serve as a punishment by reducing todo points.

Once everyone is ready, the team of 5 will be matched up against another team of 5 with a preview of everyone's stats. Clicking "Start Game" will run the stats through our algorithm that will determine a winner based on whichever team does more damage as a whole. While the game is extremely simple, it is effective in that players aren't distracted by the game itself because they would only need to spend a few minutes on the application. Furthermore, a team-based situation also provides incentive as you don't want to be the "slacker".

## How we built it

We used the Django framework, as it is our second time using it and we wanted to gain some additional practice. Therefore, the languages we used were Python for the backend, HTML and CSS for the frontend, as well as some SCSS.

## Challenges we ran into

As we all worked on different parts of the app, it was a challenge linking everything together. We also wanted to add many things to the game, such as additional in-game rewards, but unfortunately didn't have enough time to implement those.

## Accomplishments that we're proud of

As it is only our second hackathon, we're proud that we could create something fully functioning that connects many different parts together. We spent a good amount of time on the UI as well, so we're pretty proud of that. Finally, creating a game is something that was all outside of our comfort zone, so while our game is extremely simple, we're glad to see that it works.

## What we learned

We learned that game design is hard. It's hard to create an algorithm that is truly balanced (there's probably a way to figure out in our game which stat is by far the best to invest in), and we had doubts about how our application would do if we actually released it, if people would be inclined to play it or not.

## What's next for Battle To-Do

Firstly, we would look to create the registration functionality, so that player data can be generated. After that, we would look at improving the overall styling of the application. Finally, we would revisit game design - looking at how to improve the algorithm to make it more balanced, adding in-game rewards for more incentive for players to play, and looking at ways to add complexity. For example, we would look at implementing a feature where tasks that are not completed within a certain time frame leads to a reduction of todo points.