Slot game in javascript

But what about getting the player to click on the game page in the first place? How do you advertise the game effectively on a casino home page? This can be done by utilising javascript as a coding language. Graphic web designers can creating an eye popping graphical animation that also doubles as a hyperlink to the game itself. This graphical advertisement is usually colorful and fits in with the visual theme of the game.

Javascript casino games

In order to best understand how javascript is used it is useful to analyse an example of a casino game. In this article we will be looking at slot machines.

A traditional slot machine contains multiple columns of numbers or images. The columns spin and displace the images or numbers along with it. Wins are determined depending on how many are matching when the spin has ended.

Javascript can be employed to create a fun, aesthetically pleasing and enticing slot machine game. A designer could pick a theme and base the game around this. For our example we will choose space as the core theme and visual motif.

Background

First the casino game designer will need to decide on the background image. They could choose space. This image does not have to remain static. With javascript coding the background could be an animation of an epic space battle that changes depending on if the player wins or loses.

Next they will have to design the slots themselves. Each slot element could be an animated image. For instance the slots could be gifs of aliens, planets or astronauts. Interactive codes could be written into the slot images using javascript. If a player wins a or loses the image animation could display a different graphic. For instance if the player wins the alien could smile or if they lose a planet could explode.

The most important reason for using javascript as a programme for developing an online casino game is the fact it has so many interactive applications. It is crucial that the game player can interact with the onscreen site. The scripting language allows the player to click a button to spin the machine.

Underneath or above the interactive game display a graphical column containing the player’s progress information can be displayed. This can include a countdown timer, player score, winnings total and rank scoreboard. Javascript code is utilised not only for the figures within these columns to change via animation. They also control the inner working that calculate the figures themselves.

But what about getting the player to click on the game page in the first place? How do you advertise the game effectively on a casino home page?

Animations

This can be done by utilising javascript as a coding language. Graphic web designers can creating an eye popping graphical animation that also doubles as a hyperlink to the game itself. This graphical advertisement is usually colorful and fits in with the visual theme of the game.

When the prospective casino game player clicks on this advertisement image the javascript code will send them to the game page. Often in order to create an effective advertisement the programmer should not just have experience in javascript. They should also be qualified in graphic design. This too goes for designing the visual theme and aesthetic of the game itself. If a programmer feels they do not have the design skills for this it is advisable to hire a third party to outsource the artwork.

Design matters

In order to effectively understand the vast applications javascript has in the development of casino games it is useful to analyse an example. In this article we will be looking at online poker games.

The most important thing to note about this form of casino game is the fact that it is live and requires multiple players. For the game to work the javascript code needs to be able to connect the individual players together. Each player will only be able to see their own card hands. All other card hands need to be kept secret from the other players. If this can not be done properly then the game is not only ineffective but potentially fraudulent.

Thankfully, javascript is the ideal language to be utilised for the task. It is quick, easy to use and has a vast amount of application potential. In terms of graphical information code the first thing to note is that an online poker game will typically have a card table in the centre of the screen. The individual player will have their score, cards and avatar in the middle foreground of the table.

Javascript can allow their score to automatically update and have their avatar be an animated gif. In terms of interactive elements the script allows players the options of whether to fold, call or raise their chips. Poker is a complex game so for it to work a complex game code needs to be embedded into the javascript file. The chips the player has are not just animated elements. They must also be correct representations of their winnings. When they place their graphical chip elements onto the table a separate algorithm must be working behind the scenes which keeps up how much total money has been lost or won by the player.

Javascript is the ideal language to implement this. It is used only practically every web browser, wherever there are interactive elements. Game designer can use it to invent creative, innovative work for casino sites. When designing a poker game in particular, javascript has many other potential for interactive elements. If the player wants to message their rivals then a chat box can be placed on the corner of the game screen. They can also have a settings bar where players can preset game decisions such as when to auto-fold or sit out the next hand.

In order to design an online casino poker game the designer will need extensive experience in programming. While it is true that you don’t need expertise in software design to get to grips with javascript it is important to recognise how complex this form of casino game is. You will need coding that will be able to not only accurately calculate game score, winnings and bets. The coding will also need to display this information via the animation graphics and vice versa. Javascript is an essential language for developing an online casino game. All programmers use it when creating interactive web pages, as this example shows.

Javascript slot machine

Code for your new or existing gambling site

While talking about casinos and gambling, the first thought that comes into our mind is about a slot machine. After the advancement in technological, it is easy to start or integrate slot games online.

AIS technolabs has technical experts that help in building these modern-day slot machines for online gambling. Our team of coders has keen knowledge about coding and programming required for the business of casinos and gambling.

In-house experts and professional coders at AIS technolabs have mastery of developing java slot machine source code and are known to handle complex coding solutions in almost all coding languages. We serve you the best possible solution as per your requirements.

Attain the wonderful benefits by

Our javascript slot machine code for

Your online gambling site and app

At AIS technolabs, we offer a fully customizable javascript slot machine code as per the demand of our clients. Our esteemed developers provide various instructions needed for gaming system in different programming languages such as C, C++ as well as java. Moreover, we help our clients to build their javascript slot machine and that too at very affordable rates.

We are one of the leading javascript slot machine code providers that offer quality products and excellent game varieties for the gaming industry. Our skilled and professional developers are very innovative and creative those who have a complete understanding of online gaming and casino software. Furthermore, the client can hire and choose the best slot machine code developer from us for their gambling sites that develop custom slot machine codes according to their requirements. Our developed code will help our clients with all the essential information for playing safely and full of fun.

Below the several advantages of our javascript slot machine code

Slot machine the fruits - HTML5 casino game

Slot machine – the fruits is a HTML5 casino game. Enjoy this coloured slot machine with classic fruit symbols!

This game has been developed in HTML5/js and third-party library createjs – http://createjs.Com/ (not construct2 or other framework).

The ZIP package contains the game with 1500×640 resolution that scales to fit the current screen device.
The game is fully compatible with all most common mobile devices.
WARNING:
sounds are enabled for mobile but we can’t grant full audio compatibility on all mobile devices due to some well-know issue between some mobile-browser and HTML5.
So if you want to avoid sound loading, please read the documentation
sounds can’t be enabled for windows phone as this kind of device have unsolvable issues with and tag.

This game is fully compatible with CTL arcade

A wordpress plugin that allows you to create a real arcade on your website.

Easy to install

With CTL arcade you can:

Monetize with your games adding ads banners

Promote your website with social share buttons

Improve our games with leaderboard, and rating feature

=== even if we do our best to minimise any inconvenience, we can’t ensure the full compatibility of all our games on every device and every operating system update.
Thank you for the understanding. ===

YOU MIGHT ALSO BE INTERESTED IN:

Javascript slot machine

Code for your new or existing gambling site

Attain the wonderful benefits by

Our javascript slot machine code for

Your online gambling site and app

Below the several advantages of our javascript slot machine code

Slot game in javascript

Github is home to over 40 million developers working together to host and review code, manage projects, and build software together.

Clone with HTTPS
Use git or checkout with SVN using the web URL.

Downloading

Want to be notified of new releases in serdar-aglamis-wcar/javascript-slot-game ?

Launching github desktop

If nothing happens, download github desktop and try again.

Launching github desktop

If nothing happens, download github desktop and try again.

Launching xcode

If nothing happens, download xcode and try again.

Launching visual studio

Latest commit

Files

Controllers

Public

Test

Views

.Gitignore

README.Md

App.Js

Package.Json

New casino sites to play real money

This is an example slot game written in javascript. This is a fullstack javascript application (hackathon starter) short info about technology stack

Client side - ES6 with browserify and babelify, sass (node-sass)

Server side - nodejs with express, pug for view render

Tests - mocha and supertest

After this command check http://localhost:8080/ from your browser.

Only backend outcome api tests are written. You can running it with:

Javascript slot game

I'm trying to make a slot game using javascript. I need some help here because i'm stuck. I used an array to store the images. I calculate an random number so it takes an image from the array an place it into the src in the HTML file. Then it looks if the images are the same and calculate the ouput in €. If the user clicks on the spin button it had to do the functions.

The eventlistener does't do anything when i click it? Does anybody know why they don't listen to the clicks?

How have you verified that the event listeners are not getting called? Setting breakpoints on the appropriate lines of code?

Have you verified that your element references are correct in the first place? (hint: they're not.)

And why aren't you using jquery to make this all much much simpler?

You answered only the last of my 4 questions.

Set a breakpoint in the code and inspect your variables. Which one is wrong?

If you haven't you should have a quick look over the javascript links (wiki forum at coderanch)
right now you should be interested in the "debugging" section.

For example if you are allowed to use google chrome/chromium as your browser you should be looking at:
chrome devtools overview - google chrome: debugging javascript
and
debugging javascript - google chrome: debugging with breakpoints
so that you can follow bear's advice:

Bear bibeault wrote: set a breakpoint in the code [, step through your code] and inspect your variables. Which one is wrong?[for example, is any variable null or undefined when you don't expect it to be - is there an error message in the javascript console that may indicate that something has gone wrong?]

State of the art

Developing an HTML mobile slot machine game from scratch

By mihhail lapushkin

For the past 9 months at ignite we’ve been developing an HTML slot machine game for ios devices. Seems like no big deal, but the thing is that our customer did not want to make yet another game with crappy graphics and simple animations. Instead, our goal was to provide retina quality graphics with stylish, performant animations and beautiful sound tracks. Speaking of sound quality, our composer was the same guy that produced music for angry birds. Pretty cool, huh? ��

So, without further ado I present to you:

[ casino island deluxe the mobile sequel of casino island ]

In this blog post I am going to go through the core technical decisions that we had to make, challenges that we had to deal with and solutions that we have worked out to make this game kick some serious ass.

Development setup

To start off, I’ll cover the way we’ve organized our development process. The goal was simple – we needed something, which would allow us to constantly check our stuff out on real devices. Syncing seemed like the best way to go, so we’ve setup a sync system (winscp on windows, rsync on unix) between our local workspace and the development environment. Once you hit save, changes are synced to the server and you can immediately check them out in the mobile browser. Each developer has his own development URL and the committed code deploys to the stable version URL. Easy!

Game structure

DOM vs canvas

We’ve decided to go with DOM, not canvas. In my very first blog post I’ve explained some key differences between those approaches. Being already more experienced by now, I can say that the core benefits of DOM are:

Easy to use and prototype CSS animations

Declarative structure through HTML

Testability

Has a tendency to gain speed with time

Can support more animations without performance issues

Is consistent across browsers

Provides more options to play with masks and filters

At the time when we started working on our game CSS animations outperformed canvas by quite a lot, so that’s why we went with DOM. However, if you’re thinking about the future then canvas might be the way to go. Consistency across browsers is a major bonus especially for big companies, since it means lower maintenance costs and greater portability – pretty much the same arguments that led flash to become so popular in the browser world. Of course, canvas heavily lacks in tooling support, but it’s something we have to live with right now.

Layout

Our positioning system mostly resembles the already mentioned flash. Every element in our game has an absolute position and is moved to its place using pixel offsets on top and left. Parents place their children, children place their children and so on.

The cool thing that we have discovered is that retina screens don’t require any additional handling at all. If the images are double in size, they will just look better on retina screen without the need to change any stylesheets, whose measurements are designed for regular screens i.E. CSS does not care about your devicepixelratio. Pretty neat!

Conventions – a solid foundation

Having already worked in a hand full of projects before I joined this one, I’ve noticed a certain pattern of problems that usually arise in front-end development. Those problems typically fall in one of three categories:

Ad-hoc javascript

Ad-hoc CSS rules

Ad-hoc HTML structure

Under ad-hocness I mean that stuff is written:

As separate pieces that are glued together to existing codebase

Without any thought of the bigger picture

Often without proper knowledge of front-end technologies and patterns

I should know, my code used to be quite messy as well. However, continuing like that in a project, which is 90% front-end would have been a suicide, thus it was decided that we should work out some set of rules for ourselves. Next I will explain what we ended up with after some period of trial and error.

We try to push as much as possible to static HTML, meaning that we hardly create any HTML in the javascript, even if it means duplicating the same HTML code multiple times. This allows us to have a fantastic overview of the whole game structure and, basically, to use HTML as a structural template. Javascript thus stays clean, concentrating on its main role – dispatching events and switching stuff on and off.

Javascript

External

For DOM manipulation and AJAX we are using jquery in this project, but in the future we will probably switch to a simple, lightweight in-house library, since for a game, which needs to support only webkit browsers jquery is a definite overkill. For sounds and preloading we use soundjs and preloadjs. That’s pretty much all of our dependencies.

Internal

For the application code we decided to go with pure OOP as much as it is possible in javascript. Every class has a separate .Js file with its name and for view classes we also add a companion .Css file with the same name. Thus we make everything a component that can be easily modified and reused.

Here is sort of a JS class template that we have worked out for ourselves:

CSS is not a programming language in a traditional sense, thus for a typical developer it is quite hard to reason about it. Yet CSS is very important, as it builds the face of your application and usually needs to change more often than the logic. Therefore, understanding how to build scalability into CSS from the ground up is vital for success of any project.

Most of the stuff on this topic is covered in one of my blog posts. At first, we took almost everything in and then step by step started evaluating if a certain rule actually brings us any value or just adds unnecessary complexity. Our modifications and additions are listed next.

No preprocessors

There’s nothing bad about them though. We’ve just decided to keep things as bare bone as possible.

CSS animations are part of state group

Basically, it is the same change of state, but just prolonged in time. For the sake of clarity, we usually name them after continuous actions (is-rising, is-moving), unlike regular state classes, which are named after completed actions (is-hidden, is-selected).

Limit the usage of layout classes

At some point of time we understood that having layout classes everywhere just polluted our code. Unlike a website, the game does not have a lot of reusable elements, thus it is useless to separate layout from styling of every single visual element that would appear only once. We decided to limit layout class usage only to cases, where they actually make sense and merge them with styling code for remaining rules.

Separate logic classes from styling classes

After some time we also understood that it is a good thing to separate javascript hooks (classes that you reference in the code) from styling classes. This involves having to attach more classes to your elements, but completely separates your JS code from CSS. You can rename and remove styling classes without any harm to your logic and you can rename and move the hooks around the DOM without any impact to the visual look. Perfect!

Javascript hook classes have their own js- prefix and since those classes are component-scoped they don’t require namespacing or any other naming conventions.

To give an example of how this works. Imagine a label, which we would style through mycomponent__my-label class and insert a dynamic label through js-label class:

Now at some point we decide that we need a span to center the text vertically and thanks to our fancy design decision we can do it without any changes to the javascript code.

Architecture

Continuing the talk about code structure, we now move on to the actual architecture of our game. I would say that no surprises await us here. We are using the good old MVC approach coupled with a thin network layer (which would probably get merged with the model at some point).

Network

Makes AJAX requests

Receives and parses responses

Fires events once response is received

Updates model with response data

Model

Wraps DOM operations

Listens for UI events

Performs animations

Switches stuff on and off

Updates itself based on model state

Controller

Handles view and network events

Calls view and network methods

Synchronizes animations

The game itself is partitioned into several independent clients. Each client is responsible for a certain device type (iphone, ipad, android phone etc). Special device detection component is used to redirect the player to the correct client folder.

Animations

Animations are undeniably the heart of your game. Knowing what the browser offers you in this field and how to use it efficiently is the key to success for every web game developer.

Forget about JS animations

One mistake that we’ve made in the very beginning and the one that you should not repeat is thinking that JS animations are good enough. Well, they are not! Believe me.

Transitions vs animations

First thing that you should know about animating with CSS is that you have two big guns in your arsenal.

Transitions

Transitions animate changes in CSS properties. You specify what properties are animated, for how long and with what easing. When this property is updated it will smoothly transition between the current and the new value. This works both for single value properties like opacity and multi value like color.

Transitions are not very suitable for complex animations. Their main use case is when you want to animate something dynamic, which cannot be easily predefined with key frames.

In our game we use transitions only in two places: preloader progress bar smoothing and animating boat movement to different islands in the bonus game.

Animations

CSS animations provide a versatile API for complex, multi step, key frame based animations. You describe the movement with a special @keyframes rule and then reference this declaration along with duration, easing and a whole bunch of other properties. Usually, animations are applied thorough some on/off state classes.

The key to writing good animations is knowing and using every configuration property available. Take your time to study them all. For example, for me it was a surprise that animations can actually retain its final position through fill-mode. For quite a while a thought it was only possible through transitions. Other interesting thing is timing-function: steps(n) – veery useful in sprite animations.

GPU acceleration is king

Now I’ve told you that you should drop the idea of using JS animations in favor of CSS ones. Actually, I was not specific enough – GPU accelerated CSS ones. If you want to have multiple animations running at the same time you’re going to need to use the graphics card, otherwise your game would just die. This means one thing and one thing only – translate3d. Stick it wherever possible.

For example, our initial version of the bonus game used only a few hardware accelerated animations. And boy did it lag! After some iterations we were able to push everything to GPU including sprite animations. Immediately, all of our performance problems got solved.

Don’t forget about 3D quirks

While 3d transforms are awesome, they may have some interesting side effects that you should be aware of. Even though your z-coordinate will always be 0, you are still operating in the 3d context of the browser. Weird things can happen when you are switching contexts for the period of a single animation and indeed there are a lot of complains on the web about flickering in animations. The main suggestion here is to use:

This property removes the backside of your DOM element, which it automatically gets when put into 3D context. From our experience it does have an effect, so it’s definitely worth a try in case of 3D quirks.

Another good practice that reduces glitches is initially having translate3d(0,0,0) on the element to remove the context switch.

CDD and task queue

If you’ve worked with animation code in the past, you might have noticed that it tends to result in nested callbacks. In our company we call it callback driven development – an anti-pattern, which we have tried to get away from by introducing task scheduling system called task queue. The system consists of a task executor that can register and execute tasks in the specified order. Individual tasks either wait for some event to happen or execute code.

To give a bold example, here is what you mind have before you introduce the queue:

And here is what happens after:

The resulting code is not only easier to maintain and reason about, but it also gives you a nice overview of the whole sequence of events. And the best part is that it can be used to sequence anything you want, not only animations.

If you would like to get a library for handling asynchronous code, then search for: javascript flow control library.

Compilation process

Hold on, compiling javascript? Are you mad!

Compiling or building in SPA land means that you apply a set of optimizations to your initial code base to get a better (in many ways) code base as a result without any negative side effects.

As most web developers today, we use gruntjs for this task. It’s a simple nodejs application that we’ve integrated into our CI build system. On each commit it performs its magic and deploys the so-called production version of the game client.

The cool thing about grunt is, of course, the amount of plugins that you can find. And if for some reason you cannot find the one you need, then it is dead easy to write you own. That’s what I also ended up doing ��

Here is our build process at a glance:

Grunt-contrib-jshint, grunt-jscs-checker – verify code conventions/quality

Grunt-contrib-imagemin – loseless image compression

Grunt-css-url-embed – embed images and fonts into CSS files as base64 to disable on-demand loading mechanism inside the browser

Grunt-usemin (prepare step) – scan the HTML file for so-called build blocks, that mark what files should be minified (to reduce size) and concatenated into one (to reduce HTTP request count)

Grunt-contrib-concat – perform concatenation based of the list compiled by usemin

Grunt-contrib-cssmin – perform CSS minification based of the list compiled by usemin

Grunt-contrib-uglify – perform JS minification based of the list compiled by usemin

Grunt-usemin (perform step) – rewrite the HTML file with references to concatenated and minified assets

Grunt-cache-bust – append an “MD5 of content” query string to assets in the HTML file for anti-caching

Grunt-contrib-htmlmin – minify HTML files

Compressing assets

Images

As already mentioned, for images we use grunt imagemin plugin, which we have integrated into our build, so that image originals are stored in the code repo and compressed graphics are always part of compiled client.

Sounds

Sound compression is pretty straightforward. Take audacity and play with sampling and bit rates. For devices the quality can be quite low without any real harm.

Fonts

No matter where you get your fonts from use this tool to compress them into .Woff. Results are pretty impressive.

Use optimal if you don’t care about specific alphabets like cyrillic.

Use expert if you want to support those alphabets. Make sure that your original font supports those languages in the first place, of course ��

Preloaded assets in HTML

One problem that we’ve came across was that some of the stuff we needed to reference statically in the HTML file and some we had to preload in javascript. Separating assets into several places seemed like a bad idea, since it definitely would have complicated things. The solution was to keep everything in one place – the HTML file. Static assets are referenced as usual and preloaded assets reside in their own special tag:

HTML does not care about them at all, but the preloading component does. It collects those tags and passes URL’s to preloadjs. The cool thing about this approach is that initially it was used only for CSS files, however we did not have to change a thing when it came to sounds. Preloadjs supports them out of the box.

As a nice bonus, we were able to apply our grunt cache busting to preloaded assets as well without any additional work!

Second orientation

One conceptual problem that you always have to deal with when developing a mobile browser game is handling the second orientation. As you cannot lock the orientation in the browser, most games just put a notice for the player to rotate back to the supported orientation. While this seemed like the only feasible option, we somehow felt that something less annoying can be done, so instead of “throwing away” the portrait we turned it to our advantage. The idea is that if the player wants to take the game and lie down on the couch he would still have the ability to play the game without manually locking the screen. To put it simple, we rotate the game by 90° in portrait, so it would be shown as if the orientation was locked to landscape. Not only it allows us to support the so-called couch mode, but also handles the issue of switching to correct orientation, as it intuitively forces the player to rotate the device without the need to read any instructions.

Technically, the task was pretty interesting. We ended up developing an awesome javascript component that knew how to center and scale our game to fit every possible condition. Here are the key CSS and JS features that allowed us to do it:

Transform-origin, transform – to apply scale() and rotate() with specified pivot point

Element.Getboundingclientrect() – to get live offset information of the game view element, which can be used to apply counter-offsets for centering

Automated tests

For testing purposes we use jasmine together with jasmine jquery that allows loading your app into the DOM as a fixture and perform asserts on the real thing. The benefit of running tests in the browser is that they can be run on real devices without any additional hacky plugins or add ons. Just open the testing URL and it will do the rest. Nevertheless, to completely relieve us from the manual work we connected a bunch of devices to our CI and scheduled regular test runs on those devices. Thus we got a fully automated testing process on real devices.

Useful stuff to know and use

Lastly, I would like to point our some useful tips and tricks that we’ve gathered during development.

Useful CSS properties

Disables some stuff that is not needed in a game and also adds antialiasing for fonts:

And here is another interesting set of properties that we’ve came across:

We had some very controversial results regarding performance with those, so I am not going to give any suggestions. Take your time, read about them, try them out.

Useful head tags

Do not treat certain long numbers as telephone numbers:

Disable scaling and enable “full screen” mode in iphone through minimal-ui (works since ios 7.1):

Enable saving to home screen in ios:

Icon for home screen in ios:

Disabling scrolling

Scrolling is usually not needed. If you need to enable it, say, only for menu panels, then you can make a condition for preventdefault using, for example, event.Target.

Inertia scrolling

Removing tap delay

In the browser tapping involves a certain delay, since the browser always waits for double tap. There is a neat library called fastclick, which removes it.

Know your visibility toggling options

Knowing how different properties hide your elements can save you a bit of CPU ticks for free. Here are your hiding options:

Completely hides the element and reflows surrounding content. This is the most expensive hider. We use it only in very specific places, where the next one was giving side effects.

Visibility: hidden

Hides the element visually, while retaining it’s “structural part”. We use this one the most, since in case of absolute positions it behaves exactly like the previous one, but does not force the browser to do reflows.

Hides the element visually, while retaining it’s “structural part” and the ability to receive events. Our tests showed that this one is a tiny bit cheaper than the previous one. It cannot be used everywhere, since it traps events, so we use it only in places that don’t require user input.

To be continued…

Next on our list are android devices. Probably those are going to be a real headache… nevertheless, we are up for the challenge!

Hope you had a great reading and stay tuned for more games from our game studio ��

Create a slot machine game in flash using AS3

Follow the straight-forward steps of this premium tutorial to create an entertaining slot machine game in flash. Spin the wheels and see what you could win!

Step 1: brief overview

Using the flash drawing tools we'll create a good looking graphic interface that will be powered by several actionscript 3 classes.

The user will be able to bet different amounts to win the prizes.

Step 2: flash document settings

Open flash and create a 480 pixels wide, 320 pixels tall document. Set the frame rate to 30fps.

Step 3: interface

A dark interface will be displayed; this involves multiple shapes, buttons, bitmaps and more.

Continue to the next steps to learn how to create this GUI.

Step 4: background

Create a 480x320 px rectangle and fill it with this radial gradient: #404040, #080808.

Use the align panel (cmd + K) to center it in the stage.

Step 5: title

Let's add a title to our game; depending on your slot machine theme you can change the graphics to fit your needs. Here I've used the tuts+ logo.

Step 6: slots background

Use the rectangle primitive tool (R) to create a 320x160px rectangle. Change its corner radius to 10 and fill it with this linear gradient: #F5DA95, #967226, #91723B.

Duplicate the shape, change its size to 316x156px and change its color to the black linear gradient we used before.

Step 7: items graphics

These are the graphics we'll use as the slot machine items -- feel free to use any graphics you want in your own game!

Step 8: reel backgrounds

To create the background for the reels, use the rectangle tool (R) to create a 98x146px rectangle and fill it with this gradient: #8F8459, #F8F4C7, #8F8459.

Duplicate the shapes and align them in the slots area.

Step 9: reel movieclip

Arrange the items graphics in your desired order and convert them to movie clips. We'll use the reel background rectangle of the last step to create the shadow effect: change its color to black and change its alpha values to 65, 15, 0.

This can be a tricky part so be sure to download the source files to help you out.

As you can see, I've used two nettuts+ logos and two psdtuts+ logos, but only one each of the activetuts+ and vectortuts+ logos. This means there's a greater possibility of matching three nettuts+ logos than there is of matching three activetuts+ logos.

Use the shadow as a mask layer, and the timeline to animate the items downwards. I used frame by frame animation moving the items 20 px down in every frame. You could use a tween, if you wanted to.

Duplicate this moveclip and place them in the correct slot background. Use the following instance names: items1, items2, items3.

Step 10: labels

Timeline labels will be used to check for a winning combination. Create a new layer and label each frame where our item is in the center.

Step 11: static textfields

Use the text tool (T) to create three static textfields: credits, bet and winner paid.

Step 12: dynamic textfields

With the text tool still selected, create three dynamic textfields, place them above the static ones and name them, from left to right: creditst, bett and paidt.

Step 13: buttons

Use the rectangle primitive tool to create three 45x45px squares, change the corner radius to 4 and fill it with: #CD0202, #910202. Add the corresponding text label to each, convert each to a button, and name them: paytabb, betmaxb and betoneb.

Step 14: spin button

The spin button is a little larger that the others and also has another color.

Use the same process of the other buttons, but change the size to 50x50px and the color to: #5DA012, 3C670C.

Step 15: sounds

We'll use sound effects to enhance the feeling of the game, you can find the sounds used in this example in soungle.Com using the keywords slot machine.

Step 16: tweennano

We'll use a different tween engine from the default included in flash, this will increase performace as well as it is easier to use.

You can download tweennano from its official website.

Step 17: new actionscript class

Create a new (cmd + N) actionscript 3.0 class and save it as main.As in your class folder.

Step 18: class structure

Create your basic class structure to begin writing your code.

Step 19: required classes

These are the classes we'll need to import for our class to work; the import directive makes externally defined classes and packages available to your code.

Step 20: variables

These are the variables we'll use, read the comments in the code to know more about them.

Step 21: constructor code

The constructor is a function that runs when an object is created from a class, this code is the first to execute when you make an instance of an object, or runs when then SWF first loads if it belongs to the document class.

It calls the necessary functions to start the game. Check those functions in the next steps.

Step 22: stop items

Prevent the reels movieclips from playing immediately.

Step 23: add button listeners

Here we use a custom function to add the mouse events to our buttons; this function will be created later in the class.

Step 24: disable spin button

Next we use another custom function that will prevent the mouse events of the spin button.

Step 25: button listeners

This function adds or removes a mouseup event to the buttons depending on the specified parameter.

Step 26: enable/disable buttons

The following function uses its parameters to tween the alpha value of the specified button and disable/enable mouse interactions.

Step 27: bet max button

The bet max button is handled by this function.

It plays the spin sound, changes the credits textfields,, and calls the spin function.

Step 28: bet one button

The bet one button is handled by this function.

It increases the bet by one (if possible) and plays the corresponding button sound. It also enables the spin button.

Step 29: show/hide pay table

The pay table button is handled by this function.

It checks whether the pay table is already on stage, and, if not, it uses a tween to display it and center it. The other buttons are disabled while the table is showing.

Step 30: spin button

The spin button is handled by this function.

It plays the spin sound and the spin function if the credits are correct.

Step 31: spin function

One of the core functions of the game, the spin function handles the winning and spending of credits, spins the items in the slots and uses a timer to stop them. Read the next steps for a more detailed view of these actions.

Step 32: add won credits

This checks whether credits are available to add from the paidt textfield, and resets its value to 0.

Step 33: subtract credits

This subtracts the credits used in the last bet.

Step 34: spin items

This function animates the reels, to make the items appear to spin.

Step 35: spin timer

This timer determines (randomly) the time to let the reel items spin, it is different in every spin.

Step 36: timer function

This function is executed every time the timer ends its count.

It stops the current slot from spinning and plays the stop sound. When all items are stopped it clears the timer and calls the checkwin() function.

Step 37: snap to nearest logo

As the timer can end in a frame where the current item is not in the center, we check the current frame of the movieclip and use gotoandstop() to display the closest item.

You may need to alter this code to match the symbols and spin animation that you chose.

Step 38: check win

This function checks if the three items are equal, if true, it plays the winning sound and adds the corresponding amount to the paid textfield.

Step 39: set main class

We're making use of the document class in this tutorial, if you don't know how to use it or are a bit confused please read this quicktip.

Set your FLA's document class to main .

Step 40: test

We are now ready to test the movie and see if everything works as expected, don't forget to try all the buttons!

Conclusion

The final result is a customizable and entertaining game; try adding your custom graphics and prizes! You could also have a go at altering the probability to make it easier or harder to win.

I hope you liked this tutorial, thank you for reading!

Add a slot machine like this one to your site today!

It's fully customizable!

Examples

Overview

Visitors increasingly want to engage with our sites and brands. This slot machine gives the perfect way for your visitors to do that with little effort or cost to you or your company. On top of that it increases customer loyalty, returning to the site to continue to play! We've seen a huge variety of companies use this to great success. Imagination really is the only limit!

Have your own HTML5, pure javascript slot machine on your site! In a recent survey, 74% of users said the well finished game contributed вђњmoderately or significantlyвђќ to the fun of the site.

Packages provide a license for you to use this slot machine on all your sites. You can mix it up and customize your slot machine with the 5 different pre-set designs provided, or you can very easily make your own.

Written in pure HTML 5, javascript, jquery and CSS it is extremely quick and simple to integrate into any new or existing site. Proven to work flawlessly on mobiles and tablet (including android, ios and windows phone), your visitors can enjoy this feature at any time and there is no use of flash or java, so no annoying pop ups to distract your visitors from what you want them to focus on!

Some interesting uses and ideas for your slot machine

These are some of the imaginative uses our customers have given their slot machine. Get your creative juices flowing!

Encourage spending in your store giving people a chance to win discounts, prizes and promotions.

Give credits away as virtual game currency, or virtual goods in those games, when users level up, or find a chest, for example.

Give customers a chance to win a discount at the time of checkout, in your online store.

Use it together with physical scratchcards to give people prizes in a loyalty program.

Set up a spot at events with several games to entertain guests.

Add casino-style games to your site, to increase customer engagement.

Create a buzz at a convention, letting visitors play and win merchandise items (t-shirts and hats, for example). Change the odds heavily so that almost everyone wins.

5 designs included, immediately ready to use.

Fully customizable. You can very easily change the images, sounds, animations, pay table, and prizes to suit your needs.

Completely responsive to every resolution and device. Works on every browser.

You can offer either monetary prizes, or physical gifts like hats, t-shirts, or store credit for your site, to improve your brand and keep customers coming back!

100% HTML, CSS3 and javascript code, based on jquery. Does not use java or flash, ensuring compatibility with all mobile devices.

Smooth jquery animation.

Cheat and fraud prevention measures to avoid getting fraudulent complaints from your customers.

Over 10 million spins to date, resulting in millions of dollars in profits for the different sites that host it. On a monthly average, there's about one spin every 5 seconds.

The package includes the full source code for the entire slot machine, including HTML, CSS, javascript and PHP code. It also includes extensive documentation on how to implement the slots in your own site, and how to customize every element of it, in case you want to.

Only a very, very basic knowledge of PHP and CSS is necessary to add this to your site. If you don't have your own programmers, or don't feel comfortable doing it, we can do this for you for a fee.

We also offer a custom-design option for an extra fee, in which we get you in contact with our graphics designer, and you get the design that you need, ready to plug into your site.

Yes, all the images you see can be directly replaced for anything you would like, by simply changing the files provided.

Yes, all the probabilities are 100% configurable when setting up the prizes for the game. This is explained in detail in the documentation, including examples to make it as easy as possible.

Yes, it's quite easy to integrate this into wordpress by simply modifying the site templates to add the HTML code, and then adding the extra CSS and JS file. Quick and simple!

A very minimal knowledge of PHP and CSS is needed to implement this on your site. Any junior programmer can do it. Alternatively, you can hire us to do it for you, for a very small additional fee.

Yes, a one time payment of the license fee gives you our full source code, and allows you to use the slot machine in as many sites as you own.

You can very easily change everything that your visitors will see about the slot machine. All images and sounds, the pay table configuration, maximum and minimum bets, payouts, the details of the animation, etc. The package you will buy includes extensive documentation on how to modify all of these, and our support team will also be able to help you and answer all your questions.

Yes, several of our customers use their slot machine to give out t-shits, hats, store credit, discount codes and more!

Yes, you can have your payouts in entire dollars, quarters, cents, even bitcoin fractions if you want.

Yes! Basically, you can integrate this with any payment / credits mechanism you can think of, be it regular money, bitcoin, tokens, anything!

You get absolutely everything, in full un-minified, non-obfuscated form. All the PHP, HTML, CSS and javascript, which you can modify as much as you wish, along with extensive documentation on how to do so.

Add a slot machine like this one to your site today!

It's fully customizable!

Examples

Overview

Some interesting uses and ideas for your slot machine

These are some of the imaginative uses our customers have given their slot machine. Get your creative juices flowing!

Encourage spending in your store giving people a chance to win discounts, prizes and promotions.

Give credits away as virtual game currency, or virtual goods in those games, when users level up, or find a chest, for example.

Give customers a chance to win a discount at the time of checkout, in your online store.

Use it together with physical scratchcards to give people prizes in a loyalty program.

Set up a spot at events with several games to entertain guests.

Add casino-style games to your site, to increase customer engagement.

Create a buzz at a convention, letting visitors play and win merchandise items (t-shirts and hats, for example). Change the odds heavily so that almost everyone wins.

5 designs included, immediately ready to use.

Fully customizable. You can very easily change the images, sounds, animations, pay table, and prizes to suit your needs.

Completely responsive to every resolution and device. Works on every browser.

You can offer either monetary prizes, or physical gifts like hats, t-shirts, or store credit for your site, to improve your brand and keep customers coming back!

100% HTML, CSS3 and javascript code, based on jquery. Does not use java or flash, ensuring compatibility with all mobile devices.

Smooth jquery animation.

Cheat and fraud prevention measures to avoid getting fraudulent complaints from your customers.

Over 10 million spins to date, resulting in millions of dollars in profits for the different sites that host it. On a monthly average, there's about one spin every 5 seconds.