// ==UserScript==

// @name HaxBall TC Nerds script

// @namespace http://tampermonkey.net/
// @version 0.3
// @description try to take over the world!
// @author MaddoHatto
// @source https://github.com/MaddoHatto/HaxBall-TC-Nerds-Script
// @match https://www.haxball.com/headless
// @require https://code.jquery.com/jquery-1.12.4.min.js
// @grant none
// @license GPL-3.0-or-later; https://www.gnu.org/licenses/gpl-3.0.txt
// @updateURL
https://openuserjs.org/meta/MaddoHatto/HaxBall_TC_Nerds_script.meta.js
// ==/UserScript==

const RED_TEAM_ID = 1;
const BLUE_TEAM_ID = 2;
const BACKEND_BASE_URL = 'https://hax.opac.pl/';

const BALL_RADIUS = 10;

const PLAYER_RADIUS = 15;

const DISC_BALL_ID = 0;
const OFFSIDE_AVATAR = '🔥';

const SAVE_REPLAY_BUTTON_ID = 'SAVE_REPLAY_BUTTON_ID';

const HOST_HANDICAP = '40';

const playersAvatars = {
MaddoHatto: '🐻',
"Nelson Mandela": 'xD',
Amman: '🐺',
ToPP: '🤡',
hubigz: 'H',
adamaru: '😈',
rybak: ' ',
panda: '🐼'
}

class HaxBallController {

constructor() {
this.touchingTheBallTimestamps = {};
this.ballSpeed = 0;
this.prevBallPosition = null;
this.goals = [];
this.gameStartTimestamp = null;
this.gameEndTimestamp = null;
this.isPaused = false;
this.isOffsideActive = false;
this.votesForUnpause = {};
this.tick = 0;
this.logBallSpeed = false;
this.logPlayerPosition = false;
this.playersOffsidePosition = {
[RED_TEAM_ID]: {},
[BLUE_TEAM_ID]: {},
};
this.playersInitPosition = {
 [RED_TEAM_ID]: {},
[BLUE_TEAM_ID]: {},
};
this.initXLine = {
[RED_TEAM_ID]: 0,
[BLUE_TEAM_ID]: 0,
}
this.client = new Client();
this.gamePageController = null;
this.matchResult = null;
}

initRoom() {
this.room = window.HBInit({
roomName: "TC_NERDS_ROOM",
password: '1',
maxPlayers: 16,
noPlayer: true // Remove host player (recommended!)
});

this.room.setDefaultStadium("Rounded");
this.room.setScoreLimit(10);
this.room.setTimeLimit(10);

window.hbRoom = this.room;
window.hbController = this;

return this;
}

initListeners() {
this.room.onPlayerChat = this.onPlayerChat.bind(this);
this.room.onGameTick = this.onGameTick.bind(this);
this.room.onGameStart = this.onGameStart.bind(this);
this.room.onPlayerJoin = this.onPlayerJoin.bind(this);
this.room.onPlayerLeave = this.onPlayerLeave.bind(this);
this.room.onTeamGoal = this.onTeamGoal.bind(this);
this.room.onTeamVictory = this.onTeamVictory.bind(this);
this.room.onPlayerBallKick = this.onPlayerBallKick.bind(this);
this.room.onGamePause = this.onGamePause.bind(this);
this.room.onGameUnpause = this.onGameUnpause.bind(this);
this.room.onPositionsReset = this.onPositionsReset.bind(this);

return this;
}

initUserInterface() {
try {
document.body.style.background = '#939e7f
url("https://www.haxball.com/hiF05fAx/__cache_static__/g/images/bg.png") fixed';
this.waitForRoomLinkElement(() => {
let button = document.createElement("button");
button.innerHTML = "PLAY";
button.onclick = this.goToGameTab.bind(this);
button.style.color = '#fff';
button.style.height = '100px';
button.style.width = '450px';
button.style.position = 'fixed';
button.style.top = '150px';
 button.style.left = '10px';
button.style.fontSize = '36px';
button.style.background = 'linear-gradient(#8da86b, #658d59)';
button.style.border = '4px solid white';
button.style.borderRadius = '50px';
button.style.cursor = 'pointer';

button = document.body.appendChild(button);
});
} catch (error) {
console.log(error);
}

return this;
}

onPositionsReset() {
this.clearPlayersOffsidePosition();
this.updateIsOffsideActive(false);
}

onPlayerChat(player, message) {

if (this.isPauseCommand(message)) {
return this.handlePauseCommand(player, message);
}

if (this.isFindTeamsCommand(message)) {
return this.handleFindTeamsCommand();
}

if (this.isVoteForUnpauseCommand(message)) {
return this.handleVoteForUnpauseCommand(player);
}

return true;
}

onGameTick() {
this.updateTouchingTheBall();
this.updateBallSpeed();

this.updateBallPosition();
this.tick++;
}

onGameStart() {
this.updateGameStartTimestamp();
this.updateInitPlayerPositions();
}

onPlayerJoin(player) {
this.updateAdmins();
this.resetPlayerAvatar(player);
}

onPlayerLeave() {
this.updateAdmins();
}
 onTeamGoal(teamId) {
this.updateScorers(teamId);
this.clearPlayersOffsidePosition();
}

onTeamVictory(scores) {
this.updateGameEndTimestamp();

this.matchResult = this.getMatchResult(scores);
console.log('MATCH RESULT = ', this.matchResult);

try {
if (this.gamePageController) {
setTimeout(() => {
//const shouldSave =
this.gamePageController.showConfirmModal('Save replay?');

//if (shouldSave) {
// this.saveMatchResult();
//}
}, 5000);
}

this.addSaveReplayButton();

} catch(error) {
console.log(error);
}
this.clear();
}

onPlayerBallKick(player) {
this.updatePlayerTochedTheBall(player);
this.updatePlayersOffsidePosition(player);
this.updateIsOffsideActive(true);
}

onGamePause() {
this.isPaused = true;
}

onGameUnpause() {
this.isPaused = false;
}

getRoom() {
return this.room;
}

getMatchResult(scores) {
return {
score: {
Blue: scores.blue,
Red: scores.red
},
teams: this.getTeams(),
goals: this.goals,
startTimestamp: this.gameStartTimestamp,
 endTimestamp: this.gameEndTimestamp,
duration: scores.time,
rawPositionsAtEnd: this.getRawPositionsAtEnd()
};
}

getTeams() {
const players = this.room.getPlayerList();
const result = {
Red: [],
Blue: [],
Spectators: []
};

for (let i = 0; i < players.length; i++) {

const player = players[i];
const teamName = this.getTeamName(player.team);

if (result[teamName]) {
result[teamName].push(player.name);
}
}

return result;
}

getPlayers() {
const players = this.room.getPlayerList();
const result = [];

for (let i = 0; i < players.length; i++) {

const player = players[i];

if (player.team === RED_TEAM_ID || player.team === BLUE_TEAM_ID) {

result.push(player);
}
}

return result;
}

getTeamName(teamId) {
if (teamId === RED_TEAM_ID) {
return 'Red';
}

if (teamId === BLUE_TEAM_ID) {

return 'Blue';
}

return 'Spectators';
}

getEnemyTeamId(teamId) {
return teamId === RED_TEAM_ID ? BLUE_TEAM_ID : RED_TEAM_ID;
}

getRawPositionsAtEnd() {
let result = '';
 const players = this.getPlayers();

for (let i = 0; i < players.length; i++) {

const player = players[i];

if (player) {
const { x, y } = player.position;
result = `${result}${x}--${y}|`;
}
}

return result;
}

updateAdmins() {
const players = this.room.getPlayerList();
if ( players.length == 0 ) return; // No players left, do nothing.
if ( players.find((player) => player.admin) != null ) return; // There's an
admin left so do nothing.
this.room.setPlayerAdmin(players[0].id, true); // Give admin to the first
non admin player in the list

setTimeout(() => {
this.setHostHandicap();
}, 3000);
}

updateGameStartTimestamp() {
this.gameStartTimestamp = new Date().valueOf();
}

updateGameEndTimestamp() {
this.gameEndTimestamp = new Date().valueOf();
}

updateBallSpeed() {
if (this.prevBallPosition) {
const currentBallPosition = this.room.getBallPosition();
if (currentBallPosition) {
const vector = Math.sqrt(Math.pow(this.prevBallPosition.x -
currentBallPosition.x, 2) + Math.pow(this.prevBallPosition.y -
currentBallPosition.y, 2));
const speed = vector * 60; // game tick is 1/60 of second

this.ballSpeed = (parseFloat((speed / 100).toFixed(2)) * 3600) /

1000; // km/h
}
}

if (this.logBallSpeed && this.tick % 10 === 0) {

console.log('Ball speed: ' + this.ballSpeed + 'km/h');
}
}

updateBallPosition() {
this.prevBallPosition = this.room.getBallPosition();
}

updateInitPlayerPositions() {
 const players = this.getPlayers();

for (let i = 0; i < players.length; i++) {

const player = players[i];
this.playersInitPosition[player.team][player.id] = player.position;
this.initXLine[player.team] = player.position.x;
}
}

updateTouchingTheBall() {
const players = this.getPlayers();
const ballPosition = this.room.getBallPosition();
const ballRadius = 10;
const playerRadius = 15;
const triggerDistance = ballRadius + playerRadius + 0.01;
const timestamp = new Date().valueOf();

for (let i = 0; i < players.length; i++) {

const player = players[i];
if ( player.position == null ) continue; // Skip players that don't
have a position

const distanceToBall = this.pointDistance(player.position,

ballPosition);

if ( distanceToBall < triggerDistance ) {

this.touchingTheBallTimestamps[player.id] = timestamp;

if (this.playersOffsidePosition[player.team][player.id]) {
this.handleOffside(player);
} else {
this.clearPlayersOffsidePosition(player.team === RED_TEAM_ID ?
BLUE_TEAM_ID : RED_TEAM_ID);
}
}

if (this.logPlayerPosition && this.tick % 10 === 0) {

console.log('Player ' + player.name + ' position: x = ' +
player.position.x + ', y =' + player.position.y);
}
}
}

updatePlayersOffsidePosition(kicker) {
const kickerTeamId = kicker.team;

if (!this.isOffsideActive) {
return;
}

if (this.playersOffsidePosition[kickerTeamId][kicker.id]) {
this.handleOffside(kicker);
return;
}

const playerList = this.getPlayers();

const ballPosition = this.room.getBallPosition();
const ballOffset = kickerTeamId === RED_TEAM_ID ? BALL_RADIUS : -
BALL_RADIUS;
 const playerOffset = kickerTeamId === RED_TEAM_ID ? PLAYER_RADIUS : -
PLAYER_RADIUS;

let offsideLine = ballPosition.x + ballOffset;

this.clearPlayersOffsidePosition();
const kickerTeam = [];

for (let i = 0; i < playerList.length; i++) {

const player = playerList[i];

if (player.id === kicker.id) {

continue;
}

if (player.team === kickerTeamId) {

kickerTeam.push(player);
} else if (player.position !== null) {
const position = player.position.x + playerOffset;

if (
(kickerTeamId === RED_TEAM_ID && offsideLine < position)
|| (kickerTeamId === BLUE_TEAM_ID && offsideLine > position)
) {
offsideLine = position
}
}
}

for(let i = 0; i < kickerTeam.length; i++) {

const player = kickerTeam[i];

if (player.position !== null) {

const position = player.position.x + playerOffset;

if (
(kickerTeamId === RED_TEAM_ID && offsideLine < position &&
this.initXLine[RED_TEAM_ID] < position)
|| (kickerTeamId === BLUE_TEAM_ID && offsideLine > position &&
this.initXLine[BLUE_TEAM_ID] > position)
) {
this.playersOffsidePosition[kickerTeamId][player.id] =
player.name;
}
}
}

const offsidePlayerIds =
Object.keys(this.playersOffsidePosition[kickerTeamId]);
for(let i = 0; i < offsidePlayerIds.length; i++) {
const playerId = offsidePlayerIds[i];
this.room.sendAnnouncement('Player ' +
this.playersOffsidePosition[kickerTeamId][playerId] + ' is offside', null,
0xFFFFFF, null, 0);
console.log(`PLAYER ${playerId} AVATAR ${OFFSIDE_AVATAR}`);
this.room.setPlayerAvatar(playerId, OFFSIDE_AVATAR);
}
}
 updatePlayerTochedTheBall(player) {
this.touchingTheBallTimestamps[player.id] = new Date().valueOf();
}

updateScorers(teamId) {
const players = this.getPlayers();
let scorerId = null;
let scorerName = 'Unknown';
let closestTimestamp = null;

for (let i = 0; i < players.length; i++) {

const player = players[i];

if (player.team === teamId) {

const playerTimestamp = this.touchingTheBallTimestamps[player.id];

if (playerTimestamp && (closestTimestamp === null ||

closestTimestamp < playerTimestamp)) {
closestTimestamp = playerTimestamp;
scorerId = player.id;
scorerName = player.name;
}
}
}

this.room.sendAnnouncement('Goal scored by ' + scorerName, null, 0x00FF00,

"bold", 2);
this.addGoal(scorerName, teamId);
this.clearTouchingTheBallTimestamp();
}

updateIsOffsideActive(value) {
this.isOffsideActive = value;
}

handleOffside(player) {
this.room.pauseGame(true);
this.room.sendAnnouncement(this.getTeamName(player.team) + ' team offside',
null, 0xFFFFFF, "bold", 2);

const players = this.getPlayers();

const offsideTeamId = player.team;
const enemyTeamId = this.getEnemyTeamId(offsideTeamId);

const playerDiscProperties = this.room.getPlayerDiscProperties(player.id);

this.resetTeamToInitPosition();

const initXLine = this.initXLine[enemyTeamId];

const offset = enemyTeamId === RED_TEAM_ID ? 100 : -100;

this.room.setDiscProperties(DISC_BALL_ID, {
x: initXLine + offset,
y: 0,
xspeed: 0,
yspeed: 0,
});

this.clearPlayersOffsidePosition();
 this.room.pauseGame(false);
this.updateIsOffsideActive(false);
}

handlePauseCommand(player, message) {
this.room.pauseGame(true);
this.room.sendAnnouncement('Game paused by ' + player.name, null, 0x00FF00,
"bold", 2);
this.votesForUnpause = {};
return false;
}

handleFindTeamsCommand() {
const playerList = this.room.getPlayerList();

if (playerList.length % 2 != 0) {
this.room.sendAnnouncement('You have to have even amount of players!',
null, 0xFF0000 , "bold", 2);
return;
}

this.client.getCalculatedTeams(playerList,
this.handleCalculatedTeams.bind(this));
return false;
}

handleCalculatedTeams(red, blue) {
let firstRow = "Hi there! As Official Haxball's Scripted Referee I suggest
these teams for tonight's skirmish:";
let secondRow = "On left side, in red uniforms:";
let thirdRow = "On right side, wearing blue: "

for (let i = 0; i < red.length; i++) {

secondRow += " @" + red[i];
thirdRow += " @" + blue[i];
}

this.room.sendAnnouncement(firstRow);
this.room.sendAnnouncement(secondRow, null, 0xE54141);
this.room.sendAnnouncement(thirdRow, null, 0x5DADE2);
}

handleVoteForUnpauseCommand(player) {
// check if already voted
if (this.votesForUnpause[player.id]) {
return;
}

this.votesForUnpause[player.id] = true;
const playerList = this.getPlayers();
const playersCount = playerList.length;
let votesCount = 0;

for (let i = 0; i < playerList.length; i++) {

const player = playerList[i];

if (this.votesForUnpause[player.id]) {
votesCount++;
}
 }

if (votesCount === playersCount) {

this.room.sendAnnouncement('All players voted to unpause!', null,
0x00FF00, "bold", 2);
this.room.pauseGame(false);
} else {
this.room.sendAnnouncement('Player ' + player.name + ' voted to unpause
(' + votesCount + '/' + playersCount + ')', null, 0x0FFC107, "bold", 2);
}
}

handlePostMatchResult(data) {
console.log(data);
}

isPauseCommand(message) {
const commands = ['p', 'pp', 'ppp', 'pauza'];
const trimmedMessage = message.trim();

return commands.indexOf(trimmedMessage) !== -1 && !this.isPaused;

}

isFindTeamsCommand(message) {
const commands = ['find-teams'];
const trimmedMessage = message.trim();

return commands.indexOf(trimmedMessage) !== -1;

}

isVoteForUnpauseCommand(message) {
const commands = ['go', 'rdy'];
const trimmedMessage = message.trim();

return this.isPaused && commands.indexOf(trimmedMessage) !== -1;

}

changePlayerColor(playerId, color) {
this.room.setPlayerDiscProperties(playerId, {
color,
});
}

addGoal(scorerName, teamId) {
const scores = this.room.getScores();

this.goals.push({
goalScorerName: scorerName,
goalSide: this.getTeamName(teamId),
goalSpeed: this.ballSpeed,
goalTime: scores.time,
});
}

pointDistance(p1, p2) {
const d1 = p1.x - p2.x;
const d2 = p1.y - p2.y;
return Math.sqrt(d1 * d1 + d2 * d2);
}
 clearPlayersOffsidePosition(teamId) {
let offsidePlayers = {};

if (!teamId) {
offsidePlayers =
{ ...this.playersOffsidePosition[RED_TEAM_ID], ...this.playersOffsidePosition[BLUE_
TEAM_ID] };

this.playersOffsidePosition = {
[RED_TEAM_ID]: {},
[BLUE_TEAM_ID]: {},
};
} else {
offsidePlayers = { ...this.playersOffsidePosition[teamId] };
this.playersOffsidePosition[teamId] = {};
}

this.clearPlayersAvatars(offsidePlayers);
}

clearPlayersAvatars(offsidePlayers) {
const ids = Object.keys(offsidePlayers);

for (let i = 0; i < ids.length; i++) {

const playerId = ids[i];
const player = this.room.getPlayer(playerId);

if (player) {
this.resetPlayerAvatar(player);
}
}
}

clearTouchingTheBallTimestamp() {
this.touchingTheBallTimestamps = {};
}

clear() {
this.touchingTheBallTimestamps = {};
this.ballSpeed = 0;
this.prevBallPosition = null;
this.goals = [];
this.gameStartTimestamp = null;
this.gameEndTimestamp = null;
this.tick = 0;
this.isPaused = false;
this.votesForUnpause = {};
this.playersOffsidePosition = {
[RED_TEAM_ID]: {},
[BLUE_TEAM_ID]: {},
};
}

resetPlayerAvatar(player) {
const avatar = playersAvatars[player.name] || player.id;
this.room.setPlayerAvatar(player.id, `${avatar}`);
}
 resetTeamToInitPosition(teamId) {
const playerList = this.getPlayers();

for (let i = 0; i < playerList.length; i++) {

const player = playerList[i];

if (!teamId || (teamId && player.team === teamId)) {

const initPosition = this.playersInitPosition[player.team]
[player.id];

this.room.setPlayerDiscProperties(player.id, {
x: initPosition.x,
y: initPosition.y,
xspeed: 0,
yspeed: 0,
});
}
}
}

goToGameTab() {
try {
const roomLinkElement = this.getRoomLinkElement();
this.gamePageController = new GamePageController(roomLinkElement.href);
} catch (error) {
console.log(error);
}
}

getRoomLinkElement() {
return $(document.getElementsByTagName('iframe')
[0].contentWindow.document.body).find('a')[1];
}

waitForRoomLinkElement(callback) {
const element = this.getRoomLinkElement();

if (element) {
callback();
} else {
setTimeout(() => {
this.waitForRoomLinkElement(callback);
}, 500);
}
};

addSaveReplayButton() {
if (document.getElementById(SAVE_REPLAY_BUTTON_ID)) {
return;
}

let button = document.createElement("button");

button.id = SAVE_REPLAY_BUTTON_ID;
button.innerHTML = "SAVE REPLAY";
button.onclick = this.saveMatchResult.bind(this);
button.style.color = '#fff';
button.style.height = '100px';
button.style.width = '450px';
button.style.position = 'fixed';
 button.style.top = '300px';
button.style.left = '10px';
button.style.fontSize = '36px';
button.style.background = 'linear-gradient(#8da86b, #658d59)';
button.style.border = '4px solid white';
button.style.borderRadius = '50px';
button.style.cursor = 'pointer';

button = document.body.appendChild(button);
}

saveMatchResult() {
try {
if (this.matchResult) {
this.client.postMatchResult(this.matchResult,
this.handlePostMatchResult.bind(this));
} else {
throw new Error('Match not found');
}
} catch (error) {
console.log(error);
}
}

setHostHandicap() {
this.gamePageController.sendMessage('/handicap ' + HOST_HANDICAP);
}

class GamePageController {

constructor(pageUrl) {
this.page = window.open(pageUrl);
}

getDocument() {
return this.page.document.getElementsByTagName('iframe')
[0].contentWindow.document;
}

getInputBox() {
return this.getDocument().getElementsByClassName('input')[0];
}

getInput() {
return this.getInputBox().children[0];
}

getSendButton() {
return this.getInputBox().children[1];
}

sendMessage(message = '') {
const input = this.getInput();
const button = this.getSendButton();

input.value = message;
button.click();
 }

showConfirmModal(message = '') {
return this.page.confirm(message);
}

class Client {

getCalculatedTeams(playerList, callback) {
let url = BACKEND_BASE_URL + 'findTeams?'

for (let i = 0; i < playerList.length; i++) {

var player = playerList[i];
url += 'players[]=' + player.name + '&';
}

$.get(url, function (data) {

callback(data.red, data.blue);
});
}

postMatchResult(matchResult, callback){
$.ajax({
type: "POST",
url: BACKEND_BASE_URL + 'calculatedMatch/new', // move this to const
dataType: 'application/json',
data: matchResult,
success: callback,
});
}

function init(){
try {
console.log('--- starting room ---');
var haxBallController = new HaxBallController()
.initRoom()
.initListeners()
.initUserInterface()
;

window.haxBallController = haxBallController;
window.room = haxBallController.getRoom();
console.log('--- room started ---');
} catch (error) {
console.log('fooking error', error);
}
}

(function() {
'use strict';
window.onHBLoaded = init;
})();