better-owop-js

v1.1.4

Published

3 years ago

better owop-js

Downloads

0High
0Medium
0Low

mathias377

better OWOP.js (BETA)

TO-DO

remove WeirdDataView from not needed places like setPixel move etc.

changelog

added canvasUtils added pasteImageData changed paste to pasteChunk

repaired unsafe

added isWorldConnected
added Client.destroyed
added Client.destroy()\

removed id event use join insted

OWOPUnlocked variable fix

wolfMove fix

now it will use webpack emitter on unlocked OWOPs
removed html check (now you will be able to see motd)

getPixel and requestChunk is now queued so you can just use await getPixel
EventEmitter for browser should be faster and node js uses normal EventEmitter
Fixed gae memory leak which causing 2 gb of memory while requesting 200x200x2 chunks I did 500x500x2 screenshot using this link

Added parseMessage
Added wolfMove to setPixel which checks if you must move or not
Added login using Captcha token
Added bot nick

Render captcha returns captcha token

Installing: npm i better-owop-js.
REQUIRES NODE.JS 12.0+!

You can use it in opm.

OPM Example

You can connect to my owop from opm using server selector

const BOJS = OPM.require("better-owop-js");
const Client = new BOJS.Client({
	ws: OWOP.options.serverAddress[0].url
});

Client.on("join", () => {
    console.log(Client.player.id);
});

Browser Example (just paste)

const BOJS = OPM.require("better-owop-js");
const Client = new BOJS.Client({
	protocol: 0 // if you want connecto to bop it's owop,
	ws: "ws://104.237.150.24:1337",
	world: "owop", // default world is owop on his owop
	unsafe: true // because pixel bucket is ignored in bop it's owop and then you will can use infinity setPixel
});

Client.on("join", () => {
    console.log(Client.player.id);
});

Node.js Example

const BOJS = require("better-owop-js");
const Client = new BOJS.Client({
    reconnect: true,
    controller: true
});

Client.on("join", () => {
    Client.chat.send("Hello, OWOP from BOJS!");
});

Events

open - WebSocket connecting got opened.
close - WebSocket connecting got closed [close reason].
join - Joined to world [world name, id].
rawMessage - Raw websocked message (ArrayBuffer or string) [data].
updatedPlayers - Players updates [players object].
updatedPixels - Pixels update [pixels object].
playersLeft - a player left [players id object].
newPlayers - a player connected [player id].
teleport - got 'teleport' opcode. Very rare. [x, y].
rank - Got new rank. [rank].
captcha - Captcha state. [gcaptcha id].
chunkProtect - Chunk (un)protected. [x, y, newState].
pquota - New PQuota. [rate, per].
chunk - New chunk. [x, y, chunk, protected, isNew].
message - New message in chat. [msg, parsedMessage].
destroy - Socket was destroyed and will not reconnect until you will call bot.makeSocket().
Emits when you gets ban.

Options

ws - Websocket server address. (default - wss://ourworldofpixels.com)
origin - Origin header (default - https://ourworldofpixels.com).
autoMakeSocket - should make socket automatically (default - true)
autoConnectWorld - should join world automatically (default - true)
protocol - protocol id so if you set to 0 you will be able to connect bop it owop (default - 1)
captchaSiteKey - captcha key used only on browser to render captcha (default - 6LcgvScUAAAAAARUXtwrM8MP0A0N70z4DHNJh-KI)
id - ID for logging. If not set, OWOP ID will be used.
agent - Proxy Agent.
world - World name. (default - main).
log - default true.
reconnect - Reconnect if disconnected.
adminlogin - Admin login.
modlogin - Mod login.
pass - Pass for world.
nick - Nick of bot.
captchaPass - Captcha pass.
captchaToken - Automatically sends to server captcha token if provided.
teleport - Teleport on 'teleport' opcode.
controller - Enable controller for this bot. (Use only once!).
reconnectTime - Reconnect time (ms) after disconnect (default - 5000).
worldVerification - world verification code (default - 25565) unsafe - Use methods that are supposed to be only for admin or moderator or checking bucket.

Module

When you require lib, you get object with:

Client - main OJS Client class (requires options object).
Bucket - Bucket class for quota.
ChunkSystem - Class for chunks, pixels management.
EventEmitter - opcionally if you use browser version
WeirdDataView - Normal dataView which automatically adds offset

let dv = new BOJS.WeirdDataView(new ArrayBuffer(1));
//dv.setUint8(value, offset = this.offset, addToOffset = true)
dv.setUint8(1, null, false);
dv.getUint8(); // 1

API

Client

Client API is similar to OWOP, and some methods have same 'path'.

<\static> Client.options

Object with OWOP options. Check code to see them.

Client.clientOptions

Options that you passed in options argument.

Client.chat

Client.chat.parseMessage

Parses message to [userInfo, messageContent, isTell, rawMessage]

Client.chat.send(msg)

Send message in chat.

Client.chat.sendModifier

Function for modifying and getting messages that you gonna send.

Client.chat.recvModifier

Function for modifying and getting messages that you're getting from server.

Client.chat.messages

All messages that you got. Keep in mind that it can only hold maximum of Client.options.maxChatBuffer messages in it (default - 256).

Client.world

Client.world.pasteChunk(chunkX, chunkY, chunkData)

Pastes chunk

async Client.world.pasteImageData(pixelX, pixelY, imageData, isCanvasOrImage)

Pastes imageData/image/canvas

let imageData = canvasUtils.createImageData(10, 10);
let i = canvasUtils.getIbyXY(1, 3);

imageData.data[i] = 123;
imageData.data[i + 1] = 32;
imageData.data[i + 2] = 123;
imageData.data[i + 3] = 255; // then it will not be transparent

await bot.world.pasteImageData(12, 12, imageData); // pastes one pixel
bot.on("chunk", (x, y) => {
	if(x === Math.floor(12 / 16) && y === Math.floor(12 / 16)) bot.world.pasteImageData(12, 13, canvasUtils.imageDataToCtx(imageData).canvas, true); // pastes pixel under pixel
});

Client.world.join(name)

Function to join world. Should not be used, only for internal use! For connections to new worlds you should use new Client with world option in it.

Client.world.leave()

Leave world. If there's reconnect option enabled, client will try to reconnect after options.reconnectTime (default - 5000ms) seconds.

Client.world.move(x = 0, y = 0)

Move bot to X, Y.

Client.world.setPixel(x = player.x, y = player.y, color = player.color, wolfMove, sneaky, move = isAdmin)

Move and set pixel. If sneaky option is set to true, bot will return to old location.
wolf move checks if it must move when it is more than 3 chunks from x and y

Client.world.setTool(id = 0)

Set tool that bot has eqquiped.

Client.world.setColor(color = [0, 0, 0])

Set color of bot.

Client.world.protectChunk(x = player.x, y = player.y, newState = 1)

Protect chunk. You need to be admin to use this but you can ignore this if you'll use unsafe option.

Client.world.clearChunk(x = player.x, y = player.y, rgb = player.color)

Clear chunk. You need to be admin to use this but you can ignore this if you'll use unsafe option.

await Client.world.requestChunk(x = player.x, y = player.y, innacurate)

Request chunk, it'll be loaded to ChunkSystem. If inaccurate argument is passed, it'll transform x and y to chunkX and chunkY, so you can use normal coords to request chunks. Returns raw chunk.

if(inaccurate) {
	x = Math.floor(x/Client.options.chunkSize);
	y = Math.floor(y/Client.options.chunkSize);
};

await Client.world.getPixel(x = player.x, y = player.y)

Request chunk and get pixel.

Client.destroy()

makes that it will not reconnect until you will call bot.makeSocket()

Client.makeSocket()

makes socket of bot

Client.player

Client.player.x
Client.player.y
Client.player.tool
Client.player.rank
Client.player.nick
Client.player.id
Client.player.color
Client.player.pixelBucket - instance of Bucket for pixelQuota.
Client.player.chatBucket - instance of Bucket for chatQuota.

Client.players

List of players. Every player is object with properties:

x
y
id
color
tool
rank
nick

Example: Client.players[15035].

Client.captcha

renderCaptcha(uniquename = true) - renders captcha. If used on browser renders captcha otherwise throws error
login(token) - tries to login using captcha token

<\static> Client.utils

Client.utils.Player (id) - class of player
Client.utils.createChunkFromRGB (color) - used for older protocol which is on bop it's owop
Client.utils.decompress (compressedChunk) - Chunk decompressor. Vars :(
Client.utils.shouldMove (x1, y1, x2, y2) - used for wolf move (go to setPixel)
Client.utils.removeAlphaFromImageData (imagedata) - removes alpha channel - renamed and moved to canvasUtils
Client.utils.isArraysSame (...arrays) - Checks if arrays are same

Client.chunkSystem

Instance of ChunkSystem

ChunkSystem

This class is created just for Client.chunkSystem.

Chunks

All chunks and pixels stuff goes here.

Chunks.chunks - array with chunks. In this array chunks are saved like this: Chunks.chunks[x][y].
Chunks.chunkProtected - same thing as chunks but only for protected chunks.

Keep in mind, that you'll usually only need Chunks.getPixel from all this stuff here.

ChunkSystem.setChunk(x, y, data)

Set chunk data.

ChunkSystem.getChunk(x, y)

Get chunk data.

ChunkSystem.removeChunk(x, y)

Remove chunk.

ChunkSystem.setPixel(x, y, rgb)

Set pixel in chunk.

ChunkSystem.getPixel(x, y)

Get pixel from chunk.

ChunkSystem.setChunkProtect(x, y, newState)

(un)Protect chunk.

ChunkSystem.getIbyXY(x, y, width)

so chunk is saved like that
Uint8ClampedArray(768) [
123, 123, 213, 123, 123, 213, ... to 16 * 3 (because pixel is 3 places)
123, 123, 213, 123, 123, 213, ... to 16 * 3
... to 16
]
1 pixel is 3 places in this array\

so to get one pixel you need multiply y * width and add x and multiply it by 3 (y*width+x)*3
if you have alpha channel (ex. in image) it doesn't exists in normal chunks because it is always 255 it will be multiplied by 4\

if you want get x and y from i you will need do\

i = i/3; // or 4 read before

let pos = {
	x: i % width,
	y: Math.floor(i/width)
};

ChunkSystem.isProtected(x, y)

Is chunk protected.

canvasUtils

canvasUtils._lerp(color1, color2, factor = 0.5)

lerps color

canvasUtils._lerp(255, 123, 0.1); // 242

canvasUtils.lerp(color1, color2, factor = 0.5)

lerps RGB array

canvasUtils.lerp([255, 255, 255], [123, 123, 123], 0.1); // Uint8ClampedArray(3) [242, 242, 242]

canvasUtils.imageDataToCtx(imageData)

converts imageData to ctx
ps. canvas = ctx.canvas

canvasUtils.createCanvas(width, height)

Creates canvas.
Remeber that if you know on what engine(browser, nodejs) you are working faster will be creating canvas normal way

canvasUtils.createImageData(...arguments)

Creates imageData

canvasUtils.createImageData(width, height);
canvasUtils.createImageData(imageData);

canvasUtils.dataToImageData(data, width, height, hasAlpha = true, alpha = 255)