${Utils.t("charges")}
@@ -4395,172 +4332,244 @@
}
async function processImage() {
- const { width, height, pixels } = state.imageData;
- const { x: startX, y: startY } = state.startPosition;
- const { x: regionX, y: regionY } = state.region;
+ const { width, height, pixels } = state.imageData
+ const { x: startX, y: startY } = state.startPosition
+ const { x: regionX, y: regionY } = state.region
+
+ const startRow = state.lastPosition.y || 0
+ const startCol = state.lastPosition.x || 0
if (!state.paintedMap) {
- state.paintedMap = Array(height).fill().map(() => Array(width).fill(false));
+ state.paintedMap = Array(height)
+ .fill()
+ .map(() => Array(width).fill(false))
}
- function computePixelOrder() {
- const order = [];
- const isValid = (x, y) => {
- const idx = (y * width + x) * 4;
- const a = pixels[idx + 3];
- if (a < CONFIG.TRANSPARENCY_THRESHOLD) return false;
- if (!state.paintWhitePixels && Utils.isWhitePixel(pixels[idx], pixels[idx + 1], pixels[idx + 2])) return false;
- return true;
- };
- switch (state.drawingStyle) {
- case 'outline': {
- const dirs = [[1,0],[0,1],[-1,0],[0,-1]]; // clockwise order for nicer tracing
- const dist = Array(height).fill().map(()=>Array(width).fill(-1));
+ let pixelBatch = null;
- const isBoundary = (x,y) => {
- for (const [dx,dy] of dirs) {
- const nx=x+dx, ny=y+dy;
- if (nx<0||ny<0||nx>=width||ny>=height) return true;
- if (!isValid(nx,ny)) return true;
+ try {
+ outerLoop: for (let y = startRow; y < height; y++) {
+ for (let x = y === startRow ? startCol : 0; x < width; x++) {
+ if (state.stopFlag) {
+ if (pixelBatch && pixelBatch.pixels.length > 0) {
+ await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
}
- return false;
- };
-
- const q=[];
- for (let y=0;y
=width||ny>=height) continue;
- if (dist[ny][nx]!==-1) continue; if (!isValid(nx,ny)) continue;
- dist[ny][nx]=dist[y][x]+1; q.push([nx,ny]);
- }
+ if (state.paintedMap[y][x]) continue
+
+ const idx = (y * width + x) * 4
+ const r = pixels[idx]
+ const g = pixels[idx + 1]
+ const b = pixels[idx + 2]
+ const alpha = pixels[idx + 3]
+
+ if (alpha < CONFIG.TRANSPARENCY_THRESHOLD || (!state.paintWhitePixels && Utils.isWhitePixel(r, g, b))) {
+ continue;
}
- // Determine maximum layer
- let maxLayer=0; for (let y=0;ymaxLayer) maxLayer=dist[y][x];
+ let targetRgb;
+ if (Utils.isWhitePixel(r, g, b)) {
+ targetRgb = [255, 255, 255];
+ } else {
+ targetRgb = Utils.findClosestPaletteColor(r, g, b, state.activeColorPalette);
+ }
- const order=[];
- const traverseLoop=(sx,sy,L,remaining)=>{
- const stack=[[sx,sy]]; // DFS
- while(stack.length){
- const [x,y]=stack.pop();
- const key=y*width+x; if(!remaining.has(key)) continue;
- remaining.delete(key); order.push({x,y});
- for (const [dx,dy] of dirs) {
- const nx=x+dx, ny=y+dy; if(nx<0||ny<0||nx>=width||ny>=height) continue;
- if (dist[ny][nx]===L && remaining.has(ny*width+nx)) stack.push([nx,ny]);
+ const colorId = findClosestColor([r, g, b], state.availableColors);
+
+ let absX = startX + x;
+ let absY = startY + y;
+
+ let adderX = Math.floor(absX / 1000);
+ let adderY = Math.floor(absY / 1000);
+ let pixelX = absX % 1000;
+ let pixelY = absY % 1000;
+
+ if (!pixelBatch ||
+ pixelBatch.regionX !== regionX + adderX ||
+ pixelBatch.regionY !== regionY + adderY) {
+
+ if (pixelBatch && pixelBatch.pixels.length > 0) {
+ let success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
+ if (success === "token_error") {
+ if (CONFIG.AUTO_CAPTCHA_ENABLED) {
+ updateUI("captchaSolving", "warning");
+ try {
+ await handleCaptcha();
+ success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
+ if (success === "token_error") {
+ updateUI("captchaFailed", "error");
+ state.stopFlag = true;
+ break outerLoop;
+ }
+ } catch (e) {
+ updateUI("captchaFailed", "error");
+ state.stopFlag = true;
+ break outerLoop;
+ }
+ } else {
+ updateUI("captchaNeeded", "error");
+ Utils.showAlert(Utils.t("captchaNeeded"), "error");
+ state.stopFlag = true;
+ break outerLoop;
+ }
+ }
+ if (success) {
+ pixelBatch.pixels.forEach((p) => {
+ state.paintedMap[p.localY][p.localX] = true;
+ state.paintedPixels++;
+ });
+ state.currentCharges -= pixelBatch.pixels.length;
+ updateUI("paintingProgress", "default", {
+ painted: state.paintedPixels,
+ total: state.totalPixels,
+ })
+
+ if (state.paintedPixels % 50 === 0) {
+ Utils.saveProgress()
+ }
+
+ if (CONFIG.PAINTING_SPEED_ENABLED && state.paintingSpeed > 0 && pixelBatch.pixels.length > 0) {
+ const delayPerPixel = 1000 / state.paintingSpeed // ms per pixel
+ const totalDelay = Math.max(100, delayPerPixel * pixelBatch.pixels.length) // minimum 100ms
+ await Utils.sleep(totalDelay)
+ }
+ updateStats();
+ }
+
+ }
+
+ pixelBatch = {
+ regionX: regionX + adderX,
+ regionY: regionY + adderY,
+ pixels: []
+ };
+ }
+
+ pixelBatch.pixels.push({
+ x: pixelX,
+ y: pixelY,
+ color: colorId,
+ localX: x,
+ localY: y,
+ });
+
+ if (pixelBatch.pixels.length >= Math.floor(state.currentCharges)) {
+ let success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
+ if (success === "token_error") {
+ if (CONFIG.AUTO_CAPTCHA_ENABLED) {
+ updateUI("captchaSolving", "warning");
+ try {
+ await handleCaptcha();
+ success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
+ if (success === "token_error") {
+ updateUI("captchaFailed", "error");
+ state.stopFlag = true;
+ break outerLoop;
+ }
+ } catch (e) {
+ updateUI("captchaFailed", "error");
+ state.stopFlag = true;
+ break outerLoop;
+ }
+ } else {
+ updateUI("captchaNeeded", "error");
+ Utils.showAlert(Utils.t("captchaNeeded"), "error");
+ state.stopFlag = true;
+ break outerLoop;
}
}
- };
- for (let L=0; L<=maxLayer; L++) {
- const remaining = new Set();
- for (let y=0;y {
+ state.paintedMap[pixel.localY][pixel.localX] = true;
+ state.paintedPixels++;
+ })
+
+ state.currentCharges -= pixelBatch.pixels.length;
+ updateStats()
+ updateUI("paintingProgress", "default", {
+ painted: state.paintedPixels,
+ total: state.totalPixels,
+ })
+
+ if (state.paintedPixels % 50 === 0) {
+ Utils.saveProgress()
+ }
+
+ if (CONFIG.PAINTING_SPEED_ENABLED && state.paintingSpeed > 0 && pixelBatch.pixels.length > 0) {
+ const delayPerPixel = 1000 / state.paintingSpeed // ms per pixel
+ const totalDelay = Math.max(100, delayPerPixel * pixelBatch.pixels.length) // minimum 100ms
+ await Utils.sleep(totalDelay)
+ }
}
- }
- return order;
- }
- case 'spiral': {
- const visited = Array(height).fill().map(()=>Array(width).fill(false));
- let cx=Math.floor(width/2), cy=Math.floor(height/2); let steps=1; const dirs=[[1,0],[0,1],[-1,0],[0,-1]]; let dir=0; if (isValid(cx,cy)) order.push({x:cx,y:cy}); visited[cy][cx]=true;
- while(order.length < width*height){ for(let r=0;r<2;r++){ const [dx,dy]=dirs[dir%4]; for(let s=0;s=width||cy>=height) continue; if(!visited[cy][cx]){visited[cy][cx]=true; if(isValid(cx,cy)) order.push({x:cx,y:cy});}} dir++; } steps++; if(steps>Math.max(width,height)*2) break;}
- return order;
- }
- case 'random': {
- for (let y=0;y0;i--){const j=Math.floor(Math.random()*(i+1)); [order[i],order[j]]=[order[j],order[i]];}
- return order;
- }
- case 'diagonal': {
- const buckets=new Map();
- for (let y=0;ya-b).flatMap(k=>buckets.get(k));
- }
- case 'checkerboard': {
- const first=[], second=[]; for (let y=0;y0) {
- const success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
- if (success === 'token_error') { state.stopFlag=true; break; }
- if (success) {
- pixelBatch.pixels.forEach(p=>{ state.paintedMap[p.localY][p.localX]=true; state.paintedPixels++; });
- state.currentCharges -= pixelBatch.pixels.length; updateStats();
- updateUI('paintingProgress','default',{painted:state.paintedPixels,total:state.totalPixels});
- if (state.paintedPixels % 50 === 0) Utils.saveProgress();
- if (CONFIG.PAINTING_SPEED_ENABLED && state.paintingSpeed>0 && pixelBatch.pixels.length>0) { const d=1000/state.paintingSpeed; const t=Math.max(100,d*pixelBatch.pixels.length); await Utils.sleep(t);}
+ pixelBatch.pixels = [];
}
+
+ while (state.currentCharges < state.cooldownChargeThreshold && !state.stopFlag) {
+ const { charges, cooldown } = await WPlaceService.getCharges();
+ state.currentCharges = Math.floor(charges);
+ state.cooldown = cooldown;
+
+ if (state.currentCharges >= state.cooldownChargeThreshold) {
+ updateStats();
+ break;
+ }
+
+ updateUI("noChargesThreshold", "warning", {
+ time: Utils.formatTime(state.cooldown),
+ threshold: state.cooldownChargeThreshold,
+ current: state.currentCharges
+ });
+ await updateStats();
+ await Utils.sleep(state.cooldown);
+ }
+ if (state.stopFlag) break outerLoop;
+
}
- pixelBatch = { regionX: regionX+adderX, regionY: regionY+adderY, pixels: [] };
}
- pixelBatch.pixels.push({x:pixelX,y:pixelY,color:colorId,localX:x,localY:y});
- if (pixelBatch.pixels.length >= Math.floor(state.currentCharges)) {
- let success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
- if (success === 'token_error') { state.stopFlag=true; break; }
+
+ if (pixelBatch && pixelBatch.pixels.length > 0 && !state.stopFlag) {
+ const success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
if (success) {
- pixelBatch.pixels.forEach(p=>{ state.paintedMap[p.localY][p.localX]=true; state.paintedPixels++; });
- state.currentCharges -= pixelBatch.pixels.length; updateStats();
- updateUI('paintingProgress','default',{painted:state.paintedPixels,total:state.totalPixels});
- if (state.paintedPixels % 50 === 0) Utils.saveProgress();
- if (CONFIG.PAINTING_SPEED_ENABLED && state.paintingSpeed>0 && pixelBatch.pixels.length>0) { const d=1000/state.paintingSpeed; const t=Math.max(100,d*pixelBatch.pixels.length); await Utils.sleep(t);}
- }
- pixelBatch.pixels=[];
- while (state.currentCharges < state.cooldownChargeThreshold && !state.stopFlag) {
- const { charges, cooldown } = await WPlaceService.getCharges();
- state.currentCharges = Math.floor(charges); state.cooldown = cooldown;
- if (state.currentCharges >= state.cooldownChargeThreshold) { updateStats(); break; }
- updateUI('noChargesThreshold','warning',{ time: Utils.formatTime(state.cooldown), threshold: state.cooldownChargeThreshold, current: state.currentCharges });
- await updateStats(); await Utils.sleep(state.cooldown);
+ pixelBatch.pixels.forEach((pixel) => {
+ state.paintedMap[pixel.localY][pixel.localX] = true
+ state.paintedPixels++
+ })
+ state.currentCharges -= pixelBatch.pixels.length;
+ if (CONFIG.PAINTING_SPEED_ENABLED && state.paintingSpeed > 0 && pixelBatch.pixels.length > 0) {
+ const delayPerPixel = 1000 / state.paintingSpeed // ms per pixel
+ const totalDelay = Math.max(100, delayPerPixel * pixelBatch.pixels.length) // minimum 100ms
+ await Utils.sleep(totalDelay)
+ }
}
}
- state.lastPixelIndex = i;
+ } finally {
+ if (window._chargesInterval) clearInterval(window._chargesInterval)
+ window._chargesInterval = null
}
- if (!state.stopFlag && pixelBatch && pixelBatch.pixels.length>0) {
- const success = await sendPixelBatch(pixelBatch.pixels, pixelBatch.regionX, pixelBatch.regionY);
- if (success) {
- pixelBatch.pixels.forEach(p=>{ state.paintedMap[p.localY][p.localX]=true; state.paintedPixels++; });
- state.currentCharges -= pixelBatch.pixels.length;
+ if (state.stopFlag) {
+ updateUI("paintingStopped", "warning")
+ Utils.saveProgress()
+ } else {
+ updateUI("paintingComplete", "success", { count: state.paintedPixels })
+ state.lastPosition = { x: 0, y: 0 }
+ state.paintedMap = null
+ Utils.clearProgress()
+ overlayManager.clear();
+ const toggleOverlayBtn = document.getElementById('toggleOverlayBtn');
+ if (toggleOverlayBtn) {
+ toggleOverlayBtn.classList.remove('active');
+ toggleOverlayBtn.disabled = true;
}
}
- if (window._chargesInterval) clearInterval(window._chargesInterval); window._chargesInterval=null;
- if (state.stopFlag) { updateUI('paintingStopped','warning'); Utils.saveProgress(); }
- else { updateUI('paintingComplete','success',{count:state.paintedPixels}); state.lastPosition={x:0,y:0}; state.paintedMap=null; state.pixelOrder=null; state.lastPixelIndex=0; Utils.clearProgress(); overlayManager.clear(); const toggleOverlayBtn=document.getElementById('toggleOverlayBtn'); if (toggleOverlayBtn){ toggleOverlayBtn.classList.remove('active'); toggleOverlayBtn.disabled=true; } }
- updateStats();
+ updateStats()
}
async function sendPixelBatch(pixelBatch, regionX, regionY) {
@@ -4614,7 +4623,6 @@
minimized: state.minimized,
overlayOpacity: state.overlayOpacity,
blueMarbleEnabled: document.getElementById('enableBlueMarbleToggle')?.checked,
- drawingStyle: state.drawingStyle,
};
CONFIG.PAINTING_SPEED_ENABLED = settings.paintingSpeedEnabled;
CONFIG.AUTO_CAPTCHA_ENABLED = settings.autoCaptchaEnabled;
@@ -4638,7 +4646,6 @@
CONFIG.AUTO_CAPTCHA_ENABLED = settings.autoCaptchaEnabled ?? false;
state.overlayOpacity = settings.overlayOpacity ?? CONFIG.OVERLAY.OPACITY_DEFAULT;
state.blueMarbleEnabled = settings.blueMarbleEnabled ?? CONFIG.OVERLAY.BLUE_MARBLE_DEFAULT;
- state.drawingStyle = settings.drawingStyle || 'normal';
const speedSlider = document.getElementById('speedSlider');
if (speedSlider) speedSlider.value = state.paintingSpeed;
@@ -4662,8 +4669,6 @@
if (overlayOpacityValue) overlayOpacityValue.textContent = `${Math.round(state.overlayOpacity * 100)}%`;
const enableBlueMarbleToggle = document.getElementById('enableBlueMarbleToggle');
if (enableBlueMarbleToggle) enableBlueMarbleToggle.checked = state.blueMarbleEnabled;
- const drawingStyleSelectEl = document.getElementById('drawingStyleSelect');
- if (drawingStyleSelectEl) drawingStyleSelectEl.value = state.drawingStyle;
} catch (e) {
console.warn("Could not load bot settings:", e);