this.matches = [];     // id's of profiles that have been liked from both sides
    description,
function move() {
		r.close();
      pictureURL,
   * @throws IOException : The usual IOException from a BufferedReader.
      'R&B',
        // Format: `0652795462`
      location,
    recordingURLs=[],
	 * 
const store = createStore(reducer, enhancer);

	protected int[] getMapSize() {
    this.wantedRoles = wantedRoles;
                "--extensionTestsPath=${workspaceFolder}/out/test"

   *
	 * Constructor that accepts a map to read in from.
    name='',
	svgLengths.push(svg[j].getTotalLength());
  }
            ],
            "name": "Extension Tests",
  }
	}
  constructor(
    roles = [],
      recordingURLs,
            "runtimeExecutable": "${execPath}",
	"version": "0.2.0",
		{'#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#'}
  /** 
    super(
let newImgContainer = document.getElementById("new-icons");

	}
		map = new char[][] {
			if (currentSphereOrders[j] !== 6) {
import java.io.FileReader;
		newImg.className = "moving-icon";
   * @throws The usual IOException from a BufferedReader.
    this.dislikes.push(toId);
const counters = [2,2,2,2,2,2,2,2,2,2];
The program is a *Soviet calculator*, meaning that you have to first specify the numbers you want to perform a calculation on, and then the operator (so that the system will internally perform that operation). And when you input `=` it will give you the value in memory.
  }
class Profile {
This was the first 'real' coursework we got on the Computer Science module I took at the University of Bath.  
import reducer from './reducers';
}
requestAnimationFrame(move);
// generic Profile class only meant to inherit from
    // return `true` if the object satisfies the criteria (and `false` otherwise)
    <img src={event.imageUrl} alt={event.name} />
}
        case 'email':
/**
	 * @return The height and width of the map stored together in an array.
// Preparatory work: lots of copies of the social media spheres are created and put in a 2D array for 
   * @return Gold required to exit the current map.
    contactInfo,
	public Map(String fileName) throws Exception {
	 */
    this.pictureURL = pictureURL;
const svgLengths = [];
}
);
      is.close();

      description,
		{'#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#','#'},
   * @return The name of the current map.
class Band extends Profile {
	 */
            "preLaunchTask": "npm: watch"
          return ['telephone', `tel:${keyValue[1]}`];
    this.recordingURLs = recordingURLs;
// lengths of the SVG curves and the corresponding amount to increment their counters with
		goldRequired = 2;
        case 'messenger':
	// Representation of the map
            "request": "launch",
import java.util.ArrayList;
  protected char[][] getMap() {
    this.contactInfo = Profile.formatContactInfo(contactInfo);
	public Map() {
    <p> From: {(new Date(event.startDate)).toDateString()} <br/>
const enhancer = composeEnhancers(
    pictureURL='',
	private String mapName;
const speed = 2;
    type=null,      // either 'musician' or 'band'
			}
    this.filters.splice(removeIndex, 1, [filterName, newFilterFunction, extraArgument])
// Hover to view descriptions of existing attributes.
		{'#','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','#'},
    console.log(removeIndex);
import java.io.BufferedInputStream;
   */
	for (let i = 0; i < 6; i++) {
    return contactInfoArray.reduce((acc, keyValue) => {acc[keyValue[0]] = keyValue[1]; return acc}, {})
export default EventDetails;
		newA.href = hrefSet[i];
        case 'whatsapp':

    // vars for main generic info
		newImg = document.createElement("img");
    <h1> {event.name} </h1>
      'Nieuwegein',
  changeFilter = (filterName, newFilterFunction, extraArgument=null) => {
// Constants to impact flow of spheres
		return new int[] {map.length, map[0].length};
				throw new Exception("\nYour chosen map appears to not be rectangular.");
    wantedRoles=[]
      byte[] c = new byte[1024];
      pictureURL,
	}
	/**
	// Map name
// Each set also cycles through a series of "orders of the spheres" for every time they start their animation.
	 * Removes item stored at specified coordinates.
import React from 'react';
 
		newA = document.createElement("a");
  /**
  protected void readMap(String fileName) throws IOException, Exception {
const iconSets = [];
const sphereOrders = [[3,5,2,1,4,0],[0,1,2,3,4,5],[1,4,0,2,5,3],[5,4,1,2,0,3],[1,2,4,3,0,5],[2,5,4,1,0,3],[3,4,0,5,2,1]]
   */
    this.likes = [];       // id's of profiles that have been liked by the current profile
    location,
      contactInfo,
          return null;
   * @return The item stored at specified coordinates.
    id,
      name,
    recordingURLs,
      'Amsterdam',
		readMap(fileName);
    contactInfo,
    ]
    );
   * @return The map as stored in memory.
	protected int countLines(String fileName) throws IOException {
    genres,
    this.filters.push([filterName, filterFunction, extraArgument])
			// Checks if all lines have the same length
    // generic profile vars
	}
        for (int i = 0; i < readChars; ++i) {
		for (int i = 0; i < lineNumber; ++i) {
  /**
            "outFiles": [
            ],
          if (c[i] == '\n') {
 *
	
      location,
 * Reads and contains in memory the map and specifications of the game.
import ReduxThunk from 'redux-thunk';
   */
  ) {
        case 'telephone':
            "name": "Extension",
}
      id,
    return goldRequired;
    contactInfo={},

   * https://stackoverflow.com/questions/453018/number-of-lines-in-a-file-in-java
		return map[coordinates[0]][coordinates[1]];
      'Utrecht',
      'band',
      'Guitar',
	 *
		map[coordinates[0]][coordinates[1]] = '.';
  }
    <p> {event.description} </p>
  }
 * @see {@link GameLogic.java}
      'Pop',
        },


    this.id = id;
  }
    this.roles = roles;
    const removeIndex = this.filters.findIndex(filter => filter[0] === filterName);
    const removeIndex = this.filters.findIndex(filter => filter[0] === filterName && filter[2] === extraArgument);
let svg = canvas.getElementsByTagName("path");
		newImg.src = icons[i].src;
    this.name = name;
{
  protected String getMapName() {
			}
    // links to external resources
  /**
      while ((readChars = is.read(c)) != -1) {
      name,
   * Reads the map from a file using a BufferedReader and sets the appropriate parameters.
    this.location = location;
                "${workspaceFolder}/out/**/*.js"
  }
      }
    pictureURL,
    return [
import java.io.BufferedReader;
          return ['messenger', `http://m.me/${keyValue[1]}`];
    "configurations": [
    // generic profile vars
      'Hip-hop',
      'Rotterdam',
   */
  static genres = () => {
}
                "${workspaceFolder}/out/test/**/*.js"
 */
		{'#','.','.','.','.','.','.','G','.','.','.','.','.','.','.','.','.','E','.','#'},
      int count = 1; // I changed this from 0 to 1 because it was counting one too few lines for some reason
    ]
const hrefSet = ["https://www.facebook.com/jiri.swen", "", "", "https://nl.linkedin.com/in/jiriswen", "", ""];
      'Soul'
				currentSphereOrders[j] = 0;
    bandId = null,  // should be null when musician is looking for a band
            "args": [
		// First reads in the map name and amount of required gold
		}
      genres,
   * @param The coordinates to get the character at as stored in the map.
      return (count == 0 && !empty) ? 1 : count;
            ],
    // vars specific for musicians
class Musician extends Profile {
    }
			iconSets[j][i].style.transform = "translate(" + (svg[j].getPointAtLength(ownCounter * svgLengths[j]).x -15) * 0.10 + "vw, " + (svg[j].getPointAtLength(ownCounter * svgLengths[j]).y -15) * 0.08 + "vh)";
    try {
const EventDetails = ({event}) => {
	for (let j = 0; j < iconSets.length; j++) {
  addFilter = (filterName, filterFunction, extraArgument=null) => {
	}
    pictureURL,
		BufferedReader r = new BufferedReader(new FileReader(fileName));
    ]
   * Super quick line counter by martinus:
        }
		goldRequired = Integer.parseInt(r.readLine().replace("win ", ""));
          return ['email', `mailto:${keyValue[1]}`];
  constructor(

  ) {
    gender = 'm',
    name,
		newA.target = "_blank";
const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
    name,
		}
  // Als we dit willen integreren in de settings enzo moet er een ADD_FILTER action komen en moet dat via de reducer gestufft kunnen worden
                "--extensionDevelopmentPath=${workspaceFolder}"
    })
   * @param The filename of the map file.
		{'#','.','.','.','.','.','.','.','.','.','.','.','G','.','.','.','.','.','.','#'},
	private char[][] map;
      'Jazz',
# SRPN
                "--extensionDevelopmentPath=${workspaceFolder}",
// Use IntelliSense to learn about possible attributes.
   * @throws Exception : Thrown if map is not rectangular.
	 * @throws Exceptions thrown by {@link readMap}
We received a compiled program and had to reverse engineer it and write it in Java.  
    this.filters.splice(removeIndex, 1);
	protected char getItemAtCoordinate(int[] coordinates) {
      'Rock',
    return [
	}
	protected void removeItemAtCoordinate(int[] coordinates) {
    finally {
  }
  addLike = (toId) => {
   * @return The number of lines.
        // Format: `jiri.sven`
    return map;


export {Profile, Musician, Band};
    this.bandId = bandId;
	 * @param The filename of the map file.
  }
		});
	}
      'Brussels',
		map = new char[lineNumber][];
    age = 0,
// A launch configuration that compiles the extension and then opens it inside a new window
    // vars specific for bands
            "args": [
    recordingURLs,
            ++count;
	/**
const spaceBetweenSheres = 0.07;
    } 
// (because it's the percentage of the total length), and within every set a delay is applied to make
    description,
      recordingURLs,
  </div> );
	// Gold required for the human player to win
    this.genres = genres;
public class Map {
import { createStore, applyMiddleware, compose } from 'redux';
	 * Default constructor, creates the default map "Very small Labyrinth of doom".
	 */
	increments.push(1 / svgLengths[j] * speed);
}
      'Indie',
      switch (keyValue[0]) {
		{'#','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','#'},
            "preLaunchTask": "npm: watch"
  }
            "outFiles": [
  removeFilter = (filterName, filterFunction, extraArgument=null) => {
			map[i] = r.readLine().toCharArray();
	 * @param Coordinates to replace with an 'empty' slot.
// the spheres follow after one another and then also some "randomness" to make the whole thing feel more organic.
	requestAnimationFrame(move); // A function calling itself 60 times per second, yeah that's definitely a good idea
    id,
    this.type = type;
      'Disco',

		newImgContainer.appendChild(newA);
        // Format: jiri.ey@hotmail.com
   *
## Demo
import java.util.List;
  protected int getGoldRequired() {
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
        {
    genres=[],

            "runtimeExecutable": "${execPath}",
    id,             // unique number
    this.age = age;
(My submission received a very good score, you can be confident that it works as expected!)  
      'Zaandam'
		{'#','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','#'},
    // filterFunction should accept a certain property of a profile (e.g. `age` which the number 21 is assigned to) and 
      'Singer',
        }
    this.filters = [];
    this.likes.push(toId);
const increments = [];
// the animation-action that's about to follow, and also an array of all the 
		counters[j] += increments[j];
            "request": "launch",
		{'#','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','#'},
 * @version 3.0
  }
            "type": "extensionHost",
    );
	}
	
				currentSphereOrders[j]++;				
export default store;
		newA.appendChild(newImg);
let canvas = document.getElementById("icon-jumble");

    return [
    ]
	/**
let icons = document.getElementsByClassName("icon");
  }
  constructor(
	/**
			if (map[i].length != map[0].length) {
    location,
// Every set of 6 spheres has its own counter which increases more rapidly for shorter paths 
    InputStream is = new BufferedInputStream(new FileInputStream(fileName));
		{'#','.','.','E','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','#'},
 * @author Jiri Swen
			}
for (let j = 0; j < svg.length; j++) {
  addDislike = (toId) => {
		newIconSet.push(newA);
  }
		mapName = r.readLine().replace("name ", "");
  ) {
    console.log(filterName, filterFunction);
  applyMiddleware(ReduxThunk)
      genres,
	}
    this.candidates = [];  // id's of profiles that have been recommended by the system
   * @param The filename of the map file to count the lines of.
	
      int readChars = 0;
}
![gif-1](/readme-images/srpn-1.gif)
		newA.style.position = "absolute";
 * @release 15/12/2017
	/**
		};
    genres,
const currentSphereOrders = [0,1,2,3,4,5,6,0,1,2];

  return ( <div>
   */
		sphereOrders[currentSphereOrders[j]].forEach(function(i) {
  }
    location='',
			k++;
      'Hilversum',
Which was an interesting task, because the program we got had a lot of quirks!  
import java.util.Arrays;
		let k = 0;
		if (counters[j] % 1 < (increments[j] + 0.00001)) {
      contactInfo,
            "type": "extensionHost",
        {
	private int goldRequired;
			else {
        // Format: `31652795462`
   */
    super(
		int lineNumber = countLines(fileName) - 2;
	let newIconSet = []
  static roles = () => {
          return ['whatsapp', `http://wa.me/${keyValue[1]}`];
    this.description = description;
  }
        To: {(new Date(event.endDate)).toDateString()} </p>
      }
        empty = false;
import java.io.InputStream;

      boolean empty = true;
    description='',
      id,
    const contactInfoArray = Object.entries(contactInfo).map(keyValue => {
import java.io.IOException;
  static locations = () => {
            ],
    // vars that might be interesting for filtering
          }
import java.io.FileInputStream;
    this.dislikes = [];    // id's of profiles that have been disliked by the current profile
    this.gender = gender;
		mapName = "Very small Labyrinth of Doom";
			let ownCounter = (counters[j] - spaceBetweenSheres * k - 0.1 * j - 0.5 * (j % 2)) % 1;
      'Bassist',
	 */
	iconSets.push(newIconSet);

        default:
      'musician',
To give you the full experience of discovering this thing gradually, I will not say anything more about the features, but if you're interested you can look at the source code.  
/**
  static formatContactInfo = (contactInfo) => {
    return mapName;
      description,
}
To start the program, run SRPN.class (i.e. type `java SRPN` while in the directory with your terminal).
shining effectsunraysfloating head

ABOUT

landscape 1awards-cupfuture-buildinghobby-heap
jiri soul containerjiri soul pupils
octopus-treespiral-towertechnology-forest
bookbookbookbookbookbookbookbookbookbookbook
contact-details
sheep
technology icontech cloud cloud
osu! db manipulator