MKs906CH

1var mysql = require('mysql');
2var log4js = require('log4js');
3var io = require('socket.io')(8080);
4var request = require('request');
5var fs = require('fs');
6var md5 = require('md5');
7var sha256 = require('sha256');
8var math = require('mathjs');
9var config = require('./config.json');
10var logger = log4js.getLogger();
11var crypto = require('crypto');
12
13updateLog();
14function updateLog() {
15	logger.debug('New log...');
16	
17	log4js.configure({
18		appenders: {
19			out:{ type: 'console' },
20			app:{ type: 'file', filename: 'logs/site/site_'+time()+'.log' }
21		},
22		categories: {
23			default: { appenders: [ 'out', 'app' ], level: 'all' }
24		}
25	});
26	setTimeout(function(){
27		updateLog();
28	}, 24 * 3600 * 1000);
29}
30
31var pool  = mysql.createPool({
32	database: config.database["database"],
33	host: config.database["host"],
34	user: config.database["user"],
35	password: config.database["password"]
36});
37
38
39process.on('uncaughtException', function (err) {
40	logger.trace('Strange error');
41	logger.debug(err);
42});
43
44
45
46//FOR ALL GAMES
47var canPlayersBet = 1;
48var amountGiveaway = 1000;
49
50var maxbet = config.optionsSite["maxbet"]; 
51var minbet = config.optionsSite["minbet"];
52
53var needLevelToSendCoins = config.optionsSite["needLevelToSendCoins"]; //For send coins
54var delayLoadPrices = config.optionsSite["delayLoadPrices"] //in Hours
55var xpPerLevel = config.optionsSite["xpPerLevel"];
56
57var groupId = config.optionsSite["groupId"];
58var coinGroupR = config.optionsSite["coinGroupR"];
59var coinNameR = config.optionsSite["coinNameR"];
60var coinCodeR = config.optionsSite["coinCodeR"];
61var coinFriendR = config.optionsSite["coinFriendR"];
62var AppID = config.optionsSite["AppID"];
63var ApiKey = config.optionsSite["ApiKey"];
64
65var nameForGame = config.optionsSite["nameForGame"];
66var nameSite = config.optionsSite["nameSite"];
67
68var timeGiveaway = config.optionsSite["timeGiveaway"]; //hours
69
70var timeJPot = config.optionsSite["timeJPot"];	//time wait round
71
72var timerRoulette = config.optionsSite["timerRoulette"]; //seconds
73
74var maxCoinflips = config.optionsSite["maxCoinflips"]; //per user
75
76var waitStartingCrash = config.optionsSite["waitStartingCrash"]; //seconds
77
78
79/* CONNECT TO SOCKET */
80io.on('connection', function(socket) {
81	var user = false;
82	socket.on('hash', function(hash) {
83		query('SELECT `steamid`, `rank`, `balance`, `name`, `avatar`, `banPlay` FROM `users` WHERE `hash` = '+pool.escape(hash), function(err, row) {
84			if((err) || (!row.length)){
85				return socket.disconnect();
86			}else{
87				user = row[0];
88				users[user.steamid] = {
89					socket: socket.id,
90					balance: parseInt(user.balance)
91				}
92				socket.join(user.steamid);
93				timesFlooding[user.steamid] = 0;
94				
95				//100 ROLLS ROULETTE
96				socket.emit('message', {
97					type: '100rolls',
98					rolls: historyRolls100
99				});
100				
101				
102				//FIRST DATES
103				var sendRHash;
104				if(roundedHash == null) {
105					sendRHash = '0';
106				}else {
107					sendRHash = roundedHash;
108				}
109				
110				socket.emit('message', {
111					type: 'hello',
112					count: timer-wait,
113					maxbet: maxbet,
114					minbet: minbet,
115					roundedHash: sendRHash,
116					rolls: historyRolls,
117					balance: user.balance,
118					rank: user.rank,
119					user: user.steamid
120				});
121				
122				//ROULETTE
123				if(currentBets.length > 0){
124					currentBets.forEach(function(itm) {
125						socket.emit('message', {
126							type: 'bet',
127							bet: {
128								amount: itm.amount,
129								betid: itm.betid,
130								icon: itm.icon,
131								lower: itm.lower,
132								upper: itm.upper,
133								name: itm.name,
134								user: itm.user,
135								level: itm.level,
136								won: null
137							},
138							sums: {
139								0: currentSums['0-0'],
140								1: currentSums['1-7'],
141								2: currentSums['8-14']
142							}
143						});
144					});
145				}
146				
147				//MESSAGES
148				if(msgChatHist.length > 0){
149					msgChatHist.forEach(function(itm) {
150						socket.emit('message', {
151							type: 'chat',
152							msg: itm.msg,
153							name: itm.name,
154							icon: itm.icon,
155							user: itm.user,
156							rank: itm.rank,
157							lang: itm.lang,
158							hide: itm.hide,
159							level: itm.level,
160							id: itm.id,
161							time: itm.time
162						});
163					});
164				}
165				
166				//USERS ONLINE
167				io.sockets.emit('message', {
168					type: 'logins',
169					count: Object.size(io.sockets.connected)
170				});
171				
172				//CRASH
173				if(crashState == 'STARTED'){
174					socket.emit('message', {
175						type: 'startedCrash',
176						elapsed: new Date().getTime() - startCrashTime
177					});
178					
179					if(betsCrash.length > 0){
180						betsCrash.forEach(function(bet){
181							socket.emit('message', {
182								type: 'crbet',
183								bet: {
184									id: bet.id,
185									amount: bet.amount,
186									icon: bet.icon,
187									name: bet.name,
188									level: bet.level
189								}
190							});
191							
192							if(usersCrash[bet.user] !== undefined){
193								if(usersCrash[bet.user]['cashedOut'] == true) {
194									io.sockets.emit('message', {
195										type: 'betCrashWin',
196										id: bet.id,
197										cashout: usersCrash[bet.user]['autoCashout'],
198										profit: usersCrash[bet.user]['profit']
199									});
200								}
201							}
202						});
203					}
204				} else if(crashState == 'ENDED'){
205					socket.emit('message', {
206						type: 'crashed',
207						number: crashAt,
208						time: endedCrashTime
209					});
210				}
211				
212				if(usersCrash[user.steamid] !== undefined){
213					var win = usersCrash[user.steamid]['amount'] + usersCrash[user.steamid]['profit'];
214					socket.emit('message', {
215						type: 'btnCrashWin',
216						amount: win
217					});
218				}
219				
220				
221				//MINES
222				if(gamesMines[user.steamid] !== undefined && !gamesMines[user.steamid]['lose'] && !gamesMines[user.steamid]['cashout'] && gamesMines[user.steamid]['bombsWin'].length > 0){
223					var xSum = 0;
224					gamesMines[user.steamid]['bombsWin'].forEach(function(itm) {
225						socket.emit('message', {
226							type: 'getBomb',
227							mtype: 'win',
228							buttons: itm,
229							stake: gamesMines[user.steamid]['amountWin'],
230							next: gamesMines[user.steamid]['sums'][gamesMines[user.steamid]['bombsWin'].length],
231							amount: gamesMines[user.steamid]['sums'][xSum],
232							new: false
233						});
234						xSum++;
235					});
236				}
237				
238				
239				//GIVEAWAY
240				if(usersEntered.length > 0){
241					usersEntered.forEach(function(itm) {
242						socket.emit('message', {
243							type: 'joinGiveaway',
244							player: {
245								avatar: itm.avatar,
246								steamid: itm.user,
247								name: itm.name
248							}
249						});
250					});
251				}
252					
253				socket.emit('message', {
254					type: 'timerGiveaway',
255					mod: 'timer',
256					time: timerGAWAY,
257					last: lastWinnerGiveaway
258				});
259				socket.emit('message', {
260					type: 'amountGiveaway',
261					amount: amountGiveaway
262				});
263				
264				//JACKPOT
265				if((usersJPot[user.steamid] !== undefined) && (usersJPot[user.steamid] >= 1)) {
266					var change = parseFloat(100 * amountJPot[user.steamid] / totalJPot).toFixed(2);
267					
268					socket.emit('message', {
269						type: 'addChangeJPot',
270						change: change
271					});
272				}
273				if(betsJPot.length > 0){
274					betsJPot.forEach(function(itm){
275						socket.emit('message', {
276							type: 'addBetJPot',
277							bet: {
278								user: itm.user,
279								avatar: itm.avatar,
280								name: itm.name,
281								amount: itm.amount,
282								tick1: itm.tick1,
283								tick2: itm.tick2
284							},
285							total: totalJPot
286						});
287					});
288				}
289				
290				socket.emit('message', {
291					type: 'lastWinnerJP',
292					last: lastWinnerJP
293				});
294			}
295		});
296	});
297	socket.on('mes', function(m) {
298		if(!user) return;
299		
300		if(users[user.steamid] === undefined) return;
301		
302		if(canPlayersBet == 0){
303			socket.emit('message', {
304				type: 'error',
305				enable: false,
306				error: 'Error: The server are now offline. Please try again later!'
307			});
308			return;
309		}
310		
311		if(user.banPlay == 1){
312			socket.emit('message', {
313				type: 'error',
314				enable: false,
315				error: 'Error: You are banned to playing!'
316			});
317			return;
318		}
319		
320		logger.debug(user.name+" ("+user.steamid+")");
321		logger.debug(m);
322
323		
324		
325		if(m.type == "verifyAcc") return verifyAcc(user, socket);
326		
327		if(m.type == "availableR") return availableR(m, user, socket);
328		if(m.type == "groupR") return groupR(m, user, socket);
329		if(m.type == "nameR") return nameR(m, user, socket);
330		if(m.type == "codeR") return codeR(m, user, socket);
331		if(m.type == "bonusR") return bonusR(m, user, socket);
332		if(m.type == "createR") return createR(m, user, socket);
333
334		if(m.type == "createBonus") return createBonus(m, user, socket);
335		
336		if(m.type == "tradeurl") return saveTradelink(m, user, socket);
337		
338		if(m.type == "joinJackpot") return joinJackpot(m, user, socket);
339		
340		if(m.type == "joinInG") return joinInGiveaway(user, socket);
341		
342		if(m.type == "mines") {
343			if(m.mtype == 'play') {
344				return playMines(m, user, socket);
345			}else if(m.mtype == 'cashout') {
346				return cashoutMines(user, socket);
347			}else if(m.mtype == 'getBomb') {
348				return getBombMines(m, user, socket);
349			}
350		}
351		
352		if(m.type == "crbet") {
353			if(m.mtype == 'joinCrash') {
354				return crashBet(m, user, socket);
355			}else if(m.mtype == 'withdraw') {
356				return crashCashout(m, user, socket);
357			}
358		}
359		
360		if(m.type == "bet") return setBet(m, user, socket);
361		
362		if(m.type == "getMsg") return getMsg(user, socket);
363		if(m.type == "balance") return getBalance(user.steamid, socket);
364		if(m.type == "chat") return ch(m, user, socket);
365		if(m.type == "plus") return plus(user, socket);
366		
367		if(m.type == "createcfgame") return createCFGame(m, user, socket);
368		if(m.type == "joincfgame") return joinCFGame(m, user, socket);
369		if(m.type == "watchcfgame") return watchCFGame(m, user, socket);
370	});
371	
372	socket.on('disconnect', function() {
373		io.sockets.emit('message', {
374			type: 'logins',
375			count: Object.size(io.sockets.connected)
376		});
377
378		delete users[user.steamid];
379		socket.leave(user.steamid);
380	});
381});
382/* END CONNECT TO SOCKET */
383/* CHAT */
384var msgChatHist = [];
385var msgCurently = 0;
386var last_message = {};
387var timesFlooding = {};
388
389function getMsg(user, socket){
390	socket.emit('message', {
391		type: 'chatEmpty'
392	});
393	if(msgChatHist.length > 0){
394		msgChatHist.forEach(function(itm) {
395			socket.emit('message', {
396				type: 'chat',
397				msg: itm.msg,
398				name: itm.name,
399				icon: itm.icon,
400				user: itm.user,
401				rank: itm.rank,
402				lang: itm.lang,
403				hide: itm.hide,
404				level: itm.level,
405				id: itm.id,
406				time: itm.time
407			});
408		});
409	}
410}
411function ch(m, user, socket) {
412	if(m.msg) {
413		query('SELECT `bets`, `balance`, `rank`, `mute` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err, row) {
414			if((err) || (!row.length)) {
415				logger.error('Failed to get the person in the database');
416				logger.debug(err);
417				socket.emit('message', {
418					type: 'error',
419					enable: false,
420					error: 'Error: User not in DB!'
421				});
422				return;
423			}
424			
425			var n = parseFloat(row[0].bets % Math.pow(10, 3));
426			var xx = ((parseInt((row[0].bets - n)/xpPerLevel))*xpPerLevel);
427			var levelA = xx/xpPerLevel;
428			
429			var res = null;
430			if (res = /^\/send ([0-9]*) ([0-9]*)/.exec(m.msg)) {
431				logger.trace('We need to send coins from '+res[2]+' to '+res[1]);
432
433				if(res[1] == user.steamid){
434					socket.emit('message', {
435						type: 'error',
436						enable: false,
437						error: 'Error: You can\'t send coins to yourself!'
438					});
439					return;
440				}
441				if(levelA < needLevelToSendCoins){
442					socket.emit('message', {
443						type: 'error',
444						enable: false,
445						error: 'Error: You need to have level '+needLevelToSendCoins+' to send coins!'
446					});
447					return;
448				}
449				if(row[0].rank == 8 || row[0].rank == 5) {
450				// YOUTUBER OR STREAMER
451					socket.emit('message', {
452						type: 'error',
453						enable: false,
454						error: 'Error: You dont have permission to send coins because you have test coins!'
455					});
456					return;
457				}
458				if(row[0].balance < res[2]) {
459					socket.emit('message', {
460						type: 'error',
461						enable: false,
462						error: 'Error: Insufficient funds!'
463					});
464					return;
465				}
466				if(res[2] < minbet || res[2] > maxbet) {
467					socket.emit('message', {
468						type: 'error',
469						enable: false,
470						error: 'Error: Invalid bet amount ['+minbet+'-'+maxbet+']!'
471					});
472					return;
473				}
474				query('SELECT `name` FROM `users` WHERE `steamid` = '+pool.escape(res[1]), function(err2, row2) {
475					if((err2) || (!row2.length)) {
476						logger.error('Failed to get the STEAMID');
477						logger.debug(err2);
478						socket.emit('message', {
479							type: 'error',
480							enable: false,
481							error: 'Error: Unknown receiver!'
482						});
483						return;
484					}
485					query('UPDATE `users` SET `balance` = `balance` - '+res[2]+' WHERE `steamid` = '+pool.escape(user.steamid));
486					query('UPDATE `users` SET `balance` = `balance` + '+res[2]+' WHERE `steamid` = '+pool.escape(res[1]));
487					query('INSERT INTO `transfers` SET `from1` = '+pool.escape(user.steamid)+', `to1` = '+pool.escape(res[1])+', `amount` = '+pool.escape(res[2])+', `time` = '+pool.escape(time()));
488					socket.emit('message', {
489						type: 'alert',
490						alert: 'You sent '+res[2]+' coins to '+row2[0].name+'.'
491					});
492					getBalance(user.steamid, socket);
493					
494					io.sockets.in(res[1]).emit('message', {
495						type: 'refBalanceSend',
496						amount: res[2]
497					});
498					io.sockets.in(res[1]).emit('message', {
499						type: 'alert',
500						alert: 'You received '+res[2]+' coins from '+user.name+'!'
501					});
502				});
503			} else if (res = /^\/ban ([0-9]*) ([a-zA-Z0-9]*)/.exec(m.msg)) {
504				if(user.rank == 1 || user.rank == 100) { //ADMIN && OWNER
505					query('UPDATE `users` SET `banPlay` = 1, `reasonBanPlay` = '+pool.escape(res[2])+' WHERE `steamid` = '+pool.escape(res[1]));
506					socket.emit('message', {
507						type: 'alert',
508						alert: user.name+' banned '+res[1]+' for '+res[2]+'!'
509					});
510					io.sockets.in(res[1]).emit('message', {
511						type: 'alert',
512						alert: 'You have banned for '+res[2]+'!'
513					});
514					io.sockets.in(res[1]).emit('message', {
515						type: 'refreshPage'
516					});
517				}
518			} else if (res = /^\/mute ([0-9]*) ([0-9]*)/.exec(m.msg)) {
519				if(user.rank == 1 || user.rank == 2 || user.rank == 100){ //ADMIN && OWNER && MODERATOR
520					var t = time();
521					query('UPDATE `users` SET `mute` = '+parseInt(time() + res[2])+' WHERE `steamid` = '+pool.escape(res[1]));
522					socket.emit('message', {
523						type: 'alert',
524						alert: 'You mute '+res[1]+' to '+res[2]
525					});
526					
527					io.sockets.in(res[1]).emit('message', {
528						type: 'alert',
529						alert: 'You have muted for '+res[2]+' seconds!'
530					});
531				}
532			//CHAT
533			} else if (res = /^\/deletemsg ([0-9]*)/.exec(m.msg)) {
534				if(user.rank == 1 || user.rank == 2 || user.rank == 100){ //ADMIN && OWNER && MODERATOR
535					if(res[1] && res[1] <= msgCurently){
536						delete msgChatHist[res[1]];
537						socket.emit('message', {
538							type: 'alert',
539							alert: 'Message deleted!'
540						});
541						io.sockets.emit('message', {
542							type: 'deleteMsg',
543							id: res[1]
544						});
545					}else{
546						socket.emit('message', {
547							type: 'error',
548							enable: false,
549							error: 'Error: You are inserted an incorrect id!'
550						});
551						return;
552					}
553				}
554			} else if (res = /^\/clearchat/.exec(m.msg)) {
555				if(user.rank == 1 || user.rank == 2 || user.rank == 100){ //ADMIN && OWNER && MODERATOR
556					if(msgCurently > 0){
557						msgChatHist = [];
558						socket.emit('message', {
559							type: 'alert',
560							alert: 'Chat cleared!'
561						});
562						io.sockets.emit('message', {
563							type: 'deleteAllMsg',
564							rank: user.rank
565						});
566						msgCurently = 0;
567					}else{
568						socket.emit('message', {
569							type: 'error',
570							enable: false,
571							error: 'Error: There are no messages!'
572						});
573						return;
574					}
575				}
576			//GIVEAWAY
577			} else if (res = /^\/pickwinner/.exec(m.msg)) {
578				if(user.rank == 1 || user.rank == 100){ //ADMIN && OWNER
579					timerGAWAY = 0;
580					socket.emit('message', {
581						type: 'alert',
582						alert: 'Giveaway picking'
583					});
584				}
585			} else if (res = /^\/amountg ([0-9.]*)/.exec(m.msg)) {
586				if(user.rank == 1 || user.rank == 100){ //ADMIN && OWNER
587					if(res[1] > 0){
588						amountGiveaway = res[1];
589						io.sockets.emit('message', {
590							type: 'amountGiveaway',
591							amount: amountGiveaway
592						});
593						socket.emit('message', {
594							type: 'alert',
595							alert: 'Amount giveaway setted to '+amountGiveaway
596						});
597					}else{
598						socket.emit('message', {
599							type: 'error',
600							enable: false,
601							error: 'Error: Amount need be > 0!'
602						});
603						return;
604					}
605				}
606			//CRASH
607			} else if (res = /^\/nextcrash ([0-9.]*)/.exec(m.msg)) {
608				if(user.rank == 1 || user.rank == 100){ //ADMIN && OWNER
609					riggedMode = true;
610					riggedValue = parseInt(res[1]*100);
611
612					socket.emit('message', {
613						type: 'alert',
614						alert: 'Next crash set: '+(riggedValue/100).toFixed(2)+'x [Good luck !]'
615					});
616				}
617			} else if (res = /^\/crashnow/.exec(m.msg)) {
618				if(user.rank == 1 || user.rank == 100){ //ADMIN && OWNER
619					if(crashState == 'STARTED') {
620						crashAt = pointCrash * 100;
621						
622						socket.emit('message', {
623							type: 'alert',
624							alert: 'Crashed now, successfully!'
625						});
626					}else {
627						socket.emit('message', {
628							type: 'error',
629							error: 'Error: The game needs to be started!'
630						});
631						return;
632					}
633				}
634			//BETS FOR ALL
635			} else if (res = /^\/stopbets/.exec(m.msg)) {
636				if(user.rank == 1 || user.rank == 100){ //ADMIN && OWNER
637					canPlayersBet = 0;
638					io.sockets.emit('message', {
639						type: 'alert',
640						alert: 'The bets are now offline'
641					});
642				}
643			} else if (res = /^\/startbets/.exec(m.msg)) {
644				if(user.rank == 1 || user.rank == 100){ //ADMIN && OWNER
645					canPlayersBet = 1;
646					io.sockets.emit('message', {
647						type: 'alert',
648						alert: 'The bets are now online.'
649					});
650				}
651			//MESSAGE
652			} else {
653				if(row[0].mute > time()) {
654					socket.emit('message', {
655						type: 'alert',
656						alert: 'You are muted for '+parseInt((row[0].mute-time())/3600)+' hours'
657					});
658					return;
659				}
660				
661				var timeMsgH = new Date().getHours();
662				if(timeMsgH < 10) timeMsgH = '0'.concat(timeMsgH);
663				var timeMsgM = new Date().getMinutes();
664				if(timeMsgM < 10) timeMsgM = '0'.concat(timeMsgM);
665				var timeMsg = timeMsgH+":"+timeMsgM;
666				
667				io.sockets.emit('message', {
668					type: 'chat',
669					msg: safe_tags_replace(m.msg),
670					name: user.name,
671					icon: user.avatar,
672					user: user.steamid,
673					rank: user.rank,
674					lang: m.lang,
675					hide: m.hide,
676					level: levelA,
677					id: msgCurently,
678					time: timeMsg
679				});
680				
681				if(msgChatHist.length > 30){
682					msgChatHist.shift();
683				}
684				
685				msgChatHist.push({
686					msg: safe_tags_replace(m.msg),
687					name: user.name,
688					icon: user.avatar,
689					user: user.steamid,
690					rank: user.rank,
691					lang: m.lang,
692					hide: m.hide,
693					level: levelA,
694					id: msgCurently,
695					time: timeMsg
696				});
697				msgCurently++;
698			}
699		});
700	}
701}
702/* END CHAT */
703/* REFRESH BALANCE */
704function getBalance(steamid, socket) {
705	query('SELECT `balance` FROM `users` WHERE `steamid` = '+pool.escape(steamid), function(err, row) {
706		if((err) || (!row.length)) {
707			logger.error('Failed to load your balance');
708			logger.debug(err);
709			socket.emit('message', {
710				type: 'error',
711				enable: false,
712				error: 'Error: You are not DB!'
713			});
714			return;
715		}
716		socket.emit('message', {
717			type: 'balance',
718			balance: row[0].balance
719		});
720		users[steamid].balance = parseInt(row[0].balance);
721	});
722}
723/* END REFRESH BALANCE */
724/* TRADE LINK */
725function saveTradelink(m, user, socket){
726	if(!m.url){
727		socket.emit('message', {
728			type: 'error',
729			mtype: 'tradeLink',
730			enable: true,
731			error: 'Error: Tradelink cannot be empty!'
732		});
733		return;
734	}
735	
736	if(m.url.includes('https://steamcommunity.com/tradeoffer/new/?partner=') == false || m.url.includes('&token=') == false){
737		socket.emit('message', {
738			type: 'error',
739			mtype: 'tradeLink',
740			enable: true,
741			error: 'Error: Tradelink is invalid!'
742		});
743		return;
744	}
745	
746	query('UPDATE `users` SET `tradeLink` = '+pool.escape(m.url)+' WHERE `steamid`='+pool.escape(user.steamid), function(err, row) {
747		if(err) {
748			logger.error(err);
749			return;
750		}
751	});
752	
753	socket.emit('message', {
754		type: 'alert',
755		alert: 'Tradelink saved!'
756	});
757}
758/* END TRADE LINK */
759/* REWARDS */
760
761function availableR(m, user, socket){
762	request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key=926A7D90AE95AF66BE01CF96CD6C647D&steamid='+user.steamid+'&format=json', function(err1, response1) {
763		if(err1) {
764			logger.error(err1);
765			return;
766		}
767		
768		var csgo = false;
769		var res = JSON.parse(response1.body);
770		var games = res.response.games;
771		
772		if(games !== undefined){
773			games.forEach(function(game){
774				if(game.appid == AppID) csgo = true;
775			});
776		}
777		
778		if(!csgo){
779			socket.emit('message', {
780				type: 'error',
781				mtype: 'rewards',
782				ptype: m.type,
783				enable: true,
784				error: 'Error: You dont have '+nameForGame+'!'
785			});
786			return;
787		}
788		
789		query('SELECT `code` FROM `codes` WHERE `user` = '+pool.escape(user.steamid), function(err2, code){
790			if(err2){
791				socket.emit('message', {
792					type: 'error',
793					mtype: 'rewards',
794					ptype: m.type,
795					enable: true,
796					error: 'Error: You don\'t have a code to collect the coins!'
797				});
798				return;
799			}
800			
801			query('SELECT `referrals` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err3, coins){
802				if(err3) {
803					logger.error(err3);
804					return;
805				}
806				
807				if(coins[0].referrals == 0){
808					socket.emit('message', {
809						type: 'error',
810						mtype: 'rewards',
811						ptype: m.type,
812						enable: true,
813						error: 'Error: You do not have a coin to collect!'
814					});
815					return;
816				}
817				
818				if(coins[0].referrals > 0){
819					query('UPDATE `users` SET `balance` = `balance` + '+parseInt(coins[0].referrals)+', `referrals` = 0 WHERE `steamid`='+pool.escape(user.steamid), function(err4, row) {
820						if(err4) {
821							logger.error(err4);
822							return;
823						}
824						
825						getBalance(user.steamid, socket);
826						socket.emit('message', {
827							type: 'alert',
828							alert: 'You collected '+coins[0].referrals+' coins!'
829						});
830						
831						socket.emit('message', {
832							type: 'refRewards'
833						});
834					});
835					return;
836				}
837			});
838		});
839	});
840}
841
842function groupR(m, user, socket){
843	query('SELECT `groupR` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err1, row1){
844		if(err1) {
845			logger.error(err1);
846			return;
847		}
848		
849		if(parseInt(row1[0].nameR)){
850			socket.emit('message', {
851				type: 'error',
852				mtype: 'rewards',
853				ptype: m.type,
854				enable: true,
855				error: 'Error: You already collect the reward!'
856			});
857			return;
858		}
859		
860		request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key='+ApiKey+'&steamid='+user.steamid+'&format=json', function(err2, response2) {
861			if(err2) {
862				logger.error(err2);
863				return;
864			}
865			
866			var csgo = false;
867			var res = JSON.parse(response2.body);
868			var games = res.response.games;
869			
870			if(games !== undefined){
871				games.forEach(function(game){
872					if(game.appid == AppID) csgo = true;
873				});
874			}
875			
876			if(!csgo){
877				socket.emit('message', {
878					type: 'error',
879					mtype: 'rewards',
880					ptype: m.type,
881					enable: true,
882					error: 'Error: You dont have '+nameForGame+'!'
883				});
884				return;
885			}
886			
887			request('http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key='+ApiKey+'&steamids='+user.steamid, function(err3, response3) {
888				if(err3) {
889					logger.error(err3);
890					return;
891				}
892				
893				var res = JSON.parse(response3.body);
894				var idGroup = res.response.players[0].primaryclanid;
895				
896				if(idGroup != groupId){
897					socket.emit('message', {
898						type: 'error',
899						mtype: 'rewards',
900						ptype: m.type,
901						enable: true,
902						error: 'Error: Please join to '+nameSite+' Group and set primary group!'
903					});
904					return;
905				}
906				
907				query('UPDATE `users` SET `balance` = `balance` + '+parseInt(coinGroupR)+', `groupR` = 1 WHERE `steamid`='+pool.escape(user.steamid), function(err4, row4) {
908					if(err4) {
909						logger.error(err4);
910						return;
911					}
912					
913					getBalance(user.steamid, socket);
914					socket.emit('message', {
915						type: 'alert',
916						alert: 'You claimed '+coinGroupR+' coins!'
917					});
918					
919					socket.emit('message', {
920						type: 'refRewards'
921					});
922				});
923			});
924		});
925	});
926}
927
928function nameR(m, user, socket){
929	query('SELECT `nameR` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err1, row1){
930		if(err1) {
931			logger.error(err1);
932			return;
933		}
934		
935		if(parseInt(row1[0].nameR)){
936			socket.emit('message', {
937				type: 'error',
938				mtype: 'rewards',
939				ptype: m.type,
940				enable: true,
941				error: 'Error: You already collect the reward!'
942			});
943			return;
944		}
945		
946		request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key='+ApiKey+'&steamid='+user.steamid+'&format=json', function(err2, response2) {
947			if(err2) {
948				logger.error(err2);
949				return;
950			}
951			
952			var csgo = false;
953			var res = JSON.parse(response2.body);
954			var games = res.response.games;
955			
956			if(games !== undefined){
957				games.forEach(function(game){
958					if(game.appid == AppID) csgo = true;
959				});
960			}
961			
962			if(!csgo){
963				socket.emit('message', {
964					type: 'error',
965					mtype: 'rewards',
966					ptype: m.type,
967					enable: true,
968					error: 'Error: You dont have '+nameForGame+'!'
969				});
970				return;
971			}
972			
973			request('http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key='+ApiKey+'&steamids='+user.steamid, function(err3, response3) {
974				if(err3) {
975					logger.error(err3);
976					return;
977				}
978				
979				var res = JSON.parse(response3.body);
980				var name = res.response.players[0].personaname;
981				
982				if(!/CSGOKnight.eu/.exec(name)) {
983					socket.emit('message', {
984						type: 'error',
985						mtype: 'rewards',
986						ptype: m.type,
987						enable: true,
988						error: 'Error: Please add '+nameSite+' to your Steam name!'
989					});
990					return;
991				}
992				
993				query('UPDATE `users` SET `balance` = `balance` + '+parseInt(coinNameR)+', `nameR` = 1 WHERE `steamid`='+pool.escape(user.steamid), function(err4, row4) {
994					if(err4) {
995						logger.error(err4);
996						return;
997					}
998					
999					getBalance(user.steamid, socket);
1000					socket.emit('message', {
1001						type: 'alert',
1002						alert: 'You claimed '+coinNameR+' coins!'
1003					});
1004					
1005					socket.emit('message', {
1006						type: 'refRewards'
1007					});
1008				});
1009			});
1010		});
1011	});
1012}
1013
1014function codeR(m, user, socket){
1015	query('SELECT `codeR` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err1, row1){
1016		if(err1) {
1017			logger.error(err1);
1018			return;
1019		}
1020		
1021		if(parseInt(row1[0].codeR)){
1022			socket.emit('message', {
1023				type: 'error',
1024				mtype: 'rewards',
1025				ptype: m.type,
1026				enable: true,
1027				error: 'Error: You already collect the reward!'
1028			});
1029			return;
1030		}
1031		
1032		request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key='+ApiKey+'&steamid='+user.steamid+'&format=json', function(err2, response) {
1033			if(err2) {
1034				logger.error(err2);
1035				return;
1036			}
1037			
1038			var csgo = false;
1039			var res = JSON.parse(response.body);
1040			var games = res.response.games;
1041			
1042			if(games !== undefined){
1043				games.forEach(function(game){
1044					if(game.appid == AppID) csgo = true;
1045				});
1046			}
1047			
1048			if(!csgo){
1049				socket.emit('message', {
1050					type: 'error',
1051					mtype: 'rewards',
1052					ptype: m.type,
1053					enable: true,
1054					error: 'Error: You dont have '+nameForGame+'!'
1055				});
1056				return;
1057			}
1058			
1059			query('SELECT `user` FROM `codes` WHERE `code` = '+pool.escape(m.code), function(err3, row3){
1060				if(!row3[0]){
1061					socket.emit('message', {
1062						type: 'error',
1063						mtype: 'rewards',
1064						ptype: m.type,
1065						enable: true,
1066						error: 'Error: Code not found!'
1067					});
1068					return;
1069				}
1070				
1071				if(row3[0].user == user.steamid){
1072					socket.emit('message', {
1073						type: 'error',
1074						mtype: 'rewards',
1075						ptype: m.type,
1076						enable: true,
1077						error: 'Error: This is you referal code!'
1078					});
1079					return;
1080				}
1081				
1082				query('UPDATE `users` SET `balance` = `balance` + '+parseInt(coinCodeR)+', `codeR` = '+pool.escape(row3[0].user)+' WHERE `steamid` = '+pool.escape(user.steamid), function(err4, row4) {
1083					if(err4) {
1084						logger.error(err4);
1085						return;
1086					}
1087					
1088					getBalance(user.steamid, socket);
1089					socket.emit('message', {
1090						type: 'alert',
1091						alert: 'You claimed '+coinCodeR+' coins!'
1092					});
1093					
1094					socket.emit('message', {
1095						type: 'refRewards'
1096					});
1097				});
1098				
1099				query('UPDATE `users` SET `referrals` = `referrals` + '+parseInt(coinFriendR)+' WHERE `steamid` = '+pool.escape(row3[0].user), function(err5, row5) {
1100					if(err5) {
1101						logger.error(err5);
1102						return;
1103					}
1104				});
1105			});
1106		});
1107	});
1108}
1109
1110function bonusR(m, user, socket){
1111	query('SELECT * FROM `bonus` WHERE `steamid` = '+pool.escape(user.steamid), function(err1, row1){
1112		if(err1) {
1113			logger.error(err1);
1114			return;
1115		}
1116		
1117		if(row1[0]){
1118			socket.emit('message', {
1119				type: 'error',
1120				mtype: 'rewards',
1121				ptype: m.type,
1122				enable: true,
1123				error: 'Error: You already claimed the bonus code!'
1124			});
1125			return;
1126		}
1127
1128		query('SELECT `max_useds`, `useds`, `amount` FROM `bonus` WHERE `code` = '+pool.escape(m.code), function(err2, row2){
1129			if(!row2[0]){
1130				socket.emit('message', {
1131					type: 'error',
1132					mtype: 'rewards',
1133					ptype: m.type,
1134					enable: true,
1135					error: 'Error: This code is invalid!'
1136				});
1137				return;
1138			}
1139			
1140			if(row2[0].useds >= row2[0].max_useds){
1141				socket.emit('message', {
1142					type: 'error',
1143					mtype: 'rewards',
1144					ptype: m.type,
1145					enable: true,
1146					error: 'Error: The code is already maximum used!'
1147				});
1148				return;
1149			}
1150			
1151			request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key='+ApiKey+'&steamid='+user.steamid+'&format=json', function(err3, response3) {
1152				if(err3) {
1153					logger.error(err3);
1154					return;
1155				}
1156				
1157				var csgo = false;
1158				var res = JSON.parse(response3.body);
1159				var games = res.response.games;
1160				
1161				if(games !== undefined){
1162					games.forEach(function(game){
1163						if(game.appid == AppID) csgo = true;
1164					});
1165				}
1166				
1167				if(!csgo){
1168					socket.emit('message', {
1169						type: 'error',
1170						mtype: 'rewards',
1171						ptype: m.type,
1172						enable: true,
1173						error: 'Error: You dont have '+nameForGame+'!'
1174					});
1175					return;
1176				}
1177				
1178				query('UPDATE `users` SET `balance` = `balance` + '+parseInt(row2[0].amount)+' WHERE `steamid`='+pool.escape(user.steamid), function(err4, row4) {
1179					if(err4) {
1180						logger.error(err4);
1181						return;
1182					}
1183					
1184					getBalance(user.steamid, socket);
1185					socket.emit('message', {
1186						type: 'alert',
1187						alert: 'You claimed '+parseInt(row2[0].amount)+' coins!'
1188					});
1189					
1190					socket.emit('message', {
1191						type: 'refRewards'
1192					});
1193				});
1194				
1195				query('INSERT INTO `bonus` SET `steamid` = '+pool.escape(user.steamid), function(err5, row5) {
1196					if(err5) {
1197						logger.error(err5);
1198						return;
1199					}
1200				});
1201				
1202				query('UPDATE `bonus` SET `useds` = `useds` + 1 WHERE `code` = '+pool.escape(m.code), function(err6, row6) {
1203					if(err6) {
1204						logger.error(err6);
1205						return;
1206					}
1207				});
1208			});
1209		});
1210	});
1211}
1212
1213function createR(m, user, socket){
1214	request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key='+ApiKey+'&steamid='+user.steamid+'&format=json', function(err1, response) {
1215		if(err1) {
1216			logger.error(err1);
1217			return;
1218		}
1219		
1220		var csgo = false;
1221		var res = JSON.parse(response.body);
1222		var games = res.response.games;
1223		
1224		if(games !== undefined){
1225			games.forEach(function(game){
1226				if(game.appid == AppID) csgo = true;
1227			});
1228		}
1229		
1230		if(!csgo){
1231			socket.emit('message', {
1232				type: 'error',
1233				mtype: 'rewards',
1234				ptype: m.type,
1235				enable: true,
1236				error: 'Error: You dont have '+nameForGame+'!'
1237			});
1238			return;
1239		}
1240		
1241		query('SELECT `user` FROM `codes` WHERE `code` = '+pool.escape(m.code), function(err2, row2){
1242			if(row2[0]){
1243				socket.emit('message', {
1244					type: 'error',
1245					mtype: 'rewards',
1246					ptype: m.type,
1247					enable: true,
1248					error: 'Error: This code is already used!'
1249				});
1250				return;
1251			}
1252			
1253			if(!row2[0]){
1254				query('SELECT * FROM `codes` WHERE `user` = '+pool.escape(user.steamid), function(err3, row3){
1255					if(row3[0]){
1256						query('UPDATE `codes` SET `code` = '+pool.escape(m.code)+' WHERE `user`='+pool.escape(user.steamid), function(err4, row4) {
1257							if(err4) {
1258								logger.error(err4);
1259								return;
1260							}
1261							
1262							socket.emit('message', {
1263								type: 'alert',
1264								alert: 'Code updated!'
1265							});
1266							
1267							socket.emit('message', {
1268								type: 'refRewards'
1269							});
1270						});
1271						return;
1272					}
1273					
1274					if(!row3[0]){
1275						query('INSERT INTO `codes` SET `user` = '+pool.escape(user.steamid)+', `code` = '+pool.escape(m.code), function(err4, row4) {
1276							if(err4) {
1277								logger.error(err4);
1278								return;
1279							}
1280							
1281							socket.emit('message', {
1282								type: 'alert',
1283								alert: 'Code created!'
1284							});
1285						});
1286						return;
1287					}
1288				});
1289			}
1290		});
1291	});
1292}
1293
1294function createBonus(m, user, socket){
1295	if(user.rank != 1 && user.rank != 2 && user.rank != 100){
1296		socket.emit('message', {
1297			type: 'error',
1298			enable: false,
1299			error: 'Error: You don\'t have permission to use that!'
1300		});
1301		return;
1302	}
1303	
1304	if(!(/(^[0-9]*$)/.exec(m.amount))){
1305		socket.emit('message', {
1306			type: 'error',
1307			enable: false,
1308			error: 'Error: Invalid amount!'
1309		});
1310		return;
1311	}
1312	
1313	if(!(/(^[0-9]*$)/.exec(m.maxuseds))){
1314		socket.emit('message', {
1315			type: 'error',
1316			enable: false,
1317			error: 'Error: Invalid maximum users!'
1318		});
1319		return;
1320	}
1321	
1322	if(!(/(^[a-zA-Z0-9]*$)/.exec(m.code))){
1323		socket.emit('message', {
1324			type: 'error',
1325			enable: false,
1326			error: 'Error: Invalid code!'
1327		});
1328		return;
1329	}
1330	
1331	query('SELECT * FROM `bonus` WHERE `code` = '+pool.escape(m.code), function(err1, row1){
1332		if(row1.length != 0){
1333			socket.emit('message', {
1334				type: 'error',
1335				enable: false,
1336				error: 'Error: Code already exists!'
1337			});
1338			return;
1339		}
1340		
1341		query('TRUNCATE table `bonus`', function(){
1342			query('INSERT INTO `bonus` SET `code` = '+pool.escape(m.code)+', `amount` = '+parseInt(m.amount)+', `max_useds` = '+parseInt(m.maxuseds)+', `useds` = 0', function(err2, row2){
1343				if(err2){
1344					logger.error(err2);
1345					return;
1346				}
1347				
1348				socket.emit('message', {
1349					type: 'alert',
1350					alert: 'Code created!'
1351				});
1352			});
1353		});
1354	});
1355}
1356/* END REWARDS */
1357/* VERIFY ACC */
1358function verifyAcc(user, socket){
1359	request('http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/?key='+ApiKey+'&steamid='+user.steamid+'&format=json', function(err1, response) {
1360		if(err1) {
1361			logger.error(err1);
1362			return;
1363		}
1364		
1365		var csgo = false;
1366		var res = JSON.parse(response.body);
1367		var games = res.response.games;
1368		
1369		if(games !== undefined){
1370			games.forEach(function(game){
1371				if(game.appid == AppID) csgo = true;
1372			});
1373		}
1374		
1375		if(!csgo){
1376			socket.emit('message', {
1377				type: 'error',
1378				mtype: 'account',
1379				enable: true,
1380				error: 'Error: You dont have '+nameForGame+'!'
1381			});
1382			return;
1383		}
1384		
1385		query('SELECT `verified` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err2, row2){
1386			if(row2[0].verified == 1){
1387				socket.emit('message', {
1388					type: 'error',
1389					mtype: 'account',
1390					enable: true,
1391					error: 'Error: Your account is already verified!'
1392				});
1393				return;
1394			}
1395			
1396			query('UPDATE `users` SET `verified` = 1 WHERE `steamid` = '+pool.escape(user.steamid), function(err3, row3) {
1397				if(err3) {
1398					logger.error(err3);
1399					return;
1400				}
1401				
1402				socket.emit('message', {
1403					type: 'alert',
1404					alert: 'Account successfully verified!'
1405				});
1406				
1407				socket.emit('message', {
1408					type: 'refAccount'
1409				});
1410			});
1411		});
1412	});
1413}
1414/* END VERIFY ACC */
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426/* -------------- GAMES --------------*/
1427
1428
1429
1430
1431
1432/* CRASH */
1433var usersCrash = {};
1434var betsCrash = [];
1435
1436var riggedMode = false;
1437var riggedValue;
1438
1439var crashState = 'ENDED';
1440
1441var crashAt = 0;
1442var pointCrash = 0;
1443
1444var hashCodeCrash = '';
1445var secretCodeCrash = '';
1446var lotteryCodeCrash = '';
1447
1448var timerIntCrash;
1449var startCrashTime = 0;
1450var endedCrashTime = 0;
1451
1452hashCrash();
1453
1454function crashBet(m, user, socket) {
1455	if(usersCrash[user.steamid] !== undefined && usersCrash[user.steamid]['play']) {
1456		socket.emit('message', {
1457			type: 'error',
1458			mtype: 'crash',
1459			enable: true,
1460			error: 'Error: You have already joined the crash!'
1461		});
1462		return;
1463	}
1464	if(m.autoCash <= 100 && m.autoCash != 0) {
1465		socket.emit('message', {
1466			type: 'error',
1467			mtype: 'crash',
1468			enable: true,
1469			error: 'Error: Cashout needs to be more than 1.00x!'
1470		});
1471		return;
1472	}
1473	if(!(/(^[0-9.]*$)/.exec(m.autoCash))){
1474		socket.emit('message', {
1475			type: 'error',
1476			mtype: 'crash',
1477			enable: true,
1478			error: 'Error: Cashout needs to be more than 1.00x!'
1479		});
1480		logger.warn(user.steamid+' try to cheating to CRASH CASHOUT_AMOUNT');
1481		return;
1482	}
1483	if((m.amount < minbet) || (m.amount > maxbet)) {
1484		socket.emit('message', {
1485			type: 'error',
1486			mtype: 'crash',
1487			enable: true,
1488			error: 'Error: Invalid bet amount ['+minbet+'-'+maxbet+']!'
1489		});
1490		return;
1491	}
1492	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(m.amount)) {
1493		socket.emit('message', {
1494			type: 'error',
1495			mtype: 'crash',
1496			enable: true,
1497			error: 'Error: Invalid bet amount!'
1498
1499		});
1500		logger.warn(user.steamid+' try to cheating to CRASH BET_AMOUNT');
1501		return;
1502	}
1503	if(crashState != 'STARTING') {
1504		socket.emit('message', {
1505			type: 'error',
1506			mtype: 'crash',
1507			enable: true,
1508			error: 'Error: The game have been already started!'
1509		});
1510		return;
1511	}
1512	var start_time = new Date();
1513	query('SELECT `balance`, `countDeposits`, `bets` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err, row) {
1514		if((err) || (!row.length)) {
1515			logger.error('Failed to find DB');
1516			logger.debug(err);
1517			socket.emit('message', {
1518				type: 'error',
1519				mtype: 'crash',
1520				enable: true,
1521				error: 'Error: You are not DB!'
1522			});
1523			return;
1524		}
1525		
1526		var n = parseFloat(row[0].bets % Math.pow(10, 3));
1527		var xx = ((parseInt((row[0].bets - n)/xpPerLevel))*xpPerLevel);
1528		var levelA = xx/xpPerLevel;
1529		
1530		if(row[0].balance >= m.amount) {
1531			query('UPDATE `users` SET `balance` = `balance` - '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid), function(err2, row2) {
1532				if(err2) {
1533					logger.error('Error in withdraw');
1534					logger.debug(err);
1535					socket.emit('message', {
1536						type: 'error',
1537						mtype: 'crash',
1538						enable: true,
1539						error: 'Error: You dont have enough points!'
1540					});
1541					return;
1542				}
1543				
1544				if(row[0].countDeposits >= 1) query('UPDATE `users` SET `available` = `available` + '+parseInt(m.amount / 10)+', `bets` = `bets` + '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid));
1545				
1546				query('INSERT INTO `crbets` SET `user` = '+pool.escape(user.steamid)+', `amount` = '+pool.escape(m.amount)+', `autoCashout` = '+pool.escape((m.autoCash != 0) ? m.autoCash : 'infinity'), function(err3, row3) {
1547					if(err3) {
1548						logger.error('Error in DB');
1549						logger.debug(err);
1550						return;
1551					}
1552					var end = new Date();
1553
1554					if(usersCrash[user.steamid] === undefined) {
1555						usersCrash[user.steamid] = {
1556							'play': true,
1557							'id': row3.insertId,
1558							'amount': m.amount,
1559							'autoCashout': m.autoCash,
1560							'infinityCashout': false,
1561							'cashedOut': false,
1562							'profit': 0
1563						};
1564					}
1565					
1566					if(m.autoCash == 0) usersCrash[user.steamid]['infinityCashout'] = true;
1567					
1568					socket.emit('message', {
1569						type: 'crbetconfirm',
1570						bet: {
1571							id: row3.insertId,
1572							amount: m.amount,
1573							autoCashout: m.autoCash
1574						},
1575						exec: (end.getTime()-start_time.getTime()).toFixed(3)
1576					});
1577					
1578					io.sockets.emit('message', {
1579						type: 'crbet',
1580						bet: {
1581							id: row3.insertId,
1582							amount: m.amount,
1583							icon: user.avatar,
1584							name: user.name,
1585							level: levelA
1586						}
1587					});
1588					
1589					betsCrash.push({
1590						id: row3.insertId,
1591						amount: m.amount,
1592						autoCashout: m.autoCash,
1593						icon: user.avatar,
1594						name: user.name,
1595						user: user.steamid,
1596						level: levelA
1597					});
1598				
1599					logger.debug('Crash bet confirmed #'+row3.insertId+' | Amount: '+m.amount+' | AutoCashout: '+m.autoCash+' | User: '+pool.escape(user.steamid));
1600					
1601					getBalance(user.steamid, socket);
1602				});
1603			});
1604		} else {
1605			socket.emit('message', {
1606				type: 'error',
1607				mtype: 'crash',
1608				enable: true,
1609				error: 'Error: You dont have any money!'
1610			});
1611		}
1612	});
1613}
1614
1615function crashCashout(m, user, socket) {
1616	var crashPoint = pointCrash;
1617	if(crashState != 'STARTED') {
1618		socket.emit('message', {
1619			type: 'error',
1620			error: 'Error: The game is ended!'
1621		});
1622		return;
1623	}
1624	
1625	if(crashPoint <= 1.00) {
1626		socket.emit('message', {
1627			type: 'error',
1628			error: 'Error: Invalid crash!'
1629		});
1630		return;
1631	}
1632	
1633	if(usersCrash[user.steamid]['cashedOut'] == false) {
1634		var win = parseInt(usersCrash[user.steamid]['amount'] * parseFloat(crashPoint).toFixed(2));
1635		
1636		io.sockets.emit('message', {
1637			type: 'betCrashWin',
1638			id: usersCrash[user.steamid]['id'],
1639			cashout: (parseFloat(crashPoint).toFixed(2)),
1640			profit: parseInt(win - usersCrash[user.steamid]['amount'])
1641		});
1642		
1643		usersCrash[user.steamid]['cashedOut'] = true;
1644		usersCrash[user.steamid]['autoCashout'] = parseFloat(crashPoint).toFixed(2);
1645		usersCrash[user.steamid]['profit'] = parseInt(win - usersCrash[user.steamid]['amount']);
1646		
1647		socket.emit('message', {
1648			type: 'btnCrashWin',
1649			amount: win
1650		});
1651		
1652		query('UPDATE `users` SET `balance` = `balance` + '+parseInt(win)+' WHERE `steamid` = '+pool.escape(user.steamid), function(err){
1653			query('UPDATE `crbets` SET `autoCashout` = '+parseFloat(crashPoint).toFixed(2)+', `cashedOut` = 1 WHERE `id` = '+pool.escape(usersCrash[user.steamid]['id']));
1654			
1655			logger.debug('[CASHOUT] UPDATED BALANCE OF '+user.steamid+' WITH + '+parseInt(win - usersCrash[user.steamid]['amount'])+' [CASHOUT: '+parseFloat(crashPoint).toFixed(2)+'x]');
1656			getBalance(user.steamid, socket);
1657		});
1658	}else {
1659		socket.emit('message', {
1660			type: 'error',
1661			error: 'Error: You have already cashed out!'
1662		});
1663	}
1664}
1665
1666
1667function hashCrash() {
1668	crashState = 'STARTING';
1669	logger.debug('Starting crash!');
1670	
1671	io.sockets.emit('message', {
1672		type: 'resetCrash'
1673	});
1674	
1675	var startTimeCrash = waitStartingCrash;
1676	var timerWaintingCrash = setInterval(function(){
1677		if(startTimeCrash <= 0.01){
1678			clearInterval(timerWaintingCrash);
1679		}else{
1680			io.sockets.emit('message', {
1681				type: 'startingCrash',
1682				time: ((startTimeCrash).toFixed(1))
1683			});
1684			startTimeCrash -= 0.1;
1685		}
1686	},100);
1687	
1688	if(!riggedMode) {
1689		var genGameHash = function(serverSeed) {
1690			return crypto.createHash('sha256').update(serverSeed).digest('hex');
1691		};
1692		var serverSeed = makeCode();
1693		
1694		hashCodeCrash = genGameHash(serverSeed);
1695		secretCodeCrash = serverSeed;
1696		lotteryCodeCrash = time();
1697		
1698		var crashPointFromHash = function(serverSeed) {
1699			var hash = crypto.createHmac('sha256', serverSeed).digest('hex');
1700			var divisible = function divisible(hash, mod) {
1701				var val = 0;
1702				var o = hash.length % 4;
1703				for (var i = o > 0 ? o - 4 : 0; i < hash.length; i += 4) {
1704					val = ((val << 16) + parseInt(hash.substring(i, i+4), 16)) % mod;
1705				}
1706				return val === 0;
1707			};
1708			var INSTANT_CRASH_PERCENTAGE = 5;
1709			if (divisible(hash, 100 / parseInt(INSTANT_CRASH_PERCENTAGE, 10)))
1710			return 100;
1711			var h = parseInt(hash.slice(0,52/4),16);
1712			var e = Math.pow(2,52);
1713			return Math.floor((100 * e - h) / (e - h));
1714		};
1715		
1716		crashAt = crashPointFromHash(serverSeed);
1717		
1718		logger.debug('New crash: with crashPoint: ' + (crashAt / 100).toFixed(2) +'x');
1719	}else if(riggedMode) {
1720		crashAt = riggedValue;
1721		
1722		riggedMode = false;
1723		riggedValue = 0;
1724		
1725		logger.debug('Crash seted: with crashPoint: ' + (crashAt / 100).toFixed(2) +'x');
1726	}
1727	
1728	setTimeout(function() {
1729		startCrash();
1730	}, (waitStartingCrash + 1) * 1000);
1731}
1732
1733function startCrash(){
1734	crashState = 'STARTED';
1735	
1736	startCrashTime = new Date().getTime();
1737	
1738	io.sockets.emit('message', {
1739		type: 'startedCrash',
1740		elapsed: new Date().getTime() - startCrashTime
1741	});
1742
1743	function calcCrash1(ms) {
1744		var gamePayout = Math.floor(100 * calcCrash2(ms)) / 100;
1745		return gamePayout;
1746	}
1747
1748	function calcCrash2(ms) {
1749		var r = 0.00006;
1750		return Math.pow(Math.E, r * ms);
1751	}
1752
1753	timerIntCrash = setInterval(function(){
1754		pointCrash = calcCrash1(new Date().getTime() - startCrashTime);
1755		checkCrash();
1756	},100);
1757}
1758
1759function checkCrash(){
1760	var point = pointCrash * 100;
1761	
1762	if(betsCrash.length > 0){
1763		betsCrash.forEach(function(bet){
1764			if(usersCrash[bet.user]['cashedOut'] == false) {
1765				var win = parseInt(usersCrash[bet.user]['amount'] * parseFloat(point / 100).toFixed(2));
1766				io.sockets.emit('message', {
1767					type: 'btnCrashCashout',
1768					amount: win
1769				});
1770			}
1771		});
1772	}
1773	
1774	if(point >= crashAt){
1775		endedCrashTime = new Date().getTime() - startCrashTime;
1776		
1777		crashState = 'ENDED';
1778		
1779		io.sockets.emit('message', {
1780			type: 'crashed',
1781			number: crashAt,
1782			time: endedCrashTime
1783		});
1784		
1785		if(betsCrash.length > 0){
1786			betsCrash.forEach(function(bet){
1787				if(usersCrash[bet.user]['cashedOut'] == false) {
1788					io.sockets.emit('message', {
1789						type: 'betCrashLose',
1790						id: bet.id
1791					});
1792				}
1793			});
1794		}
1795		
1796		usersCrash = {};
1797		betsCrash = [];
1798		
1799		query('INSERT INTO `crash` SET `crashAt` = '+parseFloat(crashAt / 100).toFixed(2)+', `lottery` = '+pool.escape(lotteryCodeCrash)+', `secret` = '+pool.escape(secretCodeCrash)+', `hash` = '+pool.escape(hashCodeCrash));
1800		
1801		setTimeout(function() {
1802			hashCrash();
1803		}, 5000);
1804		
1805		clearInterval(timerIntCrash);
1806		
1807		logger.debug('Crash creshed at '+parseFloat(crashAt / 100).toFixed(2)+'x');
1808	}else{
1809		//CHECK AUTOCRASH
1810		if(betsCrash.length > 0){
1811			betsCrash.forEach(function(itm) {
1812				if(usersCrash[itm.user]['cashedOut'] == false) {
1813					if(usersCrash[itm.user]['infinityCashout'] == false){
1814						if(usersCrash[itm.user]['autoCashout'] <= point){
1815							var win = parseInt(usersCrash[itm.user]['amount'] * parseFloat(usersCrash[itm.user]['autoCashout'] / 100).toFixed(2));
1816							
1817							io.sockets.emit('message', {
1818								type: 'betCrashWin',
1819								id: itm.id,
1820								cashout: (parseFloat(usersCrash[itm.user]['autoCashout'] / 100).toFixed(2)),
1821								profit: parseInt(win - usersCrash[itm.user]['amount'])
1822							});
1823							
1824							io.sockets.in(itm.user).emit('message', {
1825								type: 'btnCrashWin',
1826								amount: win
1827							});
1828							
1829							usersCrash[itm.user]['cashedOut'] = true;
1830							usersCrash[itm.user]['profit'] = parseInt(win - usersCrash[itm.user]['amount']);
1831							
1832							query('UPDATE `users` SET `balance` = `balance` + '+parseInt(win)+' WHERE `steamid` = '+pool.escape(itm.user), function(err){
1833								if(err) {
1834									logger.error(err);
1835									return;
1836								}
1837								
1838								query('UPDATE `crbets` SET `autoCashout` = '+parseFloat(usersCrash[itm.user]['autoCashout'] / 100).toFixed(2)+', `cashedOut` = 1 WHERE `id` = '+pool.escape(usersCrash[itm.user]['id']));
1839								
1840								logger.debug('[CASHOUT] UPDATED BALANCE OF '+itm.user+' WITH + '+(win - usersCrash[itm.user]['amount'])+' [CASHOUT: '+(usersCrash[itm.user]['autoCashout'] / 100)+'x]');
1841								getBalance(itm.user, io.sockets.in(itm.user));
1842							});
1843						}
1844					}
1845				}
1846			});
1847		}
1848	}
1849}
1850/* END CRASH */
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861/* JACKPOT */
1862var usersJPot = {};
1863var amountJPot = {};
1864var betsJPot = [];
1865var totalJPot = 0;
1866var btJPot = 5;
1867var currentlyTick = 0;
1868
1869var widthJPot = 100; //do not modify
1870var stageJPot = 'WAIT';
1871
1872var jackpotId = 0;
1873var lastWinnerJP = {name: 'None', steamid: 0, avatar: 'http://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/fe/fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb.jpg', chance: 0, coins: 0};
1874
1875function getAvatarsWin(avatar, bets, tickets){
1876	var array = [];
1877	var totalAvatars = 100;
1878	
1879	for(var i = 0; i < totalAvatars; i++){
1880		var randomAvatar = getRandomInt(1, tickets);
1881		
1882		var avatarA;
1883		
1884		if(bets.length > 0){
1885			bets.forEach(function(itm){
1886				if((randomAvatar >= itm.tick1) && (randomAvatar <= itm.tick2)){
1887					avatarA = itm.avatar;
1888				}
1889			});
1890		}
1891		
1892		array.push(avatarA);
1893	}
1894	array[95] = avatar;
1895	
1896	return array;
1897}
1898
1899function joinJackpot(m, user, socket){
1900	if(stageJPot == 'PICKING') {
1901		socket.emit('message', {
1902			type: 'error',
1903			mtype: 'jackpot',
1904			enable: true,
1905			error: 'Error: Wait for preparing a new round!'
1906		});
1907		return;
1908	}
1909	
1910	if((usersJPot[user.steamid] !== undefined) && (usersJPot[user.steamid] == btJPot)) {
1911		socket.emit('message', {
1912			type: 'error',
1913			mtype: 'jackpot',
1914			enable: true,
1915			error: 'Error: You\'ve already entered in this jackpot for '+btJPot+' times!'
1916		});
1917		return;
1918	}
1919	
1920	if((m.amount < minbet) || (m.amount > maxbet)) {
1921		socket.emit('message', {
1922			type: 'error',
1923			mtype: 'jackpot',
1924			enable: true,
1925			error: 'Error: Invalid bet amount ['+minbet+'-'+maxbet+']!'
1926		});
1927		return;
1928	}
1929	
1930	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(m.amount)) {
1931		socket.emit('message', {
1932			type: 'error',
1933			mtype: 'jackpot',
1934			enable: true,
1935			error: 'Error: Invalid bet amount!'
1936		});
1937		logger.warn(user.steamid+' try to cheating to JACKPOT BET_AMOUNT');
1938		return;
1939	}
1940	
1941	var start_time = new Date();
1942	query('SELECT `balance`, `countDeposits` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err, row) {
1943		if((err) || (!row.length)) {
1944			logger.error('Failed to find DB');
1945			logger.debug(err);
1946			socket.emit('message', {
1947				type: 'error',
1948				mtype: 'jackpot',
1949				enable: true,
1950				error: 'Error: You are not DB!'
1951			});
1952			return;
1953		}
1954		
1955		if(row[0].balance >= m.amount) {
1956			query('UPDATE `users` SET `balance` = `balance` - '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid), function(err2, row2) {
1957				if(err2) {
1958					logger.error('Error in withdraw');
1959					logger.debug(err2);
1960					socket.emit('message', {
1961						type: 'error',
1962						mtype: 'jackpot',
1963						enable: true,
1964						error: 'Error: You dont have enough points!'
1965					});
1966					return;
1967				}
1968				
1969				if(row[0].countDeposits >= 1) query('UPDATE `users` SET `available` = `available` + '+parseInt(m.amount / 10)+', `bets` = `bets` + '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid));
1970				
1971				if(usersJPot[user.steamid] === undefined){
1972					usersJPot[user.steamid] = 1;
1973					amountJPot[user.steamid] = m.amount;
1974				}else{
1975					usersJPot[user.steamid]++;
1976					amountJPot[user.steamid] += m.amount;
1977				}
1978				
1979				totalJPot+=m.amount;
1980				
1981				betsJPot.push({
1982					user: user.steamid,
1983					avatar: user.avatar,
1984					name: user.name,
1985					amount: m.amount,
1986					tick1: (currentlyTick + 1),
1987					tick2: (parseInt(m.amount / 10) + currentlyTick)
1988				});
1989				
1990				if(betsJPot.length > 0){
1991					betsJPot.forEach(function(itm){
1992						var change = parseFloat(100 * amountJPot[itm.user] / totalJPot).toFixed(2);
1993						
1994						io.sockets.in(itm.user).emit('message', {
1995							type: 'addChangeJPot',
1996							change: change
1997						});
1998					});
1999				}
2000				
2001				socket.emit('message', {
2002					type: 'betConfJPot',
2003					amount: m.amount,
2004					br: usersJPot[user.steamid],
2005					tbr: btJPot
2006				});
2007				
2008				io.sockets.emit('message', {
2009					type: 'addBetJPot',
2010					bet: {
2011						user: user.steamid,
2012						avatar: user.avatar,
2013						name: user.name,
2014						amount: m.amount,
2015						tick1: (currentlyTick + 1),
2016						tick2: (parseInt(m.amount / 10) + currentlyTick)
2017					},
2018					total: totalJPot
2019				});
2020				
2021				currentlyTick = currentlyTick + parseInt(m.amount / 10);
2022				startJPot();
2023				
2024				logger.debug('Jackpot Bet confirmed Amount: '+m.amount+' | User: '+pool.escape(user.steamid));
2025				
2026				getBalance(user.steamid, socket);
2027			});
2028		} else {
2029			socket.emit('message', {
2030				type: 'error',
2031				mtype: 'jackpot',
2032				enable: true,
2033				error: 'Error: You dont have any money!'
2034			});
2035		}
2036	});
2037}
2038
2039var minusWJPot = (widthJPot/timeJPot).toFixed(2);
2040
2041function startJPot(){
2042	if(betsJPot.length >= 2 && Object.keys(usersJPot).length > 1){
2043		if(stageJPot == 'WAIT'){
2044			stageJPot = 'STARTED';
2045			var timerJPot = timeJPot;
2046			
2047			var intJPot = setInterval(function(){
2048				if(timerJPot >= 0){
2049					io.sockets.emit('message', {
2050						type: 'setTimesJPot',
2051						text: timerJPot+'s',
2052						start: true,
2053						width: widthJPot
2054					});
2055					
2056					widthJPot -= minusWJPot;
2057					timerJPot--;
2058				}else{
2059					clearInterval(intJPot);
2060					stageJPot = 'PICKING';
2061					
2062					io.sockets.emit('message', {
2063						type: 'setTimesJPot',
2064						text: 'Picking winner!',
2065						start: false
2066					});
2067					
2068					setTimeout(function(){
2069						pickingWinnerJPot();
2070					},4000);
2071				}
2072			}, 1000);
2073		}
2074	}
2075}
2076
2077function pickingWinnerJPot(){
2078	var nameWinner;
2079	var steamidWinner;
2080	var avatarWinner;
2081	
2082	var winnerTick = getRandomInt(1, currentlyTick);
2083	
2084	if(betsJPot.length > 0){
2085		betsJPot.forEach(function(itm){
2086			if((winnerTick >= itm.tick1) && (winnerTick <= itm.tick2)){
2087				nameWinner = itm.name;
2088				steamidWinner = itm.user;
2089				avatarWinner = itm.avatar;
2090			}
2091		});
2092	}
2093	
2094	var arrayAvatars = getAvatarsWin(avatarWinner, betsJPot, currentlyTick);
2095	
2096	io.sockets.emit('message', {
2097		type: 'rollJackpot',
2098		avatars: arrayAvatars
2099	});
2100	
2101	setTimeout(function(){
2102		io.sockets.emit('message', {
2103			type: 'setTimesJPot',
2104			text: 'The winner is '+nameWinner+' ('+steamidWinner+') | Ticket: '+winnerTick+'!',
2105			start: false
2106		});
2107		
2108		query('UPDATE `users` SET `balance`=`balance`+'+parseInt(totalJPot)+' WHERE `steamid`='+pool.escape(steamidWinner));
2109		getBalance(steamidWinner, io.sockets.in(steamidWinner));
2110		
2111		//ARRAY TOTAL PLAYERS, AMOUNTS AND TICKETS
2112		var arrayPlayers = [];
2113		var arrayAmounts = [];
2114		var arrayTickets = [];
2115		
2116		if(betsJPot.length > 0){
2117			betsJPot.forEach(function(itm){
2118				arrayPlayers.push(itm.user);
2119				arrayAmounts.push(itm.amount);
2120				arrayTickets.push(itm.tick1+'-'+itm.tick2);
2121			});
2122		}
2123		
2124		arrayPlayers = arrayPlayers.join('/');
2125		arrayAmounts = arrayAmounts.join('/');
2126		arrayTickets = arrayTickets.join('/');
2127		
2128		var chanceWin = parseFloat(100 * amountJPot[steamidWinner] / totalJPot).toFixed(2);
2129		
2130		//ADD HISTORY JACKPOT
2131		query('INSERT INTO `jackpot` SET `winner` = '+pool.escape(steamidWinner)+', `ticketwinner` = '+pool.escape(winnerTick)+', `chance` = '+pool.escape(chanceWin)+', `players` = '+pool.escape(arrayPlayers)+', `amounts` = '+pool.escape(arrayAmounts)+', `tickets` = '+pool.escape(arrayTickets)+', `hash` = '+pool.escape(getHash("JACKPOT", jackpotId))+', `amount` = '+pool.escape(totalJPot), function(err3, row3) {
2132			if(err3) {
2133				logger.error('Error in DB');
2134				logger.debug(err);
2135				return;
2136			}
2137			
2138			jackpotId = row3.insertId + 1;
2139		});
2140		
2141		io.sockets.in(steamidWinner).emit('message', {
2142			type: 'alert',
2143			alert: 'You won '+totalJPot+' at this jackpot with ticket '+winnerTick+'! Hash: '+terminatingHash
2144		});
2145		
2146		setTimeout(function(){
2147			lastWinnerJP = {steamid: steamidWinner, name: nameWinner, avatar: avatarWinner, chance: chanceWin, coins: totalJPot};
2148			
2149			stageJPot = 'WAIT';
2150			widthJPot = 100;
2151			
2152			usersJPot = {};
2153			amountJPot = {};
2154			betsJPot = [];
2155			totalJPot = 0;
2156			currentlyTick = 0;
2157			
2158			io.sockets.emit('message', {
2159				type: 'resetJPot'
2160			});
2161			io.sockets.emit('message', {
2162				type: 'setTimesJPot',
2163				text: 'Waiting for players...',
2164				start: false
2165			});
2166			io.sockets.emit('message', {
2167				type: 'lastWinnerJP',
2168				last: lastWinnerJP
2169			});
2170		},5000);
2171	},10300);
2172}
2173/* END JACKPOT */
2174
2175
2176
2177
2178
2179
2180
2181
2182/* GIVEAWAY */
2183var userJoin = {};
2184var usersEntered = [];
2185var giveawayState = 1;
2186var lastWinnerGiveaway = {steamid: 0, name: 'None', avatar: 'http://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/fe/fef49e7fa7e1997310d705b2a6158ff8dc1cdfeb.jpg'};
2187var timerGAWAY;
2188startGiveaway();  
2189
2190function startGiveaway() {
2191	userJoin = {};
2192	usersEntered = [];
2193	
2194	giveawayState = 0;
2195	logger.trace('Starting Giveaway');
2196	timerGAWAY = timeGiveaway * 3600;
2197	
2198	io.sockets.emit('message', {
2199		type: 'timerGiveaway',
2200		mod: 'timer',
2201		time: timerGAWAY,
2202		last: lastWinnerGiveaway
2203	});
2204	
2205	var timerGA = setInterval(function() {
2206		if (timerGAWAY == -2) {
2207			clearInterval(timerGA);
2208			
2209			giveawayState = 1;
2210			logger.trace('Pick Winner');
2211			io.sockets.emit('message', {
2212				type: 'timerGiveaway',
2213				mod: 'else',
2214				subiect: 'Picking Winner'
2215			});
2216			
2217			if(usersEntered.length > 0){
2218				getWinnerGiveaway();
2219			}else{
2220				io.sockets.emit('message', {
2221					type: 'timerGiveaway',
2222					mod: 'else',
2223					subiect: 'No players entered in giveaway'
2224				});
2225				setTimeout(function() {
2226					startGiveaway();
2227				}, 3000);
2228			}
2229		}
2230		timerGAWAY--;
2231	}, 1000);
2232}
2233function getWinnerGiveaway(){
2234	var array = usersEntered[Math.floor(Math.random() * usersEntered.length)];
2235	var nameWinner = array['name'];
2236	var steamidWinner = array['user'];
2237	var avatarWinner = array['avatar'];
2238	
2239	setTimeout(function() {
2240		logger.trace('The Winner Giveaway is '+nameWinner+' ('+steamidWinner+')');
2241		lastWinnerGiveaway = {steamid: steamidWinner, name: nameWinner, avatar: avatarWinner};
2242		query('UPDATE `users` SET `balance`=`balance` + '+parseInt(amountGiveaway)+' WHERE `steamid` = '+pool.escape(steamidWinner));
2243		
2244		getBalance(steamidWinner, io.sockets.in(steamidWinner));
2245		
2246		io.sockets.emit('message', {
2247			type: 'timerGiveaway',
2248			mod: 'winner',
2249			subiect: {
2250				name: nameWinner,
2251				user: steamidWinner
2252			}
2253		});
2254		query('INSERT INTO `giveaway` SET `winner` = '+pool.escape(steamidWinner)+', `name` = '+pool.escape(nameWinner)+', `hash` = '+pool.escape(getHash("GIVEAWAY", time()+nameWinner))+', `amount` = '+pool.escape(amountGiveaway), function(err3, row3) {
2255			if(err3) {
2256				logger.error('Error in DB');
2257				logger.debug(err);
2258				return;
2259			}
2260		});
2261		setTimeout(function() {
2262			io.sockets.emit('message', {
2263				type: 'removeQGiveaway'
2264			});
2265			startGiveaway();
2266		}, 7000);
2267	}, 3000);
2268}
2269function joinInGiveaway(user, socket) {
2270	if(giveawayState == 1) {
2271		socket.emit('message', {
2272			type: 'error',
2273			enable: true,
2274			error: 'Error: Wait for starting giweaway!'
2275		});
2276		return;
2277	}
2278	if((userJoin[user.steamid] !== undefined) && (userJoin[user.steamid] == 1)) {
2279		socket.emit('message', {
2280			type: 'error',
2281			enable: true,
2282			error: 'Error: You have already joined in giveawey!'
2283		});
2284		return;
2285	}
2286	if(userJoin[user.steamid] === undefined) {
2287		userJoin[user.steamid] = 1;
2288	}
2289	io.sockets.emit('message', {
2290		type: 'joinGiveaway',
2291		player: {
2292			avatar: user.avatar,
2293			steamid: user.steamid,
2294			name: user.name
2295		}
2296	});
2297	usersEntered.push({
2298		avatar: user.avatar,
2299		name: user.name,
2300		user: user.steamid
2301	});
2302	logger.debug('Join In Giveaway confirmed user: '+pool.escape(user.steamid));
2303}
2304/* END GIVEAWAY */
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315/* MINESWEEPER */
2316var usersMines = {};
2317var gamesMines = {};
2318
2319function playMines(m, user, socket){
2320	if((usersMines[user.steamid] !== undefined) && (usersMines[user.steamid] == 1)) {
2321		socket.emit('message', {
2322			type: 'error',
2323			mtype: 'mines',
2324			btype: 'play',
2325			enable: true,
2326			error: 'Error: You\'ve already started a game!'
2327		});
2328		return;
2329	}
2330	
2331	if((m.amount < minbet) || (m.amount > maxbet)) {
2332		socket.emit('message', {
2333			type: 'error',
2334			mtype: 'mines',
2335			btype: 'play',
2336			enable: true,
2337			error: 'Error: Invalid bet amount ['+minbet+'-'+maxbet+']!'
2338		});
2339		return;
2340	}
2341	
2342	if(m.bombs < 1 || m.bombs > 24) {
2343		socket.emit('message', {
2344			type: 'error',
2345			mtype: 'mines',
2346			btype: 'play',
2347			enable: true,
2348			error: 'Error: Invalid bombs amount [1-24]!'
2349		});
2350		logger.warn(user.steamid+' try to cheating to MINESWEEPER BOMBS_AMOUNT_1');
2351		return;
2352	}
2353	
2354	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(m.amount)) {
2355		socket.emit('message', {
2356			type: 'error',
2357			mtype: 'mines',
2358			btype: 'play',
2359			enable: true,
2360			error: 'Error: Invalid bet amount!'
2361		});
2362		logger.warn(user.steamid+' try to cheating to MINESWEEPER BET_AMOUNT');
2363		return;
2364	}
2365	
2366	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(m.bombs)) {
2367		socket.emit('message', {
2368			type: 'error',
2369			mtype: 'mines',
2370			btype: 'play',
2371			enable: true,
2372			error: 'Error: Invalid bombs amount!'
2373		});
2374		logger.warn(user.steamid+' try to cheating to MINESWEEPER BOMBS_AMOUNT_2');
2375		return;
2376	}
2377	
2378	var start_time = new Date();
2379	query('SELECT `balance`, `countDeposits` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err, row) {
2380		if((err) || (!row.length)) {
2381			logger.error('Failed to find DB');
2382			logger.debug(err);
2383			socket.emit('message', {
2384				type: 'error',
2385				mtype: 'mines',
2386				btype: 'play',
2387				enable: true,
2388				error: 'Error: You are not DB!'
2389			});
2390			return;
2391		}
2392		
2393		if(row[0].balance >= m.amount) {
2394			query('UPDATE `users` SET `balance` = `balance` - '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid), function(err2, row2) {
2395				if(err2) {
2396					logger.error('Error in withdraw');
2397					logger.debug(err2);
2398					socket.emit('message', {
2399						type: 'error',
2400						mtype: 'mines',
2401						btype: 'play',
2402						enable: true,
2403						error: 'Error: You dont have enough points!'
2404					});
2405					return;
2406				}
2407				
2408				if(row[0].countDeposits >= 1) query('UPDATE `users` SET `available` = `available` + '+parseInt(m.amount / 10)+', `bets` = `bets` + '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid));
2409				
2410				query('INSERT INTO `minesbets` SET `user` = '+pool.escape(user.steamid)+', `amount` = '+pool.escape(m.amount)+', `amountBombs` = '+pool.escape(m.bombs), function(err3, row3) {
2411					if(err3) {
2412						logger.error('Error in DB');
2413						logger.debug(err);
2414						return;
2415					}
2416					
2417					usersMines[user.steamid] = 1;
2418				
2419					gamesMines[user.steamid] = {
2420						bombs: m.bombs,
2421						amount: m.amount,
2422						amountWin: m.amount,
2423						bombsWin: [],
2424						sums: getArraySums(parseInt((m.amount * m.bombs) / (25 - m.bombs)), (25 - m.bombs)),
2425						bombsLose: getArrayBombs(m.bombs),
2426						cashout: false,
2427						lose: false,
2428						id: row3.insertId
2429					};
2430					
2431					socket.emit('message', {
2432						type: 'newMines',
2433						stake: gamesMines[user.steamid]['amountWin'],
2434						next: gamesMines[user.steamid]['sums'][0],
2435					});
2436					
2437					logger.debug('Mines Bet confirmed #'+row3.insertId+' | Amount: '+m.amount+' | Bombs: '+m.bombs+' | User: '+pool.escape(user.steamid));
2438					
2439					getBalance(user.steamid, socket);
2440				});
2441			});
2442		} else {
2443			socket.emit('message', {
2444				type: 'error',
2445				mtype: 'mines',
2446				btype: 'play',
2447				enable: true,
2448				error: 'Error: You dont have any money!'
2449			});
2450		}
2451	});
2452}
2453
2454function cashoutMines(user, socket){
2455	if(gamesMines[user.steamid]['cashout']){
2456		socket.emit('message', {
2457			type: 'error',
2458			mtype: 'mines',
2459			btype: 'cashout',
2460			enable: true,
2461			error: 'Error: The already cashout!'
2462		});
2463		return;
2464	}
2465	
2466	if(gamesMines[user.steamid]['lose']){
2467		socket.emit('message', {
2468			type: 'error',
2469			mtype: 'mines',
2470			btype: 'cashout',
2471			enable: true,
2472			error: 'Error: The game is already ended!'
2473		});
2474		return;
2475	}
2476	
2477	if(gamesMines[user.steamid]['bombsWin'].length == 0){
2478		socket.emit('message', {
2479			type: 'error',
2480			mtype: 'mines',
2481			btype: 'cashout',
2482			enable: true,
2483			error: 'Error: You need to play one time to withdraw your winnings!'
2484		});
2485		return;
2486	}
2487	
2488	query('UPDATE `users` SET `balance` = `balance` + '+parseInt(gamesMines[user.steamid]['amountWin'])+' WHERE `steamid` = '+pool.escape(user.steamid), function(err, row) {
2489		if(err) {
2490			logger.error('Error in withdraw');
2491			logger.debug(err);
2492			socket.emit('message', {
2493				type: 'error',
2494				mtype: 'mines',
2495				btype: 'cashout',
2496				enable: true,
2497				error: 'Error: You dont have enough points!'
2498			});
2499			return;
2500		}
2501		
2502		socket.emit('message', {
2503			type: 'cashoutMines'
2504		});
2505		
2506		socket.emit('message', {
2507			type: 'getBomb',
2508			mtype: 'lose',
2509			buttons: gamesMines[user.steamid]['bombsLose']
2510		});
2511		
2512		query('UPDATE `minesbets` SET `bombsWin` = '+pool.escape(gamesMines[user.steamid]['bombsWin'].join('/'))+', `bombsLose` ='+pool.escape(gamesMines[user.steamid]['bombsLose'].join('/'))+', `enable` = 1, `win` = '+parseInt(gamesMines[user.steamid]['amountWin'])+', `hash` = '+pool.escape(getHash("MINESWEEPER", gamesMines[user.steamid]['id']))+' WHERE `id` = '+pool.escape(gamesMines[user.steamid]['id']));
2513		
2514		usersMines[user.steamid] = 0;
2515		gamesMines[user.steamid]['cashout'] = true;
2516		gamesMines[user.steamid]['amountWin'] = 0;
2517		
2518		getBalance(user.steamid, socket);
2519	});
2520	
2521	io.sockets.emit('message', {
2522		type: 'refMines'
2523	});
2524}
2525
2526function getBombMines(m, user, socket){
2527	if((usersMines[user.steamid] == undefined) || (usersMines[user.steamid] == 0)) {
2528		socket.emit('message', {
2529			type: 'error',
2530			mtype: 'mines',
2531			btype: 'bombs',
2532			bomb: m.bomb,
2533			enable: true,
2534			error: 'Error: The game is not started!'
2535		});
2536		return;
2537	}
2538	
2539	if(gamesMines[user.steamid]['lose']){
2540		socket.emit('message', {
2541			type: 'error',
2542			mtype: 'mines',
2543			btype: 'bombs',
2544			bomb: m.bomb,
2545			enable: true,
2546			error: 'Error: The game is ended!'
2547		});
2548		return;
2549	}
2550	
2551	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(m.bomb)) {
2552		socket.emit('message', {
2553			type: 'error',
2554			mtype: 'mines',
2555			btype: 'bombs',
2556			bomb: m.bomb,
2557			enable: true,
2558			error: 'Error: Invalid bomb!'
2559		});
2560		logger.warn(user.steamid+' try to cheating to MINESWEEPER PRESBOMB_1');
2561		return;
2562	}
2563	
2564	if(m.bomb < 1 || m.bomb > 25) {
2565		logger.warn(user.steamid+' try to cheating to MINESWEEPER PRESBOMB_2');
2566		return;
2567	}
2568	
2569	for(var x = 0; x <= gamesMines[user.steamid]['bombsWin'].length; x++){
2570		if(gamesMines[user.steamid]['bombsWin'][x] == m.bomb){
2571			socket.emit('message', {
2572				type: 'error',
2573				mtype: 'mines',
2574				btype: 'bombs',
2575				bomb: m.bomb,
2576				enable: true,
2577				error: 'Error: You already pressed this button!'
2578			});
2579			return;
2580		}
2581	}	
2582	
2583	var bombWin = false;
2584	for(var y = 0; y <= gamesMines[user.steamid]['bombsLose'].length; y++){
2585		if(gamesMines[user.steamid]['bombsLose'][y] == m.bomb) bombWin = true;
2586	}
2587	var sumWin = gamesMines[user.steamid]['sums'][gamesMines[user.steamid]['bombsWin'].length];
2588	
2589	if(bombWin){
2590		gamesMines[user.steamid]['lose'] = true;
2591		gamesMines[user.steamid]['amountWin'] = 0;
2592		usersMines[user.steamid] = 0;
2593		socket.emit('message', {
2594			type: 'getBomb',
2595			mtype: 'lose',
2596			buttons: gamesMines[user.steamid]['bombsLose']
2597		});
2598		
2599		var crypto = require('crypto');
2600		var serverSeed = 'MINES'+gamesMines[user.steamid]['id'];
2601		var genGameHash = function(serverSeed) {
2602			return crypto.createHash('sha256').update(serverSeed).digest('hex');
2603		};
2604		var terminatingHash = genGameHash(serverSeed);
2605		
2606		query('UPDATE `minesbets` SET `bombDefuse` = '+m.bomb+', `bombsWin` = '+pool.escape(gamesMines[user.steamid]['bombsWin'].join('/'))+', `bombsLose` ='+pool.escape(gamesMines[user.steamid]['bombsLose'].join('/'))+', `enable` = 1, `hash` = '+pool.escape(terminatingHash)+' WHERE `id` = '+pool.escape(gamesMines[user.steamid]['id']));
2607	
2608		io.sockets.emit('message', {
2609			type: 'refMines'
2610		});
2611	}else{
2612		gamesMines[user.steamid]['bombsWin'].push(m.bomb);
2613		gamesMines[user.steamid]['amountWin'] += sumWin
2614		socket.emit('message', {
2615			type: 'getBomb',
2616			mtype: 'win',
2617			buttons: m.bomb,
2618			stake: gamesMines[user.steamid]['amountWin'],
2619			next: gamesMines[user.steamid]['sums'][gamesMines[user.steamid]['bombsWin'].length],
2620			amount: sumWin,
2621			new: true
2622		});
2623	}
2624}
2625
2626function getArraySums(sum, bombs){
2627	var array = [];
2628	var cSums = 0
2629	while(cSums < bombs){
2630		array.push(sum);
2631		cSums++;
2632	}
2633	
2634	var xSum = parseInt(sum / array.length);
2635
2636	for(var i = 0; i < array.length; i++){
2637		if(i <= parseInt(array.length / 2)){
2638			array[i] -= (xSum * (parseInt(array.length / 2) - i));
2639		}else{
2640			array[i] += (xSum * (i - parseInt(array.length / 2)));
2641		}
2642	}
2643	return array;
2644}
2645
2646function getArrayBombs(bombs){
2647	var totalBombs = bombs
2648	var cBomb = 0;
2649	var array = [];
2650	while(cBomb < totalBombs){
2651		array.push(getNRRR());
2652		cBomb++;
2653	}
2654	function getNRRR(){
2655		var nr = getRandomInt(1, 25);
2656		var i;
2657		for(i = 0;i <= array.length;i++){
2658			if(array[i] == nr) return getNRRR();
2659		}
2660		return nr;
2661	}
2662	return array;
2663}
2664/* END MINESWEEPER */
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677/* ROULETTE */
2678var accept = timerRoulette + 1; //WAIT TIME
2679var wait = 10; //ROLLING TIME
2680var br = 3;
2681var q1 = 2; 
2682var q2 = 14; 
2683var timer = -1; 
2684var users = {}; 
2685var roll = 0; 
2686var currentBets = [];
2687var historyRolls = []; 
2688var historyRolls100 = [];
2689var usersBr = {};
2690var usersAmount = {}; 
2691var currentSums = {
2692	'0-0': 0,
2693	'1-7': 0,
2694	'8-14': 0
2695};
2696var roundedHash = null;
2697var currentRollid = 0;
2698var pause = false;
2699var hash = ''; 
2700var countRLogs = 0;
2701var sh = '';
2702
2703loadHistory();
2704checkTimer();
2705
2706function setBet(m, user, socket) {
2707	var betColor;
2708	
2709	if((usersBr[user.steamid] !== undefined) && (usersBr[user.steamid] == br)) {
2710		socket.emit('message', {
2711			type: 'error',
2712			mtype: 'roulette',
2713			enable: true,
2714			error: 'Error: You\'ve already placed '+usersBr[user.steamid]+'/'+br+' bets this roll!'
2715		});
2716		return;
2717	}
2718	
2719	if((m.amount < minbet) || (m.amount > maxbet)) {
2720		socket.emit('message', {
2721			type: 'error',
2722			mtype: 'roulette',
2723			enable: true,
2724			error: 'Error: Invalid bet amount ['+minbet+'-'+maxbet+']!'
2725		});
2726		return;
2727	}
2728	
2729	if(m.lower == 1 && m.upper == 7) {
2730		betColor = 'red';
2731	}else if(m.lower == 8 && m.upper == 14) {
2732		betColor = 'black'
2733	}else if(m.lower == 0 && m.upper == 0) {
2734		betColor = 'green';
2735	}else {
2736		logger.warn(user.steamid+' try to cheating to ROULETTE COLOR');
2737		return;
2738	}
2739	
2740	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(m.amount)) {
2741		socket.emit('message', {
2742			type: 'error',
2743			mtype: 'roulette',
2744			enable: true,
2745			error: 'Error: Invalid bet amount!'
2746		});
2747		logger.warn(user.steamid+' try to cheating to ROULETTE BET_AMOUNT');
2748		return;
2749	}
2750	
2751	if(pause) {
2752		socket.emit('message', {
2753			type: 'error',
2754			enable: false,
2755			error: 'Error: Betting for this round is closed!'
2756		});
2757		return;
2758	}
2759	
2760	var start_time = new Date();
2761	query('SELECT `balance`, `countDeposits`, `bets` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err, row) {
2762		if((err) || (!row.length)) {
2763			logger.error('Failed to find DB');
2764			logger.debug(err);
2765			socket.emit('message', {
2766				type: 'error',
2767				mtype: 'roulette',
2768				enable: true,
2769				error: 'Error: You are not DB!'
2770			});
2771			return;
2772		}
2773		
2774		var n = parseFloat(row[0].bets % Math.pow(10, 3));
2775		var xx = ((parseInt((row[0].bets - n)/xpPerLevel))*xpPerLevel);
2776		var levelA = xx/xpPerLevel;
2777		
2778		if(row[0].balance >= m.amount) {
2779			query('UPDATE `users` SET `balance` = `balance` - '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid), function(err2, row2) {
2780				if(err2) {
2781					logger.error('Error in withdraw');
2782					logger.debug(err2);
2783					socket.emit('message', {
2784						type: 'error',
2785						mtype: 'roulette',
2786						enable: true,
2787						error: 'Error: You dont have enough points!'
2788					});
2789					return;
2790				}
2791				
2792				if(row[0].countDeposits >= 1) query('UPDATE `users` SET `available` = `available` + '+parseInt(m.amount / 10)+', `bets` = `bets` + '+parseInt(m.amount)+' WHERE `steamid` = '+pool.escape(user.steamid));
2793				
2794				query('INSERT INTO `bets` SET `user` = '+pool.escape(user.steamid)+', `amount` = '+pool.escape(m.amount)+', `lower` = '+pool.escape(m.lower)+', `upper` = '+pool.escape(m.upper), function(err3, row3) {
2795					if(err3) {
2796						logger.error('Error in DB');
2797						logger.debug(err3);
2798						return;
2799					}
2800					var end = new Date();
2801					if(usersBr[user.steamid] === undefined) {
2802						usersBr[user.steamid] = 1;
2803					} else {
2804						usersBr[user.steamid]++;
2805					}
2806					if(usersAmount[user.steamid] === undefined) {
2807						usersAmount[user.steamid] = {
2808							'0-0': 0,
2809							'1-7': 0,
2810							'8-14': 0
2811						};
2812					}
2813					usersAmount[user.steamid][m.lower+'-'+m.upper] += parseInt(m.amount);
2814					currentSums[m.lower+'-'+m.upper] += m.amount;
2815					socket.emit('message', {
2816						type: 'betconfirm',
2817						bet: {
2818							betid: row3.insertId,
2819							lower: m.lower,
2820							upper: m.upper,
2821							amount: usersAmount[user.steamid][m.lower+'-'+m.upper]
2822						},
2823						mybr: usersBr[user.steamid],
2824						br: br,
2825						exec: (end.getTime()-start_time.getTime()).toFixed(3)
2826					});
2827					users[user.steamid].balance = row[0].balance-m.amount;
2828					io.sockets.emit('message', {
2829						type: 'bet',
2830						bet: {
2831							level: levelA,
2832							amount: m.amount,
2833							betid: row3.insertId,
2834							icon: user.avatar,
2835							lower: m.lower,
2836							name: user.name,
2837							upper: m.upper,
2838							user: user.steamid,
2839							won: null
2840						},
2841						sums: {
2842							0: currentSums['0-0'],
2843							1: currentSums['1-7'],
2844							2: currentSums['8-14']
2845						}
2846					});
2847					currentBets.push({
2848						amount: m.amount,
2849						betid: row3.insertId,
2850						icon: user.avatar,
2851						lower: m.lower,
2852						upper: m.upper,
2853						name: user.name,
2854						user: user.steamid,
2855						level: levelA
2856					});
2857					
2858					logger.debug('Bet #'+row3.insertId+' with amount: '+m.amount);
2859					
2860					getBalance(user.steamid, socket);
2861				});
2862			});
2863		} else {
2864			socket.emit('message', {
2865				type: 'error',
2866				mtype: 'roulette',
2867				enable: true,
2868				error: 'Error: You dont have any money!'
2869			});
2870		}
2871	});
2872}
2873function checkTimer() {
2874	if((timer == -1) && (!pause)) {
2875		logger.trace('Starting roulette');
2876		timer = accept+wait;
2877		
2878		sh = sha256('CSGOWitch69' + time() + '-' + Math.floor(Math.random() * (690 - 1 + 1)) + 1);
2879		roundedHash = sh;
2880		
2881		timerID = setInterval(function() {
2882			if((timer-wait)%5 == 0 && timer-wait >= 0) {
2883				logger.trace('Timer roulette: '+(timer-wait)+'!');
2884			}
2885			
2886			if(timer-wait >= 0){
2887				io.sockets.emit('message', {
2888					type: 'timeRoulette',
2889					time: timer-wait
2890				});
2891			}
2892			
2893			if (timer == wait) {
2894				pause = true;
2895				logger.trace('Rolling roulette!');
2896				
2897				io.sockets.emit('message', {
2898					type: 'preroll',
2899					sums: {
2900						0: currentSums['0-0'],
2901						1: currentSums['1-7'],
2902						2: currentSums['8-14'],
2903					}
2904				});
2905			}
2906			
2907			if (timer == wait-2) {
2908				toWin();
2909			}
2910
2911			if(timer == 0) {
2912				logger.trace('New round to roullete!');
2913				
2914				sh = sha256('CSGOWitch69' + time() + '-' + Math.floor(Math.random() * (690 - 1 + 1)) + 1);
2915				roundedHash = sh;
2916				
2917				io.sockets.emit('message', {
2918					type: 'roundedHash',
2919					roundedHash: roundedHash
2920				});
2921				
2922				historyRolls.push({id: currentRollid, roll: roll});
2923				if(historyRolls.length > 10) historyRolls.slice(1);
2924				
2925				historyRolls100.push(roll);
2926				if(historyRolls100.length > 100) historyRolls100.shift();
2927				
2928				io.sockets.emit('message', {
2929					type: '100rolls',
2930					rolls: historyRolls100
2931				});
2932				
2933				timer = accept+wait;
2934				currentBets = [];
2935				usersBr = {};
2936				usersAmount = {};
2937				currentSums = {
2938					'0-0': 0,
2939					'1-7': 0,
2940					'8-14': 0
2941				};
2942				pause = false;
2943			}
2944			timer--;
2945		}, 1000);
2946	}
2947}
2948
2949function toWin() {
2950    var lottery = time();
2951    var secret = makeCode();
2952	
2953	roll = getRoll(sh, secret, lottery);
2954
2955	logger.trace('[Roulette] --> Round hash: ' + sh + ', Lottery: ' + lottery + ', Secret: ' + secret + ', Rolling: ' + roll);
2956	
2957	io.sockets.emit('message', {
2958		type: 'roundedSecret',
2959		roundedSecret: secret
2960	});
2961	
2962	query('INSERT INTO `rolls` SET `roll` = '+pool.escape(roll)+', `hash` = '+pool.escape(sh)+', `secret` = '+pool.escape(secret)+', `lottery` = '+pool.escape(lottery), function(err, row){
2963		currentRollid = row.insertId;
2964		
2965		var r = '';
2966		var s = 0;
2967		var wins = {
2968			'0-0': 0,
2969			'1-7': 0,
2970			'8-14': 0
2971		};
2972		if(roll == 0) {
2973			r = '0-0'; 
2974			s = q2; 
2975			wins['0-0'] = currentSums['0-0']*s; 
2976		}
2977		if((roll > 0) && (roll < 8)) { 
2978			r = '1-7'; 
2979			s = q1;
2980			wins['1-7'] = currentSums['1-7']*s; 
2981		}
2982		if((roll > 7) && (roll < 15)) { 
2983			r = '8-14'; 
2984			s = q1;
2985			wins['8-14'] = currentSums['8-14']*s; 
2986		}
2987		
2988		for(key in users) {
2989			if(usersAmount[key] === undefined) {
2990				var balance = null;
2991				var won = 0;
2992			} else {
2993				var balance = parseInt(users[key].balance)+usersAmount[key][r]*s;
2994				var won = usersAmount[key][r]*s;
2995			}
2996			if (io.sockets.connected[users[key].socket]) {
2997				io.sockets.connected[users[key].socket].emit('message', {
2998					balance: balance,
2999					nets: [{
3000							lower: 0,
3001							samount: currentSums['0-0'],
3002							swon: wins['0-0'],
3003							upper: 0
3004						}, {
3005							lower: 1,
3006							samount: currentSums['1-7'],
3007							swon: wins['1-7'],
3008							upper: 7
3009						}, {
3010							lower: 8,
3011							samount: currentSums['8-14'],
3012							swon: wins['8-14'],
3013							upper: 14
3014						}
3015					],
3016					roll: roll,
3017					rollid: currentRollid,
3018					type: "roll",
3019					wait: wait-2,
3020					won: won
3021				});
3022			}
3023		}
3024		if(currentBets.length > 0){
3025			currentBets.forEach(function(itm) {
3026				if((roll >= itm.lower) && (roll <= itm.upper)) {
3027					logger.debug('Bet id #'+itm.betid+' amount '+itm.amount+' win '+(itm.amount*s)+'(x'+s+');');
3028					query('UPDATE `users` SET `balance` = `balance` + '+itm.amount*s+' WHERE `steamid` = '+pool.escape(itm.user));
3029					users[itm.user].balance += itm.amount*s;
3030				}
3031			});
3032		}
3033	});
3034}
3035
3036function loadHistory() {
3037	query('SELECT * FROM `rolls` ORDER BY `id` DESC LIMIT 10', function(err, row) {
3038		if(err) {
3039			logger.error('Cant load betting history - 10 bets');
3040			logger.debug(err);
3041		}
3042		logger.trace('Sucesfully updated history');
3043		for(var i = row.length - 1; i >= 0; i--){
3044			historyRolls.push(row[i]);
3045		}
3046	});
3047	query('SELECT * FROM `rolls` ORDER BY `id` DESC LIMIT 100', function(err, row) {
3048		if(err) {
3049			logger.error('Cant load betting history - 100 bets');
3050			logger.debug(err);
3051		}
3052		for(var i = row.length - 1; i >= 0; i--){
3053			historyRolls100.push(row[i].roll);
3054		}
3055	});
3056}
3057/* END ROULETTE */
3058
3059
3060
3061
3062
3063
3064
3065
3066
3067/* COINFLIP */
3068function createCFGame(m, user, socket) {
3069	var selectedCoin = m.selectedCoin;
3070	var betAmount = parseInt(m.amount);
3071	
3072	if((betAmount < minbet) || (betAmount > maxbet)) {
3073		socket.emit('message', {
3074			type: 'error',
3075			mtype: 'roulette',
3076			enable: true,
3077			error: 'Error: Invalid bet amount ['+minbet+'-'+maxbet+']!'
3078		});
3079		return;
3080	}
3081	
3082	if(/(a|b|c|d|e|f|g|h|j|i|k|l|m|n|o|p|q|r|s|t|v|u|w|x|y|z)/.exec(betAmount)) {
3083		socket.emit('message', {
3084			type: 'error',
3085			mtype: 'roulette',
3086			enable: true,
3087			error: 'Error: Invalid bet amount!'
3088		});
3089		logger.warn(user.steamid+' try to cheating to COINFLIP BET_AMOUNT');
3090		return;
3091	}
3092	
3093	if(selectedCoin != 't' && selectedCoin != 'ct'){
3094		socket.emit('message', {
3095			type: 'error',
3096			mtype: 'coinflip',
3097			btype: 'create',
3098			enable: true,
3099			error: 'Error: Invalid coin!'
3100		});
3101		logger.warn(user.steamid+' try to cheating to COINFLIP COIN_TIPE');
3102		return;
3103	}
3104	
3105	query('SELECT COUNT(*) AS `total` FROM `coinflip` WHERE `p1_steamid`='+pool.escape(user.steamid)+' AND `result` = 0', function(err, row) {
3106		if(err) {
3107			logger.error('ERROR');
3108			logger.error(err);
3109		}
3110		query('SELECT `balance`, `countDeposits` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(e, rr) {
3111			if(e) return;
3112			if(betAmount > rr[0].balance) {
3113				socket.emit('message', {
3114					type: 'error',
3115					mtype: 'coinflip',
3116					btype: 'create',
3117					enable: true,
3118					error: 'Error: You do not have enough coins to create the game!'
3119				});
3120				return;
3121			} else {
3122				if(row[0].total >= maxCoinflips) {
3123					socket.emit('message', {
3124						type: 'error',
3125						mtype: 'coinflip',
3126						btype: 'create',
3127						enable: true,
3128						error: 'Error: You can create just '+maxCoinflips+' game!'
3129					});
3130				} else {
3131					query('UPDATE `users` SET `balance` = `balance` - '+parseInt(betAmount)+' WHERE `steamid` = '+pool.escape(user.steamid), function(errr){
3132						if(errr) return;
3133						
3134						if(rr[0].countDeposits >= 1) query('UPDATE `users` SET `available` = `available` + '+parseInt(betAmount / 10)+', `bets` = `bets` + '+parseInt(betAmount)+' WHERE `steamid` = '+pool.escape(user.steamid));
3135
3136						var castigator = Math.floor(Math.random() * (2 - 1 + 1)) + 1;
3137						if(castigator == '1') {
3138							WinnerC = 'ct';
3139						}else if(castigator == '2') {
3140							WinnerC = 't';
3141						}
3142						
3143						query('INSERT INTO `coinflip` SET `p1_steamid` = '+pool.escape(user.steamid)+', `p1_name` = '+pool.escape(user.name)+', `p1_pick` = '+pool.escape(selectedCoin)+', `amount` = '+parseInt(betAmount)+', `won_pick` = '+pool.escape(WinnerC)+', `hash` = '+pool.escape(getHash("COINFLIP", getRandomInt(1,2)+WinnerC+time()))+', `time` = '+pool.escape(time()));
3144						
3145						io.sockets.emit('message', {
3146							type: 'refCoinflip'
3147						});
3148						
3149						getBalance(user.steamid, socket);
3150					});
3151				}
3152			}
3153		});
3154	});
3155}
3156
3157
3158function watchCFGame(m, user, socket) {
3159	var NumberID = m.gamenr;
3160	
3161	if(NumberID < 0) {
3162		socket.emit('message', {
3163			type: 'error',
3164			error: 'Error: Invalid id game!'
3165		});
3166		logger.warn(user.steamid+' try to cheating to COINFLIP ID_GAME_WATCH');
3167		return;
3168	}
3169	
3170	query('SELECT `p1_pick`, `p2_pick`, `p1_name`, `p2_name`, `p1_steamid`, `p2_steamid`, `won_pick`, `result` FROM `coinflip` WHERE `id` = '+pool.escape(NumberID), function(err, row) {
3171		if(err) {
3172			socket.emit('message', {
3173				type: 'error',
3174				error: 'Error: Invalid id game!'
3175			});
3176			logger.warn(user.steamid+' try to cheating to COINFLIP ID_GAME_WATCH');
3177			return;
3178		}
3179		
3180		var Result = row[0].result;
3181		
3182		query('SELECT `avatar` FROM `users` WHERE `steamid` = '+pool.escape(row[0].p1_steamid), function(err2, row2){
3183			if(err2) return;
3184			var AvatarP1 = row2[0].avatar;
3185			if(Result == 0){
3186				var PickP1 = row[0].p1_pick;
3187				var NameP1 = row[0].p1_name;
3188				var SteamP1 = row[0].p1_steamid;
3189				var Won_pick = row[0].won_pick;
3190				socket.emit('message', {
3191					type: 'watchcfgame',
3192					GameID: NumberID,
3193					pickp1: PickP1,
3194					namep1: NameP1,
3195					steamp1: SteamP1,
3196					avatarp1: AvatarP1,
3197					wonpick: Won_pick
3198				});
3199			}else if(Result == 1){
3200				query('SELECT `avatar` FROM `users` WHERE `steamid` = '+pool.escape(row[0].p2_steamid), function(err3, row3){
3201					if(err3) return;
3202				
3203					socket.emit('message', {
3204						type: 'finishCoinflip',
3205						flip: row[0].won_pick,
3206						numeplayer1: row[0].p1_name,
3207						steamidplayer1: row[0].p1_steamid,
3208						choiceplayer1: row[0].p1_pick,
3209						avatarplayer1: AvatarP1,
3210						numeplayer2: row[0].p2_name,
3211						steamidplayer2: row[0].p2_steamid,
3212						choiceplayer2: row[0].p2_pick,
3213						avatarplayer2: row3[0].avatar
3214					});
3215				});
3216			}
3217		});
3218	});
3219}
3220
3221
3222function joinCFGame(m, user, socket) {
3223	var NumberGame = m.gamenr;
3224	
3225	if(NumberGame < 0) {
3226		socket.emit('message', {
3227			type: 'error',
3228			error: 'Error: Invalid id game!'
3229		});
3230		logger.warn(user.steamid+' try to cheating to COINFLIP ID_GAME_CREATE');
3231		return;
3232	}
3233	
3234	query('SELECT `result`,`id`,`p1_pick`,`amount`, `p1_steamid`, `p1_name` FROM `coinflip` WHERE `id` = '+pool.escape(NumberGame), function(err, row) {
3235		if(err || !row[0]) {
3236			socket.emit('message', {
3237				type: 'error',
3238				error: 'Error: Invalid id game!'
3239			});
3240			logger.warn(user.steamid+' try to cheating to COINFLIP ID_GAME_CREATE');
3241			return;
3242		}
3243		
3244		if(row[0].p1_pick == 'ct'){
3245			var pickedP2Coin = 't';
3246		} else if(row[0].p1_pick == 't'){
3247			var pickedP2Coin = 'ct';
3248		}
3249		
3250		if(row[0].result != 0) {
3251			socket.emit('message', {
3252				type: 'error',
3253				error: 'Error: This game are already flipping!'
3254			});
3255			return;
3256		}
3257		
3258		if(user.steamid == row[0].p1_steamid) {
3259			socket.emit('message', {
3260				type: 'error',
3261				error: 'Error: You cannot join your game!'
3262			});
3263			return;
3264		}
3265		
3266		query('SELECT `balance`, `totalDeposits` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(e, rr) {
3267			if(e) return;
3268			if(rr[0].balance < row[0].amount) {
3269				socket.emit('message', {
3270					type: 'error',
3271					error: 'Error: You do not have enough coins to join the game!'
3272				});
3273				return;
3274			}else if(row[0].amount <= rr[0].balance) {
3275				query('UPDATE `users` SET `balance` = `balance` - '+parseInt(row[0].amount)+' WHERE `steamid` = '+pool.escape(user.steamid), function(errr){
3276					if(err) return;
3277					
3278					if(rr[0].countDeposits >= 1) query('UPDATE `users` SET `available` = `available` + '+parseInt(betAmount / 10)+', `bets` = `bets` + '+parseInt(betAmount)+' WHERE `steamid` = '+pool.escape(user.steamid));
3279		
3280					query('UPDATE `coinflip` SET `result` = 1 WHERE `id` = '+row[0].id);
3281					query('UPDATE `coinflip` SET `p2_steamid` = '+pool.escape(user.steamid)+', `p2_name` = '+pool.escape(user.name)+', `p2_pick` = '+pool.escape(pickedP2Coin)+' WHERE `id`='+row[0].id);
3282					
3283					query('SELECT `won_pick`, `id` FROM `coinflip` WHERE `id` = '+pool.escape(row[0].id), function(err2, row2) {
3284						if(err2) return;
3285						
3286						io.sockets.emit('message', {
3287							type: 'refCoinflip'
3288						});
3289						
3290						getBalance(user.steamid, socket);
3291						
3292						setTimeout(function() {
3293							if(row2[0].won_pick == row[0].p1_pick) {
3294								query('UPDATE `users` SET `balance` = `balance` + '+parseInt(1.95*row[0].amount)+' WHERE `steamid` = '+pool.escape(row[0].p1_steamid));
3295								setTimeout(function() {
3296									io.sockets.in(row[0].p1_steamid).emit('message', {
3297										type: 'alert',
3298										alert: 'You won the coinflip game #'+row[0].id+' | Coins won: '+parseInt(1.95*row[0].amount)+'!'
3299									});
3300									io.sockets.in(user.steamid).emit('message', {
3301										type: 'error',
3302										error: 'You lost the coinflip game #'+row[0].id+' | Coins lost: '+parseInt(row[0].amount)+'!'
3303									});
3304									
3305									getBalance(row[0].p1_steamid, socket);
3306									
3307									io.sockets.emit('message', {
3308										type: 'refCoinflip'
3309									});
3310									query('UPDATE `coinflip` SET `result` = 2 WHERE `id`='+row[0].id);
3311								}, 4000);
3312							}else if(row2[0].won_pick != row[0].p1_pick) {
3313								query('UPDATE `users` SET `balance` = `balance` + '+parseInt(1.95*row[0].amount)+' WHERE `steamid` = '+pool.escape(user.steamid));
3314								setTimeout(function() {
3315									io.sockets.in(row[0].p1_steamid).emit('message', {
3316										type: 'error',
3317										error: 'You lost the coinflip game #'+row[0].id+' | Coins lost: '+parseInt(row[0].amount)+'!'
3318									});
3319									io.sockets.in(user.steamid).emit('message', {
3320										type: 'alert',
3321										alert: 'You won the coinflip game #'+row[0].id+' | Coins won: '+parseInt(1.95*row[0].amount)+'!'
3322									});
3323									
3324									getBalance(user.steamid, socket);
3325									
3326									io.sockets.emit('message', {
3327										type: 'refCoinflip'
3328									});
3329									query('UPDATE `coinflip` SET `result`=2 WHERE `id`='+row[0].id);
3330								}, 4000);
3331							}
3332							query('SELECT `avatar` FROM `users` WHERE `steamid` = '+pool.escape(row[0].p1_steamid), function(err3, row3) {
3333								if(err3) return;
3334								query('SELECT `avatar` FROM `users` WHERE `steamid` = '+pool.escape(user.steamid), function(err4, row4) {
3335									io.sockets.in(row[0].p1_steamid).emit('message', {
3336										type: 'finishCoinflip',
3337										flip: row2[0].won_pick,
3338										numeplayer1: row[0].p1_name,
3339										steamidplayer1: row[0].p1_steamid,
3340										choiceplayer1: row[0].p1_pick,
3341										avatarplayer1: row3[0].avatar,
3342										numeplayer2: user.name,
3343										steamidplayer2: user.steamid,
3344										choiceplayer2: pickedP2Coin,
3345										avatarplayer2: row4[0].avatar
3346									});
3347									io.sockets.in(user.steamid).emit('message', {
3348										type: 'finishCoinflip',
3349										flip: row2[0].won_pick,
3350										numeplayer1: row[0].p1_name,
3351										steamidplayer1: row[0].p1_steamid,
3352										choiceplayer1: row[0].p1_pick,
3353										avatarplayer1: row3[0].avatar,
3354										numeplayer2: user.name,
3355										steamidplayer2: user.steamid,
3356										choiceplayer2: pickedP2Coin,
3357										avatarplayer2: row4[0].avatar
3358									});
3359									//SEND WATCH TO PLAYER
3360									io.sockets.emit('message', {
3361										type: 'watchcfgameShow',
3362										GameID: row2[0].id,
3363										flip: row2[0].won_pick,
3364										numeplayer2: user.name,
3365										steamidplayer2: user.steamid,
3366										choiceplayer2: pickedP2Coin,
3367										avatarplayer2: row4[0].avatar
3368									});
3369								});
3370							});
3371						}, 1500);
3372					});
3373				});
3374			}
3375		});
3376	});
3377}
3378/* END COINFLIP */
3379
3380
3381
3382
3383
3384/* ElSE */
3385var tagsToReplace = {
3386    '&': '&amp;',
3387    '<': '&lt;',
3388    '>': '&gt;'
3389};
3390
3391function replaceTag(tag) {
3392    return tagsToReplace[tag] || tag;
3393}
3394
3395function safe_tags_replace(str) {
3396    return str.replace(/[&<>]/g, replaceTag);
3397}
3398Object.size = function(obj) {
3399	var size = 0,
3400		key;
3401	for (key in obj) {
3402		if (obj.hasOwnProperty(key)) size++;
3403	}
3404	return size;
3405};
3406function getRandomInt(min, max) {
3407	return Math.floor(Math.random() * (max - min + 1)) + min;
3408}
3409function getRandomArbitary(min, max) {
3410	return Math.random() * (max - min) + min;
3411}
3412function query(sql, callback) {
3413	if (typeof callback === 'undefined') {
3414		callback = function() {};
3415	}
3416	pool.getConnection(function(err, connection) {
3417		if(err) return callback(err);
3418		//logger.info('DB Connection ID: '+connection.threadId);
3419		connection.query(sql, function(err, rows) {
3420			if(err) return callback(err);
3421			connection.release();
3422			return callback(null, rows);
3423		});
3424	});
3425}
3426
3427function getHash(a,b){
3428	var crypto = require('crypto');
3429	var serverSeed = a+b;
3430	var genGameHash = function(serverSeed) {
3431		return crypto.createHash('sha256').update(serverSeed).digest('hex');
3432	};
3433	return terminatingHash = genGameHash(serverSeed);
3434}
3435
3436/**/
3437function getRoll(hash, secret, lottery){
3438  var rolled = sha256(hash+'-'+secret+'-'+lottery);
3439  rolled = hexdec(rolled.substr(0, 8)) % 15;
3440  return rolled;
3441}
3442
3443function makeCode() {
3444    var text = "";
3445    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
3446
3447    for(var i=0; i < 12; i++)
3448        text += possible.charAt(Math.floor(Math.random() * possible.length));
3449
3450    return text;
3451}
3452
3453function hexdec(hexString) {
3454  hexString = (hexString + '').replace(/[^a-f0-9]/gi, '')
3455  return parseInt(hexString, 16)
3456}
3457/**/
3458
3459function time() {
3460	return parseInt(new Date().getTime()/1000);
3461}