I have ZERO interest in favouring a winner since i am only taking a 3% fee.
The fact you're taking a fee has nothing to do with whether or not you would play on your site and use information that only you have access to to gain an unfair advantage over players. You could easily do this undetected and make more money.
Again, i am at the opposing end of traditional casinos that take 97% instead of 3% and that i showed in one of my first messages in the posts i wrote you.
The traditional casino doesn't take 97%. If they offer a game with a 3% house edge, they will profit 3% of the total wagered, just like you.
Provably fair is a nonsense as you already know
You're uninformed about provably fair. Do some research.
I am not a scammer, i can even show you the source code since i am the programmer myself,
Cool, post it.
i never bet against my players and i can show that as well.
Cool, prove it. Make it so that you couldn't exploit the players even if you wanted to also...of course this would require a provably fair system which you think is nonsense.
I will take care of all your nonsense one step at a time.
1. I m posting the code (backend) and since it s a lot, i will have 1 post for each game. Here's Keno Frenzy
Keno Frenzy
This is the code that generates the numbers, broadcasts the results and controls the auto-pilot (automated betting system for players)
var ev
var kenoBet = require ('../../models/Keno Frenzy/keno.model')
var keno = []
var result
var kenoValue
var kenoWinner = require('./winner')
var objects = require ('../../objects')
var duplicates = require ('../../duplicates')
var autoPilot = require('../../auto-pilot')
var time = 1
module.exports = function (socket, kenoCB, breakCB, event, kenoPotSchema, User, kenoSchema) {
function getRandomIntInclusive(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive
}
(function () {
var caller = arguments.callee
var interval1 = setInterval(() => {
kenoValue = getRandomIntInclusive(1, 80)
result = keno.find((val) => {return val === kenoValue})
while( result !== undefined ){
kenoValue = getRandomIntInclusive(1, 80)
result = keno.find((val) => {return val === kenoValue})
}
keno.push(kenoValue)
socket.of('/api/keno-frenzy').emit('keno-plot', {kenoValue: kenoValue, draw: keno, event: ev})
kenoCB(kenoValue)
if (time === 1) {
clearInterval(interval1)
kenoSchema.find({event: ev}, (e1,r1) => {
r1.forEach((val) => {
const result = keno.concat(val.chosenNumbers)
kenoSchema.findByIdAndUpdate(val._id, {matched: duplicates(result), $set: {draw: keno}}, {new: true}, (e2, r2) => {
socket.of('/api/keno-frenzy').emit('table', {avatar: r2.avatar, username: r2.username, matched: r2.matched})
})
})
keno.length = 0
var pause = 20
kenoWinner(socket, ev, kenoPotSchema, User, kenoSchema, () => {
objects.kenoPlayers = 0
ev = Date.now()
event(ev)
breakCB(pause)
socket.of('/api/keno-frenzy').emit('break', {break: pause})
kenoPotSchema.find({}, (e, rf) => {
var pot = 0
rf.forEach((obj) => {
pot = pot + obj.pot
})
kenoPotSchema.remove({}, () => {
kenoPotSchema.create({
pot: 0 + pot,
timeOfInsertionms: Date.now(),
event: ev
}).then((finalPot) => {
autoPilot.preKeno(pause, ev, socket)
var int = setInterval(() => {
kenoBet.countDocuments({event: ev}, (err, count) => {
if (count >= 1) {
clearInterval(int)
socket.of('/api/keno-frenzy').emit('remaining', {remaining: 0})
var interval2 = setInterval(() => {
socket.of('/api/keno-frenzy').emit('break', {break: pause})
breakCB(pause)
if (pause === 1) {
clearInterval(interval2)
time = 10
kenoBet.countDocuments({event: ev}, (err, count) => {
objects.kenoPlayers = count !== undefined ? count : 0
socket.of('/api/online').emit('players', {rocket: objects.rocketPlayers, keno: objects.kenoPlayers, stock: objects.stockPlayers})
})
caller()
}
pause--
}, 1000)
}
else {
socket.of('/api/keno-frenzy').emit('remaining', {remaining: 10 - count})
}
})
}, 1000)
})
})
})
})})
}
time--
}, 1000)
})()
}
This is the code called inside the previous block to split the pot between the winner(s).
var topEarners = require ('../../models/Top 3/top-earners.model')
module.exports = function (socket, event, kenoPotSchema, User, kenoSchema, cb) {
kenoSchema.aggregate([
{$match: {$and:[{event: event}]} },
{$group: {
_id: "$matched",
winners: {$push:'$username'}
}},
{$sort:{_id:-1}},
{$limit:1}
]).then((res) => {
if (res.length > 0 && event) {
kenoPotSchema.findOne({event: event}, (e, r) => {
var partialPot = r.pot / res[0].winners.length
res[0].winners.forEach((winner) => {
User.findOneAndUpdate({username: winner}, {$inc:{accountValue: partialPot}}, {new:true}, (e3, r3) => {
topEarners.create({
username: r3.username,
avatar: r3.avatar,
winnings: partialPot,
timeOfInsertionms: Date.now()
}).then(() => {})
socket.of('/api/keno-frenzy').emit('table', {avatar: r3.avatar, event: event, username: winner, matched: res[0]._id, result: 'winner'})
})
})
kenoPotSchema.findByIdAndDelete(r._id, () => {
cb()
})
})
}
else {
cb()
}
})
}
Here is the code for the auto-pilot called in the same first block:
exports.preKeno = function (kenoPause, kenoEvent, socket) {
kenoArr.forEach((player) => {
User.findOne({username: player.username}, (e1, resp) => {
if(player.noOfGames !== 0 && resp.accountValue >= Math.pow(2, player.tickets - 1)) {
if (player.noOfGames !== -1) {
const index = kenoArr.indexOf(player)
kenoArr.splice(index, 1, {
username: player.username,
avatar: player.avatar,
chosenNumbers: player.chosenNumbers,
tickets: player.tickets,
noOfGames: player.noOfGames - 1
})
}
// User.findOne({username: player.username}, (eee1, resss) => {
if (kenoPause > 1 && resp.accountValue >= Math.pow(2, player.tickets - 1) && player.tickets >= 1 && player.chosenNumbers.length === 10 + (player.tickets-1)) {
kenoSchema.findOne({username: player.username, event: kenoEvent}, (err, res) => {
if (!res || res === null || res === undefined) {
kenoSchema.create({
username: player.username,
avatar: player.avatar,
ticketsPrice: Math.pow(2, player.tickets - 1),
tickets: player.tickets,
availableTickets: player.tickets,
chosenNumbers: player.chosenNumbers,
timeOfInsertion: new Date(Date.now()),
timeOfInsertionms: Date.now(),
event: kenoEvent
}).then((val) => {
topTickets.create({
username: val.username,
avatar: val.avatar,
tickets: val.tickets,
timeOfInsertionms: Date.now()
}).then(() => {})
// player.soc.emit('buy-ticket', {tickets: val.tickets, event: val.event})
socket.of('/api/keno-frenzy').emit('table', {avatar: val.avatar, username: val.username, event: val.event})
User.findOneAndUpdate({username: val.username}, {$inc: {accountValue: -val.ticketsPrice}}, (e, r555) => {
revenue.findOneAndUpdate({game: 'Keno Frenzy'}, {$inc:{amount: 0.03 * val.ticketsPrice}}, {new: true}, (ex, rx) => {
if (rx && rx !== undefined && rx !== null) {
kenoPotSchema.findOneAndUpdate({event: kenoEvent}, {$inc:{pot: 0.97 * val.ticketsPrice}}, {new: true}, (e2, r2) => {
socket.of('/api/keno-frenzy').emit('pot', {pot: r2.pot, event: r2.event})
})
}
else {
revenue.create({
game: 'Keno Frenzy',
amount: 0.03 * val.ticketsPrice
}).then(() => {
kenoPotSchema.findOneAndUpdate({event: kenoEvent}, {$inc:{pot: 0.97 * val.ticketsPrice}}, {new: true}, (e2, r2) => {
socket.of('/api/keno-frenzy').emit('pot', {pot: r2.pot, event: r2.event})
})
})
}
})
})
})
}
else{
}
})
}
// })
}
else {
autoPilot.findOneAndUpdate({username: player.username}, {
keno: false,
avatar: player.avatar,
$set:{'kenoSettings.$.chosenNumbers': [],
'kenoSettings.$.tickets': 0,
'kenoSettings.$.noOfGames': 0}
}, {new: true}, (e, r) => {
const index = kenoArr.indexOf(player)
kenoArr.splice(index, 1)
})
}
})
})
}
