How to make a simple BalloonPop game with V-Play

Introduction

This game idea and its image and audio resources are from the excellent Corona tutorial on Ray Wenderlich's site http://www.raywenderlich.com/22064/how-to-make-a-simple-game-with-corona.

This tutorial assumes you already had a look at Getting Started with V-Play and Qt Creator. They provide you with the very basics which may not be fully explained in this tutorial. Nevertheless, this tutorial aims at beginners, so let's give it a shot.

Resources

Images and sounds for this game are available for you to download right here: Download Resources

New Project

Create a new Empty V-Play Project with the name BalloonPop. Now extract the resource files that you just downloaded into the qml directory of your project. Since you are already here, also create a new folder entities (which we will need later) inside the qml directory.

On to a little brainstorming. What major components do we need to create this game?

  • We already know, our root element is the GameWindow in the main.qml which will then hold our Scene for the game.
  • Obviously there will be balloons.
  • We want to keep the balloons inside the scene so we need walls to surround it.
  • A little heads-up display to give the player information.

We cut down the Code in the main.qml to the minimum, like this:

 import VPlay 2.0
 import QtQuick 2.0

 GameWindow {

   Scene {}
 }

Game scene

Keep in mind that larger games will definitely have more than just the game scene (e.g. menu, settings,...). So it's common to define the different scenes in separate files, making the code more readable. Go ahead and add a BalloonScene.qml to your qml directory.

Now we will put the Scene element here, and our GameWindow will hold our custom scene.

BalloonScene.qml

 import VPlay 2.0
 import QtQuick 2.0

 Scene {

 }

main.qml

 import VPlay 2.0
 import QtQuick 2.0

 GameWindow {

   // our scene that contains the game
   BalloonScene {}
 }

Our main.qml is finished now since this is our only scene.

Let's take a look at our BalloonScene.qml. We add some basic features that we definitely need.

 //...
 Scene {
   // number of balloons currently on the scene
   property int balloons: 0
   // maximum number of balloons
   property int balloonsMax : 100
   // duration of the game
   property int time : 20
   // flag if game is running
   property bool gameRunning: false

   // position the scene on the top edge
   sceneAlignmentY: "top"

   // used to create balloons at runtime
   EntityManager {
     id: entityManager
     entityContainer: balloonScene
   }

   // make the balloons float up
   PhysicsWorld {z: 1; gravity.y: -1}

   // add a background image
   Image {source:"../assets/img/clouds.png"; anchors.fill:gameWindowAnchorItem}

   // the pop sound used by balloon entities
   SoundEffectVPlay {source:"../assets/snd/balloonPop.wav"}

   // add background music
   BackgroundMusic {source:"../assets/snd/music.mp3"}
 }

Now we can set the maximum number of balloons that we want to have on the scene, as well as the time we give the player to pop them. Furthermore we added a counter balloons that will hold the current number of balloons alive and a flag to indicate if the game is running or not.

The EntityManager is used to create balloons at runtime. The PhysicsWorld with a very low gravity of -1 in y direction makes the balloons float up gently.

The background Image and BackgroundMusic improve the gaming experience, I have no doubt about that! Have a look at anchors.fill:gameWindowAnchorItem in the background Image. This is needed to avoid black borders on different mobile devices with different screen sizes. Also the sceneAlignmentY: "top" is there for a similar reason, we ensure that the ceiling of our scene is at the top of the screen.

The SoundEffectVPlay object loads the pop sound for the balloons. This one will have to be available to the balloons themselves so we need to add a little fix here.

 //...
 Scene {
   id: balloonScene

   // provide the pop sound public for the balloons
   property alias popSound: popSound
   //...
   // the pop sound used by balloon entities
   SoundEffectVPlay {id:popSound; source:"../assets/snd/balloonPop.wav"}
   //...
 }

Adding an id to the Scene gives us the possibility to interact with it from outside. The pop sound can now be accessed via balloonScene.popSound thanks to the property alias that points at our SoundEffectVPlay object.

Run the project and enjoy the beautiful sky, prettified by the delightful music, isn't that already enough? Not for us!

We'll proceed with some walls, everyone likes walls.

Walls

Following the lessons we learned in Getting Started with V-Play and Qt Creator, we will create a reusable wall entity. Add an entities folder as subfolder of qml if you haven't done that already. Now add a new file Wall.qml to the entities folder.

Insert the following code to Wall.qml

 import QtQuick 2.0
 import VPlay 2.0
  // for accessing the Body.Static type

 EntityBase {
   entityType: "wall"
   // default width and height
   width: 1
   height: 1

   // only collider since we want the wall to be invisible
   BoxCollider {
     anchors.fill: parent
     bodyType: Body.Static // the body shouldn't move
   }
 }

So what happened here? We want the walls to be invisible, so we don't add anything like a Rectangle or similar. We just want them to block our balloons, so we add a BoxCollider that fills the whole wall. Also, the wall shouldn't be affected by gravity, that's why we tell it to be Body.Static.

Now add some walls to the BalloonScene.qml, just before the last closing }. Additionally we need to import our entities folder to be able to use our Wall.qml

 //...
 import "entities"

 Scene {
   //...
   // left wall
   Wall {height:parent.height+50; anchors.right:parent.left}
   // right wall
   Wall {height:parent.height+50; anchors.left:parent.right}
   // ceiling
   Wall {width:parent.width; anchors.bottom:parent.top}
 }

We want the walls to be outside of the scene, so we use the anchors. E.g. we anchor the furthest right side of the wall to the furthest left side of the scene, meaning the body of the wall is left outside of the screen. The reason I put +50 to the height, which causes the wall to go 50 pixels below the scene, is that we don't lose any balloons to the sides while creating them. You will understand this security measure in a few moments.

Ok looks fine, not that there is anything new to see if we run the project, but anyway, time for balloons!

Balloons

Add a Balloon.qml file to the entities folder.

Insert the following code to Balloon.qml

 import QtQuick 2.0
 import VPlay 2.0

 EntityBase {
   entityType: "balloon"
   width: sprite.width
   height: sprite.height

   MultiResolutionImage {
     id: sprite
     source: "../../assets/img/balloon.png"
   }

   CircleCollider {
     radius: sprite.width/2
     // restitution is bounciness, balloons are quite bouncy
     fixture.restitution: 0.5
   }

   MouseArea {
     anchors.fill: sprite
   }

   // gives the balloon a random position when created
   Component.onCompleted: {
     x = utils.generateRandomValueBetween(0,balloonScene.width-sprite.width)
     y = balloonScene.height
   }
 }

There are some more things to say about this piece of code. In our case, we want the size of the balloon to result from the size of the MultiResolutionImage we load, so it's super easy to replace that one. The MultiResolutionImage uses the correct image size depending on the display resolution. To learn more about multi-resolution support check out How to create mobile games for different screen sizes and resolutions.

A CircleCollider matches the shape of a balloon best and way better than a BoxCollider. Add some fixture.restitution to make the balloon bouncy.

The MouseArea fills the whole balloon image and is used to make them pop when the balloon is touched.

And the last little bit of code, the Component.onCompleted section will define the position of the balloon when it is created. We want the balloons to spawn at the very bottom of your scene, and thanks to the id:balloonScene that we gave the Scene, we can get its width and height for this calculation.

At the end of BalloonScene.qml, just before the last closing }, we add this piece of code

 //...
 // create balloons with short intervals in between
 Timer {
   interval: 20 // milliseconds
   running: true // start running from the beginning, when the scene is loaded
   repeat: true
   onTriggered: {
     // after every 20ms we create a new balloon
     entityManager.createEntityFromUrl(Qt.resolvedUrl("entities/Balloon.qml"));
     balloons++
     // if the maximum number of balloons is reached, we stop the timer and therefore the balloon creation and start the game
     if(balloons===balloonsMax) {
       running = false
       gameRunning = true
     }
   }
 }
 //...

Finally we got some action in here. Watch the balloons getting a little crazy when you run the project. So crazy that we made the side walls a little longer than maybe needed, just in case...

What did we do? We used a Timer with an interval of 20ms. So every 20ms it will trigger. And on each of these triggers we tell our EntityManager to create a new entity from our Balloon.qml file, in other words a new balloon. If our maximum number of balloons is reached, we stop the timer and start the game.

Handling the V-Play Splash Screen

When running the code you might have noticed the V-Play Splash Screen, which is only visible for developers that use our free plan. Our game scene is already created and starts running in the background while the splash is still visible. This allows the splash to also act as a basic loading screen for the first visible scene - after splash is finished the scene is immediately shown.

Unfortunately there's one issue caused by this behavior: We already start the game and create balloons while the splash is still visible. This happens because the Timer that creates the balloons starts running automatically after it is created. So let's add some code to delay our balloon creation until the splash screen is finished:

Let us change the Timer in BalloonScene.qml to not run automatically:

 Scene {
   // ...

   // starts the game
   function start() {
     spawnBaloons.start()
   }

   // create balloons with short intervals in between
   Timer {
     id: spawnBaloons // after the game initialization is complete we start the timer manually using the id
     interval: 20 // milliseconds
     repeat: true
     onTriggered: {
       // after every 20ms we create a new balloon
       entityManager.createEntityFromUrl(Qt.resolvedUrl("entities/Balloon.qml"));
       balloons++
       // if the maximum number of balloons is reached, we stop the timer and therefore the balloon creation and start the game
       if(balloons===balloonsMax) {
         running = false
         gameRunning = true
       }
     }
   }
 }

For the Timer, we removed the running: true setting and added an id. We can then use the new start() function of our scene to start the Timer anytime we want. To start it right after the splash is gone we can use the onSplashScreenFinished signal in our main.qml.

 GameWindow {
   id: gameWindow

   // start the game when is splash finished
   onSplashScreenFinished: balloonScene.start()

   // our scene that contains the game
   BalloonScene {
     id: balloonScene
   }

 }

Start the game again, you will see the balloons popping up after the splash is gone just as we wanted them to.

Note: For initialization code that can safely be run while the splash is still showing you can also use the Component.onCompleted signal instead. In addition, if you removed the splash screen by purchasing a V-Play license, the two signals are identical. We recommend to only use onSplashScreenFinished for code that requires to be run right after the splash. Otherwise the regular Component.onCompleted signal is the better choice.

Now we have everything correctly set up, so what's next? You don't want to hurt no balloon, do you? Me neither, but the players may want to, so let's make them pop-able.

Popping the balloons

This is done by adding a simple piece of code to our Balloon.qml, more precisely the MouseArea

 MouseArea {
   anchors.fill: sprite
   onPressed: {
     // if you touch a balloon and the game is running, it will pop
     if(balloonScene.gameRunning) {
       balloonScene.balloons--
       balloonScene.popSound.play()
       removeEntity()
     }
   }
 }

We listen on the MouseArea::pressed signal of the MouseArea. If the player touches the balloon we count down the current number of balloons, play the pop sound and remove the entity. Of course we only allow this to happen if the game is running.

Not too challenging when you got infinite time. We take care of that now.

Ending the game

Add this at the end of BalloonScene.qml, just before the last closing }

 // game timer, default interval is 1 second
 Timer {
   id: gameTimer
   running: gameRunning // time only counts down if game is running
   repeat: true
   onTriggered: {
     time--
     // if time is over, or each balloon is popped, we stop the game and give the player some feedback about his success
     if(time === 0 || balloons === 0) {
       gameRunning = false
     }
   }
 }

The timer is only running if the game is running, meaning it starts after all balloons are loaded and the game started. After each second (we don't necessarily need to define that interval because 1 second is the default interval) the timer triggers. On every trigger we decrease the remaining time. Then we check if the time is already over or the player managed to pop all balloons, in both cases we stop the game.

The only thing missing now is a little heads-up display.

HUD

We want to keep it as simple as possible, one row at the bottom will do it. We want to display the remaining time, and a little info field.

Add this to BalloonScene.qml, e.g. above our timers

 //...
 // HUD
 Row {
   anchors.bottom: parent.bottom
   z: 2 // make sure the HUD is always on top
   // info text area
   Text {id:infoText; width:200; height:40; text:"Loading balloons..."}
   // display remaining time
   Text {id:timeText; height:40; text:"Time: "+balloonScene.time}
 }
 //...

Now we got a Row with 2 Texts. The 2nd one displays the text "Time: " followed by the remaining time of the game.

The 1st one should give the player some information. We start with the text "Loading balloons...". After all balloons are loaded we want to give the player feedback that he can start popping them now.

Add this to your BalloonScene.qml, more precisely the first Timer, used to create the balloons

 //...
 // if the maximum number of balloons is reached, we stop the timer and therefore the balloon creation and start the game
 if(balloons===balloonsMax) {
   running = false
   gameRunning = true
   infoText.text = "Hurry!"
 }
 //...

This changes the text property of our infoText Item to "Hurry!", telling the player that the game is running.

The last thing we want to add are some motivating words to the player at the end of the game.

Add this to your BalloonScene.qml, more precisely the second Timer, used for the game time

 //...
 // if time is over, or each balloon is popped, we stop the game and give the player some feedback about his success
 if(time === 0 || balloons === 0) {
   gameRunning = false
   if(balloons === 0) infoText.text = "Perfect, take a cookie!"
   else if(balloons < balloonsMax/2) infoText.text = "Well, that was decent..."
   else infoText.text = "Not your day huh..."
 }
 //...

Depending on the number of balloons the player popped, he gets a feedback about his success as soon as the time ran out or he popped all balloons.

So that's it for now, enjoy the gaming experience! If you have any questions regarding this tutorial, don't hesitate to visit the support forums.

Visit V-Play Engine Examples and Demos to gain more information about game creation with V-Play and to see the source code of existing apps in the app stores.

Voted #1 for:

  • Easiest to learn
  • Most time saving
  • Best support

Develop Cross-Platform Apps and Games 50% Faster!

  • Voted the best supported, most time-saving and easiest to learn cross-platform development tool
  • Based on the Qt framework, with native performance and appearance on all platforms including iOS and Android
  • Offers a variety of plugins to monetize, analyze and engage users
FREE!
create apps
create games
cross platform
native performance
3rd party services
game network
multiplayer
level editor
easiest to learn
biggest time saving
best support
Sign up for Free and start developing right away!
I want to make Games
I want to make Apps
Game Development
Cross-Platform, Any Resolution

Use one IDE to deploy to all supported platforms, including iOS and Android, from a single code base.

Support all screen resolutions, aspect ratios and sizes with auto-adapting UI elements, smart scene scaling and memory efficient asset selection.

Learn More

V-Play ranked #1 at research2guidance cross-platform tool benchmarking 2014 by 2188 developers comparing 40 leading tools.

Multiplayer

V-Play Multiplayer supports both real-time and turn-based gameplay, so you can use it to make many different types of cross-platform multiplayer games. It's perfect for making player-vs-player games like 'Words with Friends' or games for a large amount of players, such as 'Clash of Clans'.

Learn More Video

Highscores & Achievements

The V-Play Game Network is a cross-platform gaming service that allows players around the world to compare game highscores and achievements. Players can also challenge each other across multiple platforms and share their progress on Facebook.

Learn More

QML & JavaScript

Qt Meta Language is a highly intuitive reactive language, which is super easy to learn, yet it's extremely powerful and flexible. Mix it with JavaScript to create awesome stuff, with just a few lines of code.

import QtQuick 2.0
import VPlay 2.0

GameWindow {
  Scene {
    
    SimpleButton {
      anchors.centerIn: parent
      text: "Press Me"
      onClicked: {
        console.debug("Wow you pressed me!")
      }
    }
  }
}

Learn More

Monetize & Analyze

With V-Play, you can use many 3rd party services for ads, in-app purchases, analytics and more, with just a few lines of code. All of these plugins work cross-platform, which allows you to maintain a single code base.

Learn More

Level Editor

The LevelEditor can be used during development to create and modify levels for your game, which you can then bundle in your final publishing build. Additionally, you can also integrate the in-game level editor to your published game and let your gamers create new levels.

Learn More Video

Card Game like UNO, Hearthstone or Poker

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/OneCard/OneCard.pro

Match-3 like Candy Crush Saga

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/JuicySquash/JuicySquash.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/JuicySquashAdvanced/JuicySquashAdvanced.pro

Puzzle like 2048 or Threes!

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/2048/2048.pro

Casino like Big Win Slots

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/FlaskOfRum/FlaskOfRum.pro

Side Scroller like Jetpack Joyride or Flappy Bird

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/FlappyBird/FlappyBird.pro

Tower Defense like Castle Defense or Bloons TD

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/Squaby/Squaby.pro

Falldown & Jump like Doodle Jump or Mega Jump

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/ChickenOutbreak/ChickenOutbreak.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/ChickenOutbreak2/ChickenOutbreak2.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/DoodleJump/DoodleJump.pro

Platformer like Super Mario or Lep's World

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/Platformer/Platformer.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/PlatformerWithLevelEditor/PlatformerWithLevelEditor.pro

Action like Angry Birds, Fruit Ninja, Cut the Rope

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/StackTheBoxWithCommunityEditor/StackTheBoxWithCommunityEditor.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/BalloonPop/BalloonPop.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/CarChallenge/CarChallenge.pro

Arcade like Arkanoid or Space Invaders

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/demos/ZombieBreak/ZombieBreak.pro

Community like Super Mario Maker or Minecraft

We got a demo game for you!

The V-Play SDK includes an open-source demo for this game genre. You can use its source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/examples/Squaby/Squaby.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/StackTheBoxWithCommunityEditor/StackTheBoxWithCommunityEditor.pro

<Path to V-PlaySDK>/Examples/V-Play/demos/PlatformerWithLevelEditor/PlatformerWithLevelEditor.pro

Any other Idea? let us know how we can help you

You are looking for another demo?

The V-Play SDK includes many open-source demos for different game genres. You can use their source code and build your game in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

If you do not find your game genre in this list and wonder if V-Play is the right choice, just contact us, we are happy to help!

Contact Us

App Development
Better Apps, Less Effort

Develop feature-rich, cross-platform mobile apps from a single code base.

V-Play apps look, feel and perform exactly like native iOS, Android and Desktop apps. With less code & much faster development time.

Learn More Highlights Video

V-Play ranked #1 at research2guidance cross-platform tool benchmarking 2014 by 2188 developers comparing 40 leading tools.

Save Time, Code & Money

Save up to 90% source code with V-Play, compared to frameworks like Xamarin, Titanium, React Native and others.

Learn More

QML & JavaScript

Qt Meta Language is a highly intuitive reactive language, which is super easy to learn, yet it's extremely powerful and flexible. Mix it with JavaScript to create awesome stuff, with just a few lines of code. QML also allows you to easily create smooth and complex animations.

import QtQuick 2.0
import VPlayApps 2.0

App {
  Page {
    
    AppButton {
      anchors.centerIn: parent
      text: "Press Me"
      onClicked: {
        console.debug("Wow you pressed me!")
      }
    }
  }
}

Learn More

Monetize & Analyze

With V-Play, you can use many 3rd party services for ads, in-app purchases, analytics and more, with just a few lines of code. All of these plugins work cross-platform, which allows you to maintain a single code base.

Learn More

Native Sensors & More

V-Play Apps harness the power of Qt, the leading cross-platform development framework used by over 1,000,000 developers.

This gives your access to native device features like sensors, camera, file system as well as multimedia, networking, localization and much more.

Learn More

Responsive Design

V-Play has built in responsive design capabilities, you can target phones and tablets with the same source code.

Learn More

Highly Extensible

You have existing JavaScript, C++ or native code? You want to add any 3rd party SDK that we do not offer already?

No worries, you can add any JS, C++, Java or Objective-C code to your project.

Learn More

Component Showcase App shows the most important V-Play features and components

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/showcase/Showcase.pro

Qt World Summit Conference App a full-featured conference management app made by V-Play

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/qtws2016/QtWS2016.pro

Twitter App how to build layouts like in the official Twitter app for iOS and Android

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/twitter/Twitter.pro

Maps App displays free bikes or boxes at bike stations for Vienna's bike sharing service Citybike Wien

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/maps/Maps.pro

Messaging App demonstrates how to create the UI of a Facebook Messenger like app

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/messaging/Messaging.pro

Weather App how to include powerful animations into your user interface

We got a demo app for you!

The V-Play SDK includes an open-source demo for this app type. You can use its source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play.

<Path to V-PlaySDK>/Examples/V-Play/appdemos/waether/Weather.pro

Any other Idea? let us know how we can help you

You are looking for another app demo?

The V-Play SDK includes many open-source demos for different app types. You can use their source code and build your app in record time. After installing V-Play, you can simply open the .pro file with Qt Creator, the development environment used for V-Play..

If you do not find your app type in this list and wonder if V-Play is the right choice, just contact us, we are happy to help!

Contact Us