text:
Published by Addison-Wesley Professional
ISBN-13: 978-0-321-69942-8 One of the most important elements of a game is the game loop. It is the heartbeat that keeps the game ticking. Every game has a series of tasks it must perform on a regular basis, as follows:
- Update the game state
- Update the position of game entities
- Update the AI of game entities
- Process user input, such as touches or the accelerometer
- Play background music and sounds This may sound like a lot, especially for a complex game that has many game elements, and it can take some time to process each of these stages. For this reason, the game loop not only makes sure that these steps take place, but it also ensures that the game runs at a constant speed.
This chapter shows you how to build the game loop for Sir Lamorak's Quest. We take the OpenGL ES template app created in Chapter 3, "The Journey Begins," and make changes that implement the game loop and the general structure needed to easily extend the game in later chapters.
Timing Is Everything
Let's start out by looking at some pseudocode for a simple game loop, as shown in Listing 4.1.
Listing 4.1??A Simple Game Loop
BOOL gameRunning = true; while(gameRunning) { updateGame; renderGame; } This example game loop will continuously update the game and render to the screen until gameRunning is false.
Although this code does work, it has a serious flaw: It does not take time into account. On slower hardware, the game runs slowly, and on fast hardware, the game runs faster. If a game runs too fast on fast hardware and too slow on slow hardware, your user's experience with the game will be disappointing. There will either be too much lag in the game play, or the user won't be able to keep up with what's going on in the game.
This is why timing needs to be handled within your game loop. This was not such a problem for games written back in the 1980s, because the speed of the hardware on which games were written was known, and games would only run on specific hardware for which they were designed. Today, it is possible to run a game on many different types of hardware, as is the case with the iPhone. For example, the following list sorts the devices (from slowest to fastest) that run the iOS:
- iPhone (first generation)
- iPod Touch 1G
- iPhone 3G
- iPod Touch 2G
- iPhone 3GS/iPod Touch 3G
- iPad/iPhone 4 As a game developer, you need to make sure that the speed of your game is consistent. It's not a good idea to have a game on the iPhone 3GS running so fast that the player can't keep up with the action, or so slow on an iPhone 3G that the player can make a cup of tea before the next game frame is rendered.
There are two common components used to measure a game loop's speed, as follows:
- Frames Per Second (FPS):FPS relates to how many times a game scene is rendered to the screen per second. The maximum for the iPhone is 60 FPS, as that is the screen's maximum refresh rate. In Listing 4.1, this relates to how many times the renderGame method is called.
- Update speed:This is the frequency at which the game entities are updated. In Listing 4.1, this relates to how many times the updateGame method is called.
Collision Detection
Timing is important for a number of reasons--not only the overall game experience, but, maybe more importantly, for functions such as collision detection. Identifying when objects in your game collide with each other is really important and is a basic game mechanic we need to use. In Sir Lamorak's Quest, having the player able to walk through walls is not a great idea, and having the player's sword pass through baddies with no effect is going to frustrate the player and keep them from playing the game.
Collision detection is normally done as part of the game's update function. Each entity has their AI and position updated as play progresses. Those positions are checked to see if it has collided with anything. For example, Sir Lamorak could walk into (or collide with) a wall, or a ghost could collide with an axe. As you can imagine, the distance a game entity moves between each of these checks is important. If the entity moves too far during each game update, it may pass through another object before the next check for a collision.
Having entities move at a constant speed during each game update can help to reduce the chances of a collision being missed. There is, however, always a chance that a small, fast-moving entity could pass through another object or entity unless collision checks are implemented that don't rely solely on an entities current position, but also its projected path. Collision detection is discussed in greater detail in Chapter 15, "Collision Detection," which is where we implement it into the game.
The Game Loop
The game loop is a key, if not the key, element in a game. I spent considerable time tweaking the game loop for Sir Lamorak's Quest, and it was something that I revisited a number of times, even after I thought I had what was needed.
There are so many different approaches to game loops. These range from the extremely simple closed loops you saw earlier in Listing 4.1, up to multithreaded loops that handle things such as path finding and complex AI on different threads. I found that I actually started off with the very simple approach that then became more complex as the game developed (and as I ran into issues).
We will not review some of the different game loops that I tried through the development of Sir Lamorak's Quest. Instead, we'll focus on the game loop used in the game, rather than diving down some rabbit hole we'll never end up using.
The easiest type of game loop is called a frame-based loop. This is where the game is updated and rendered once per game cycle, and is the result of the simple game loop shown in Listing 4.1. It is quick and easy to implement, which was great when I first started the game, but it does have issues.
The first of these issues is that the speed of the game is directly linked to the frame rate of the device on which the game is running--the faster the hardware, the faster the game; the slower the hardware, the slower the game. Although we are writing a game for a very small family of devices, there are differences in speed between them that this approach would highlight.
Figure 4.1 shows how frames are rendered more quickly on fast hardware and more slowly on slower hardware. I suppose that could be obvious, but it can often be overlooked when you start writing games, leaving the player open to a variable playing experience. Also remember that each of these frames is performing a single render and update cycle.
Figure 4.1: Entity following a curved path on slow and fast hardware. A time-based variable interval loop is similar to the frame-based approach, but it also calculates the elapsed time. This calculation is used to work out the milliseconds (delta) that have passed since the last game cycle (frame). This delta value is used during the update element of the game loop, allowing entities to move at a consistent speed regardless of the hardware's speed.
For example, if you wanted an entity to move at 1 unit per second, you would use the following calculation:
position.x += 1.0f * delta; Although this gets over the problem of the game running at different speeds based on the speed of the hardware (and therefore the frame rate), it introduces other problems. While most of the time the delta could be relatively small and constant, it doesn't take much to upset things, causing the delta value to increase with some very unwanted side effects. For example, if a text message arrived on the iPhone while the user was playing, it could cause the game's frame rate to slow down. You could also see significantly larger delta values causing problems with elements, such as collision detection.
Each game cycle causes an entity in Figure 4.2 to move around the arc. As you can see in the diagram, with small deltas, the entity eventually hits the object and the necessary action can be taken.
Figure 4.2: Frames using a small delta value. However, if the delta value were increased, the situation shown in Figure 4.3 could arise. Here, the entity is moving at a constant distance, but the reduced frame rates (and, therefore, increased delta) has caused what should have been a collision with the object to be missed.
Figure 4.3: Frames using a large delta. Don't worry--there is a reasonably easy solution, and that is to use a time-based, fixed interval system.
Time-Based, Fixed Interval
The key to this method is that the game's state is updated a variable number of times per game cycle using a fixed interval. This provides a constant game speed, as did the time-based variable interval method, but it removes issues such as the collision problem described in the previous section.
You'll remember that the previous methods tied the game's update to the number of frames. This time, the game's state could be updated more times than it is rendered, as shown in Figure 4.4. We are still passing a delta value to the game entities, but it's a fixed value that is pre-calculated rather than the variable delta that was being used before (thus, the term fixed interval).
Figure 4.4: Variable numbers of updates per frame with a single render. This system causes the number of game updates to be fewer when the frame rate is high, but it also increases the number of game updates when the frame rate is low. This increase in the number of game updates when the game slows down means that the distance each frame travels is constant. The benefit is that you are not losing the chance to spot a collision by jumping a large amount in a single frame.
Getting Started
The project that accompanies this chapter already contains the game loop and other changes we are going to run through in the remainder of this chapter. You should now open the project CH04_SLQTSOR. We run through the changes and additions to the project since Chapter 3.
Note - This project should be compiled against version 3.1 or higher of the iPhone SDK. The CADisplayLink function used in this example is only available in version 3.1 of the iPhone SDK. If you compile this project using iPhone SDK 3.0 or less, it still works, but you will need to use NSTimer rather than CADisplayLink. Using iPhone SDK 3.0 or less will also generate warnings, as shown in Figure 4.5.
Figure 4.5: Errors generated in EAGLView.m when compiling against iPhone SDK version 3.0 or lower. When you open the CH04_SLQTSOR project in Xcode, you see a number of new groups and classes in the Groups & Files pane on the left that have been added to the project since Chapter 3, including the following:
- Group Headers: This group holds global header files that are used throughout the project.
- Abstract Classes: Any abstract classes that are created are kept in this group. In CH04_SLQTSOR, it contains the AbstractScene class.
- Game Controller: The game controller is a singleton class used to control the state of the game. We will see how this class is used and built later in this chapter.
- Game Scenes: Each game scene we create (for example, the main menu or main game) will have its own class. These classes are kept together in this group. Let's start with the changes made to the EAGLView class.
Inside the EAGLView Class
The first change to EAGLView.h, inside the Classes group, is the addition of a forward declaration for the GameController class. This class does not exist yet, but we will create it soon:
@class GameController; Inside the interface declaration, the following ivars have been added:
CFTimeInterval lastTime; GameController *sharedGameController; These instance variables will be used to store the last time the game loop ran and point to an instance of the GameController class, which we create later. No more changes are needed to the header file. Save your changes, and let's move on to the implementation file.
Inside the EAGLView.m File
In Xcode, select EAGLView.m and move to the initWithCoder: method. The changes in here center around the creation of the renderer instance. In the previous version, an instance of ES2Renderer was created. If this failed, an instance of ES1Renderer was created instead. We are only going to use OpenGL ES 1.1 in Sir Lamorak's Quest, so we don't need to bother with ES2Renderer.
Because we are not using ES2Renderer, the ES2Renderer.h and .m files have been removed from the project. The Shaders group and its contents have also been removed.
There is also an extra line that has been added to the end of the initWithCoder method, as shown here:
sharedGameController = [GameController sharedGameController]; The next change is the actual code for the game loop. We are going to have EAGLView running the game loop and delegating the rendering and state updates to the ES1Renderer instance called renderer. Just beneath the initWithCoder: method, you can see the game loop[sup]1[/sup] code, as shown in Listing 4.2.
Listing 4.2??EAGLView gameLoop: Method
#define MAXIMUM_FRAME_RATE 45 #define MINIMUM_FRAME_RATE 15 #define UPDATE_INTERVAL (1.0 / MAXIMUM_FRAME_RATE) #define MAX_CYCLES_PER_FRAME (MAXIMUM_FRAME_RATE / MINIMUM_FRAME_RATE) - (void)gameLoop { static double lastFrameTime = 0.0f; static double cyclesLeftOver = 0.0f; double currentTime; double updateIterations; currentTime = CACurrentMediaTime(); updateIterations = ((currentTime - lastFrameTime) + cyclesLeftOver); if(updateIterations > (MAX_CYCLES_PER_FRAME * UPDATE_INTERVAL)) updateIterations = (MAX_CYCLES_PER_FRAME * UPDATE_INTERVAL); while (updateIterations >= UPDATE_INTERVAL) { updateIterations -= UPDATE_INTERVAL; [sharedGameController updateCurrentSceneWithDelta:UPDATE_INTERVAL]; } cyclesLeftOver = updateIterations; lastFrameTime = currentTime; [self drawView:nil]; } When the game loop is called from either CADisplayLink or NSTimer, it first obtains the current time using CACurrentMediaTime(). This should be used instead of CFAbsoluteTimeGetCurrent() because CACurrentMediaTime() is synced with the time on the mobile network if you are using an iPhone. Changes to the time on the network would cause hiccups in game play, so Apple recommends that you use CACurrentMediaTime().
Next, we calculate the number of updates that should be carried out during this frame and then cap the number of update cycles so we can meet the minimum frame rate.
The MAXIMUM_FRAME_RATE constant determines the frequency of update cycles, and MINIMUM_FRAME_RATE is used to constrain the number of update cycles per frame.
Capping the number of updates per frame causes the game to slow down should the hardware slow down while running a background task. When the background task has finished running, the game returns to normal speed.
Using a variable time-based approach in this situation would cause the game to skip updates with a larger delta value. The approach to use depends on the game being implemented, but skipping a large number of updates while the player has no ability to provide input can cause issues, such as the player walking into a baddie without the chance of walking around or attacking them.
I tried to come up with a scientific approach to calculating the maximum and minimum frame rate values, but in the end, it really was simple trial and error. As Sir Lamorak's Quest developed and the scenes became more complex, I ended up tweaking these values to get the responsiveness I wanted while making sure the CPU wasn't overloaded.
The next while loop then performs as many updates as are necessary based on updateIterations calculated earlier. updateIterations is not an actual count of the updates to be done, but an interval value that we use later:
while (updateIterations >= UPDATE_INTERVAL) { updateIterations -= UPDATE_INTERVAL; [sharedGameController updateCurrentSceneWithDelta:UPDATE_INTERVAL]; } This loops around reducing the interval in updateIterations by the fixed UPDATE_INTERVAL value and updates the games state. Once updateIterations is less than the UPDATE_INTERVAL, the loop finishes, and we load any fractions of an update left in updateIterations into cyclesLeftOver. This means we don't lose fractions of an update cycle that we can accumulate and use later.
With all the updates completed, we then render the scene:
[self drawView:nil]; The CADisplayLink or NSTimer now calls the game loop until the player quits or the battery runs out (which it could do, given how much they will be enjoying the game!).
This is not a complex game loop, although it may take a while to get your head around the calculations being done. I found that moving to this game loop reduced the CPU usage on Sir Lamorak's Quest quite significantly and really smoothed out the game.
The final changes to EAGLView are within the startAnimation method. To get things ready for the first time we run through the gameLoop, we need to set the lastTime ivar. Because the gameLoop will not be called until the animation has started, we need to add the following line to the startAnimation method beneath the animating = TRUE statement:
lastTime = CFAbsoluteTimeGetCurrent(); The selectors used when setting up the CADisplayLink and NSTimer also need to be changed. The new selector name should be gameLoop instead of drawView.
Having finished with the changes inside EAGLView, we need to check out the changes to ES1Renderer. This class is responsible for setting up the OpenGL ES context and buffers, as noted in Chapter 3. However, we are going to extend ES1Renderer slightly so it sets up the OpenGL ES state we need for the game and renders the currently active scene.
ES1Renderer Class
When you look inside the ES1Renderer.h file, you see a forward declaration to the GameController class, which is in the next section, and an ivar that points to the GameController instance. The rest of the header file is unchanged.
In Xcode, open the ES1Renderer.m file. The GameController.h file is imported, followed by an interface declaration, as shown here:
@interface ES1Renderer (Private) // Initialize OpenGL - (void)initOpenGL; @end This interface declaration specifies a category of Private and is being used to define a method that is internal to this implementation. (I normally create an interface declaration such as this inside my implementations so I can then declare ivars and methods that are going to be private to this class.) There is only one method declared, initOpenGL, which is responsible for setting up the OpenGL ES states when an instance of this class is created.
Although Objective-C doesn't officially support private methods or ivars, this is a common approach used to define methods and ivars that should be treated as private.
The next change comes at the end of the init method:
sharedGameController = [GameController sharedGameController]; This is pointing the sharedGameController ivar to an instance of the GameController class. GameController is implemented as a singleton. This is a design pattern, meaning there can be only one instance of the class. It exposes a class method called sharedGameController that returns a reference to an instance of GameController. You don't have to worry if an instance has already been created or not because that is all taken care of inside the GameController class itself.
The next change is within the render method, shown in Listing 4.3. This is where the template initially inserted drawing code for moving the colored square. We will see the code used to draw the square again, but it's not going to be in this method. If you recall, this method is called by the game loop and needs to call the render code for the currently active scene.
Listing 4.3??EAGLView render Method
- (void) render { glClear(GL_COLOR_BUFFER_BIT); [sharedGameController renderCurrentScene]; [context presentRenderbuffer:GL_RENDERBUFFER_OES]; } First of all, glClear(GL_COLOR_BUFFER_BIT) clears the color buffer and then clears the screen, making it ready for the next scene to be rendered. For the rendering, the game controller is asked to render the currently active scene. This is how the render message is passed from the game loop to ES1Renderer, and then onto the game controller and eventually the render method inside the currently active game scene. Figure 4.6 shows how a game scene fits into the other classes we are reviewing.
Figure 4.6: Class relationships. The last line in this method presents the render buffer to the screen. If you remember, this is where the image that has been built in the render buffer by the OpenGL ES drawing commands is actually displayed on the screen.
Having looked at the changes to the render method, we'll move on to the resizeFromLayer: method. If you recall, the resizeFromLayer: method was responsible for completing the OpenGL ES configuration by assigning the renderbuffer created to the context (EAGLContext) for storage of the rendered image. It also populated the backingWidth and backingHeight ivars with the dimensions of the renderbuffer.
The following line of code has been added to this method that calls the initOpenGL method:
[self initOpenGL]; If this looks familiar, that's because this method was placed inside the interface declaration (described earlier) as a private category. As the resizeFromLayer method assigns the render buffer to the context and finishes up the core setup of OpenGL ES, it makes sense to place this OpenGL ES configuration activity in this method so we can set up the different OpenGL ES states needed for the game.
Now move to the bottom of the implementation and look at the initOpenGL method. This method sets up a number of key OpenGL ES states that we will be using throughout the game.
If you move to the bottom of the implementation, you can see the following implementation declaration:
@implementation ES1Renderer (Private) You can tell this is related to the interface declaration at the top of the file because it's using the same category name in brackets. There is only one method declared in this implementation: initOpenGL.
At the start of the method, a message is output to the log using the SLQLOG macro defined in the Global.h header file. The next two lines should be familiar, as they were covered in Chapter 3. We are switching to the GL_PROJECTION matrix and then loading the identity matrix, which resets any transformations that have been made to that matrix.
The next line is new and something we have not seen before:
glOrthof(0, backingWidth, 0, backingHeight, -1, 1); This command describes a transformation that produces an orthographic or parallel projection. We have set the matrix mode to GL_PROJECTION, so this command will perform a transformation on the projection matrix. The previous function sets up an orthographic projection--in other words, a projection that does not involve perspective (it's just a flat image).
Note - I could go on now about orthographic and perspective projection, but I won't. It's enough to know for our purposes that glOrthof is defining the clipping planes for width, height, and depth. This has the effect of making a single OpenGL ES unit equal to a single pixel in this implementation because we are using the width and height of the screen as the parameters.As mentioned earlier, OpenGL ES uses its own units (that is, a single OpenGL ES unit by default does not equal a single pixel). This gives you a great deal of flexibility, as you can define how things scale as they're rendered to the screen. For Sir Lamorak's Quest, we don't need anything that complex, so the previous function--which results in a unit equal to a pixel--is all we need.
Configuring the View Port
It is not common to make many changes to the GL_PROJECTION matrix apart from when initially setting up the projection.
As we are setting up the projection side of things, this is a good place to also configure the view port:
glViewport(0, 0, backingWidth , backingHeight); The Viewport function specifies the dimensions and the orientation of the 2D window into which we are rendering. The first two parameters specify the coordinates of the bottom-left corner, followed by the width and height of the window in pixels. For the width and height, we are using the dimensions from the renderbuffer.
With the projections side set up, we then move onto setting up the GL_MODELVIEW matrix. This is the matrix that normally gets the most attention as it handles the transformations applied to the game's models or sprites, such as rotation, scaling, and translation. As noted in Chapter 3, once the matrix mode has been switched to GL_MODELVIEW, the identity matrix is loaded so it can apply the transformations.
glMatrixMode(GL_MODELVIEW); glLoadIdentity(); Next, we set the color to be used when we clear the screen and also disable depth testing. Because we are working in 2D and not using the concept of depth (that is, the z-axis), we don't need OpenGL ES to apply any tests to pixels to see if they are in front of or behind other pixels. Disabling depth testing in 2D games can really help improve performance on the iPhone.
Not using the depth buffer means that we have to manage z-indexing ourselves (that is, the scene needs to be rendered from back to front so objects at the back of the scene appear behind those at the front):
glClearColor(0.0f, 0.0f, 0.0f, 1.0f); glDisable(GL_DEPTH_TEST); We finish up the OpenGL ES configuration by enabling more OpenGL ES functions. You may remember that OpenGL ES is a state machine. You enable or disable a specific state, and it stays that way until you change it back. We have done exactly that when disabling depth testing, which now stays disabled until we explicitly enable it again:
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); The preceding states are used to tell OpenGL ES that we are going to be providing an array of vertices and an array of colors to be used when rendering to the screen. Other client states will be described and used later in Chapter 5, "Image Rendering."
That's it for the configuration of OpenGL ES. A lot of the OpenGL ES configuration should have looked familiar to you. A number of the functions in there were present in the render code from the OpenGL ES template. In the template, the states were set each time we rendered. Although this is fine, it isn't necessary to do that unless you are using state changes to achieve specific effects.
Tip - Keep the number of state changes being made within the game loop to a minimum, as some, such as switching textures, can be expensive in terms of performance. Is really is worth creating your own state machine that stores the states set in OpenGL ES. These can then be checked locally to see if they need to change i.e. there is no point in setting them if the values are the same.That completes all the changes that have been made to the ES1Renderer class. We have added a pointer to the game controller, so rendering can be delegated to an instance of that class. We have also added some core OpenGL ES configuration to the class as well, making it responsible for all OpenGL ES setup that gives us a single place to go when we need to change that setup.
Game Scenes and the Game Controller
Having looked at the changes that were needed within EAGLView and ES1Renderer, we need to now look at the game controller and game scenes. Because we have the game loop in place, we need to introduce new classes that will handle the introduction of other game elements. The game elements I'm talking about are the different scenes used in Sir Lamorak's Quest, such as the following:
- The main menu: This is where players are taken when they first launch Sir Lamorak's Quest. The main menu provides the player with options to change the game settings, view credits, or start the game.
- The game itself: This is where the (game) action takes place. The idea is that a game scene is responsible for its own rendering and game logic updates. This helps to break up the game into manageable chunks. I've seen entire games containing multiple scenes coded in a single class. For me, this is just too confusing, and creating a separate class for each scene just seemed logical.
In addition to the game scenes, we need to create a game controller. We have already seen the game controller mentioned in the EAGLView and ES1Renderer classes, so let's run through what it does.
Creating the Game Controller
Figure 4.6 shows the relationship between the classes (that is, EAGLView, ES1Renderer, and GameController), and the game scene classes.
The GameController Class
If we are going to have a number of scenes, and each scene is going to be responsible for its rendering and logic, we are going to need a simple way of managing these scenes and identifying which scene is active. Inside the game loop, we will be calling the game update and render methods on a regular basis. And because there will be multiple scenes, we need to know which of those scenes is currently active so the update and render methods are called on the right one. Remember from looking at EAGLView that inside the game loop, we were using the following code to update the game:
[sharedGameController updateCurrentSceneWithDelta:UPDATE_INTERVAL]; This line calls a method inside an instance of GameController. We are not telling the game controller anything about the scene that should be rendered as are expecting the GameController to already know.
Note - One important aspect of the game controller is that it is a singleton class. We don't want to have multiple game controllers within a single game, each with their own view of the game's state, current scene, and so forth.Inside the Game Controller group, you find the GameController.h and GameController.m files. Open GameController.h and we'll run through it.
Although it may sound complicated to make a class a singleton, it is well-documented within Apple's Objective-C documentation. To make this even easier, we use the SynthesizeSingleton macro created by Matt Gallagher.[sup]2[/sup] Matt's macro enables you to turn a class into a singleton class simply by adding a line of code to your header and another to your implementation.
At the top of the GameController.h file, add the following import statement to bring in this macro:
#import "SynthesizeSingleton.h"Note - I won't run through how the macro works, because all you need can be found on Matt's website. For now, just download the macro from his site and import the SynthesizeSingleton.h file into the project.Next is another forward declaration to AbstractScene, which is a class we will be looking at very shortly. This is followed by an interface declaration that shows this class is inheriting from NSObject and implements the UIAccelerometerDelegate protocol:
@interface GameController : NSObject UIAccelerometerDelegate is used to define this class as the delegate for accelerometer events, and it supports the methods necessary to handle events from the accelerometer.
Within the interface declaration, we have just a couple of ivars to add. The first is as follows:
NSDictionary *gameScenes; This dictionary will hold all the game scenes in Sir Lamorak's Quest. I decided to use a dictionary because it allows me to associate a key to each scene, making it easier to retrieve a particular scene:
AbstractScene *currentScene; As you will see later, AbstractScene is an abstract class used to store the ivars and methods common between the different game scenes. Abstract classes don't get used to create class instances themselves. Instead, they are inherited by other classes that override methods which provide class-specific logic.
Note - Objective-C does not enforce abstract classes in the same way as Java or C++. It's really up to the developer to understand that the class is meant to be abstract, and therefore subclassed--thus placing Abstract at the beginning of the class name.This works well for our game scenes, as each scene will have its own logic and rendering code, but it will have ivars and methods, such as updateSceneWithDelta and renderScene, that all scenes need to have. We run through the AbstractScene class in a moment.
After the interface declaration, the next step is to create a single property for the currentScene ivar. This makes it so currentScene can be both read and updated from other classes.
Creating the Singleton
So far, this looks just like any other class. Now let's add two extra lines of code to make this a singleton class:
+ (GameController *)sharedGameController; This is a class method identified by the + at the beginning of the method declaration. Because this is going to be a singleton class, this is important. We use this method to get a pointer to the one and only instance of this class that will exist in the code, which is why the return type from this method is GameController.
Next, we have two more method declarations; the first is as follows:
- (void)updateCurrentSceneWithDelta:(float)aDelta; This method is responsible for asking the current scene to update its logic passing in the delta calculated within the game loop. The next method is responsible for asking the current scene to render:
- (void)renderCurrentScene; Now that the header is complete, open GameController.m so we can examine the implementation.
Inside GameController.m
To start, you can see that the implementation is importing a number of header files:
#import "GameController.h" #import "GameScene.h" #import "Common.h" GameScene is a new class; it inherits from the AbstractScene class. Because we will be initializing the scenes for our game in this class, each scene we created will need to be imported. Common.h just contains the DEBUG constant at the moment, but more will be added later.
Next, an interface is declared with a category of Private. This just notes that the methods defined in this interface are private and should not be called externally to the class. Objective-C does not enforce this, although there really is no concept of a private method or ivar in Objective-C:
@interface GameController (Private) - (void)initGame; @end As you can see from this code, we are using initGame to initialize game scenes.
Next is the implementation declaration for GameController. This is a standard declaration followed by a synthesize statement for currentScene, so the necessary getters and setters are created. The next line is added to turn this class into a singleton class:
SYNTHESIZE_SINGLETON_FOR_CLASS(GameController); The macro defined within the SynthesizeSingleton.h file adds all the code necessary to convert a class into a singleton. If you look inside the SynthesizeSingleton.h file, you see the code that gets inserted into the class when the project is compiled.
Notice that this class also has an init method. The init is used when the initial instance of this class is created. The formal approach to getting an instance of this class is to call the method sharedGameController, as we defined in the header file. This returns a pointer to an instance of the class. If it's the first time that method has been called, it creates a new instance of this class and the init method is called.
Tip - The name of the class method defined in the header is important; it should be shared, followed by the name of the class (for example, sharedClassName). The class name is passed to the macro in the implementation, and it is used to create the sharedClassName method.If an instance already exists, a pointer to that current instance will be returned instead, thus only ever allowing a single instance of this class to exist. If you tried to create an instance of this class using alloc and init, you will again be given a pointer to the class that already exists. The code introduced by the synthesize macro will stop a second instance from being created.
initGame is called within the init method and sets up the dictionary of scenes, as well as the currentScene.
If you move to the bottom of the file, you see the implementation for the private methods.
Inside the initGame method, we are writing a message to the console, before moving on to set up the dictionary. It's good practice to make sure that all these debug messages are removed from your code before you create a release version. The next line creates a new instance of one of the game scenes, called GameScene:
AbstractScene *scene = [[GameScene alloc] init]; As you can see, GameScene inherits from AbstractScene. This means we can define *scene as that type. This enables you to treat all game scenes as an AbstractScene. If a game scene implements its own methods or properties that we need to access, we can cast from AbstractScene to the actual class the scene is an instance of, as you will see later.
Now that we have an instance of GameScene, we can add it to the dictionary:
[gameScenes setValue:scene forKey:@"game"]; This creates an entry in the dictionary that points to the scene instance and gives it a key of game. Notice that the next line releases scene:
[scene release]; Adding scene to the dictionary increases its retain count by one, so releasing it now reduces its retain count from two to one. When the dictionary is released or the object is asked to release again, the retain count on the object will drop to zero and the object's dealloc method will be called. If we didn't ask scene to release after adding it to the dictionary, it would not be released from memory when dictionary was released without another release call, which we may not realize we need to do. This is a standard approach for managing memory in Objective-C.
The last action of the method is to set the currentScene. This is a simple lookup in the gameScenes dictionary for the key game, which we used when adding the game scene to the dictionary. As additional game scenes are added later, we will add them to the dictionary with the following method:
currentScene = [gameScenes objectForKey:@"game"]; We only have a few more methods left to run through in the GameController class. Next up is the updateCurrentSceneWithDelta: method, shown here:
- (void)updateCurrentSceneWithDelta:(float)aDelta { [currentScene updateSceneWithDelta:aDelta]; } This takes the delta value calculated within the game loop and calls the updateSceneWithDelta method inside the currentScene. Remember that we have set the currentScene to point to an object in the gameScene dictionary. These objects should all inherit from AbstractScene and therefore support the update method.
The same approach is taken with the render method, shown here:
-(void)renderCurrentScene { [currentScene renderScene]; } The final method to review is accelerometer:didAccelerate, shown here:
- (void)accelerometer:(UIAccelerometer *)accelerometer didAcceler- ate:(UIAcceleration *)acceleration { } This delegate method needs to be implemented because the class uses the UIAccelerometerDelegate protocol. When the accelerometer is switched on, this method is passed UIAcceleration objects that can be used to find out how the iPhone is being moved. This can then be used to perform actions or control the player inside the game. We aren't using this method in Sir Lamorak's Quest, but it's useful to understand how this information could be obtained. More information on user input can be found in Chapter 12, "User Input."
AbstractScene Class
AbstractScene was mentioned earlier, and as the name implies, it is an abstract class. All the game scenes we need to create will inherit from this class.
Open AbstractScene.h in the Abstract Classes group, and we'll take a look.
The header starts off by importing the OpenGL ES header files. This allows any class that inherits from AbstractScene.h to access those headers as well. The class itself inherits from NSObject, which means it can support operations such as alloc and init.
A number of ivars are defined within the interface declaration. Again, the ivars will be available to all classes that inherit from this class. The idea is to place useful and reusable ivars in this abstract class so they can be used by other game scenes. The ivars you will find here include the following:
- screenBounds: Stores the dimensions of the screen as a CGRect.
- sceneState: Stores the state of the scene. Later, we create a number of different scene states that can be used to track what a scene is doing (for example, transitioning in, transitioning out, idle, and running).
- sceneAlpha: Stores the alpha value to be used when rendering to the screen. Being able to fade everything in and out would be cool, so storing an overall sceneAlpha value that we can use when rendering enables us to do this.
- nextSceneKey: A string that holds the key to the next scene. If the GameController receives a request to transition out, the next scene specified in this ivar will become the current scene.
- sceneFadeSpeed: Stores the speed at which the scene fades in and out. After the interface declaration, two more properties are defined, as follows:
@property (nonatomic, assign) uint sceneState; @property (nonatomic, assign) GLfloat sceneAlpha; These simply provide getter and setter access to the sceneState and sceneAlpha ivars.
Next, a number of methods are defined to support the game scenes, including the update and render methods we have already discussed:
- (void)updateSceneWithDelta:(float)aDelta; - (void)renderScene; There are also a few new methods, too. The first relates to touch events. The EAGLView class responds to touch events as it inherits from UIView, and these need to be passed to the currently active game scene. The active scene uses this touch information to work out what the player is doing. The following touch methods are used to accept the touch information from EAGLView and allow the game scene to act upon it:
- (void)touchesBegan:(NSSet*)touches withEvent:(UIEvent*)event view:(UIView*)aView; - (void)touchesMoved:(NSSet*)touches withEvent:(UIEvent*)event view:(UIView*)aView; - (void)touchesEnded:(NSSet*)touches withEvent:(UIEvent*)event view:(UIView*)aView; - (void)touchesCancelled:(NSSet*)touches withEvent:(UIEvent*)event view:(UIView*)aView; The next method declared is similar to the touch methods. Just as touches are fed to each game scene, accelerometer events also need to be fed down in the same way. We have already seen that GameController is the target for accelerometer events; therefore, GameController needs to pass down accelerometer event information to the current game scene:
- (void)updateWithAccelerometer:(UIAcceleration*)aAcceleration; That's it for the header file. Now let's move to the implementation file by opening AbstractScene.m.
You may be surprised by what you find in the implementation file. When I said earlier that the abstract class doesn't do anything, I really meant it. Apart from setting up the synthesizers for the two properties we declared, it just contains empty methods.
The idea is that the game scene that inherits from this class will override these methods to provide the real functionality.
That being the case, let's jump straight to the final class to review in this chapter: the GameScene class.
GameScene Class
The GameScene class is responsible for implementing the game logic and rendering code for the scene. As described earlier, a game scene can be anything from the main menu to the actual game. Each scene is responsible for how it reacts to user input and what it displays onscreen.
For the moment, we have created a single game scene that we will use for testing the structure of Sir Lamorak's Quest. You find the GameScene.h file inside the Game Scenes group in Xcode. When you open this file, you see that all we have defined is an ivar, called transY. We have no need to define anything else at the moment because the methods were defined within the AbstractScene class we are inheriting from.
Tip - When you inherit in this way, you need to make sure the header of the class you are inheriting from is imported in the interface declaration file (the .h file).Because there is not much happening in the header file, open the GameScene.m file. This is where the magic takes place. All the logic for rendering something to the screen can be found in the GameScene.m file.
To keep things simple at this stage, we are simply implementing a moving box, just like you saw in Chapter 3 (refer to Figure 3.4). You may recall from the previous chapter that the logic to move the box, and the box rendering code itself, were all held within the render method. This has now been split up inside GameScene.
The updateSceneWithDelta method is called a variable number of times within the game loop. Within that method, we have defined the transY ivar, which increases within the updateSceneWithDelta method:
- (void)updateSceneWithDelta:(float)aDelta { transY += 0.075f; } When the updating has finished, the game loop will render the scene. This render request is passed to the GameController, which then asks the currently active scene to render. That request ends with the next method, renderScene.
The renderScene method is where the code to actually render something to the screen is held. As mentioned earlier, we are just mimicking the moving box example from the previous chapter, so the first declaration within this method is to set up the vertices for the box:
static const GLfloat squareVertices[] = { 50, 50, 250, 50, 50, 250, 250, 250, };Note - Do you notice anything different between the data used in this declaration and the one used in the previous project? Don't worry if you can't spot it; it's not immediately obvious.This behavior uses the OpenGL ES configuration we defined earlier in the initOpenGL method (located inside the ES1Renderer class). We configured the orthographic projection and view port. This now causes OpenGL ES to render using pixel coordinates, rather than defining the vertices for the square.
The vertex positions in the previous example were defined using values that ranged from -1.0 to 1.0. This time, the values are much bigger.
Going forward, this will make our lives much easier, as we can more easily position items on the screen and work out how large they will be.
Having defined the vertices for the square, we can define the colors to be used within the square. This is exactly the same as in the previous example.
Next, we perform a translation that moves the point at which the square is rendered. As before, we are not changing the vertices of the square, but instead moving the drawing origin in relation to where the rendering takes place:
glTranslatef(0.0f, (GLfloat)(sinf(transY)/0.15f), 0.0f); Once the translation has finished, we point the OpenGL ES vertex pointer to the squareVertices array and the color pointer to the squareColors array:
glVertexPointer(2, GL_FLOAT, 0, squareVertices); glColorPointer(4, GL_UNSIGNED_BYTE, 0, squareColors); If you have a photographic memory, you may notice that there are a couple of lines missing from this section of code that were present in the previous example. When we last configured the vertex and color pointers, we enabled a couple of client states in OpenGL ES, which told OpenGL ES that we wanted it to use vertex and color arrays. There is no need to do that this time because we have already enabled those client states inside ES1Renderer when we performed the initOpenGL method. Remember that OpenGL ES is a state machine, and it remembers those settings until they have been explicitly changed.
Having pointed OpenGL ES at the vertices and colors, it's now time to render to the screen:
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); At this point, our lovely colored box is rendered, but it isn't on the screen just yet. When this method is finished, it passes control back to the GameController and then up to the render method in EAGLView, whose next task is to present the renderbuffer to the screen. It is at that point that you actually see the square in the display.
We have created a number of new classes that give us a structure on which we can build going forward. We now have the ability to create any number of different game scenes, each of which will perform its own logic and rendering, all being controlled by the GameController class.
We use this structure throughout this book and build upon it to create Sir Lamorak's Quest.
In the next chapter, we go more in-depth on how to render images to the screen. This involves looking at OpenGL ES in greater detail and creating a number of classes that make the creation, configuration, and rendering of images in Sir Lamorak's Quest much easier.
If you run the project for this chapter, you see the colored box moving up and down the screen. If you want the project to do more, try making some changes to the project, such as the following:
- Create a new game scene called TriangleScene and change the rendering code so that it draws a triangle rather than a square.
- Hint - Rather than drawing two triangles that make a square, which GL_TRIANGLE_STRIP is for, you only need a single triangle; GL_TRIANGLES is great for that. Remember, a triangle only has three points, not four.
- After you create your new class, initialize it in the GameController initGame method and add it to the dictionary with a key.
- Hint - Don't forget to make your new scene the current scene.
If you get stuck, you can open the CH04_SLQTSOR_EXERCISE project file to see what you need to do.
- The game loop code used is based on a tutorial by Alex Diener at http://sacredsoftware.net/tutorials/Animation/TimeBasedAnimation.xhtml. SynthesizeSingleton; see http://cocoawithlove.com/2008/11/singletons-appdelegates-and-top-level.html.
(C) Copyright Pearson Education. All rights reserved.
Reprinted with permission


text:
Multiple Dates
Science Experiments Class for Children & those with Learning Difficulties
Event Information
Date and Time
S-miles Center
Hannouche Building, 3rd Floor, Sabtiyeh roundabout, Bauchrieh
Beirut, Beirut
Why Science Experiments?
The best way for children to learn is by doing things, not by being told about them. When children are young, they are not only learning things, they are learning how to learn.
Regardless of the environment or culture they live in, each child do science of some sort. Children have an inbuilt drive for discovery. We are all born with an intrinsic curiosity to observe, explore things and learn from our surrounding environment. All infants and toddlers test the environment to see what happens when, for example, they drop a toy out of their highchair or touch every single item they perceive. This drive for discovery continues to develop as they grow and become more adventurous in the things that they try out.
Benefits of Science Experiments at S-miles Center:
Maria Montessori believed that all children behave like "little scientists" in that they are eager to observe and make "what if" discoveries about their world.
Experiments encourage our little scientists to be curious, creative and confident by observing and exploring things relevant in their lives.
- Science projects and experiments elicit a child's resourcefulness. It also nurtures intellectual curiosity, helping children acquire new ways of asking questions and understanding the world around them.
- Mathematical Skills: Various computational skills, geometric and algebraic concepts are used in science. For example measuring instruments are needed to record data using different metric units. Formulas are computed to find out answers.
- S-miles' young scientists are encouraged to build and use their knowledge. Using a logical approach to solve a problem or explain an observation is modeled by the adult, and then students are guided and given ample opportunities to apply what they have learned through a new way of thinking.
- When preparing for a science project, children at S-miles are particularly guided to foster their goal-setting, planning, and problem-solving skills.
- Scientific process: Participants in our science experiment class are exposed to different scientific theories. When ready they are guided to formulate a hypothesis to explain observations they have made. This leads to making predictions that can be tested by further observations and experiments. If predictions are correct, the hypothesis is supported. While children test and explore, they begin to realize that some experiments will work while others do not. This is critical to the learning process. Trial and error is important when experimenting.
- Pre-vocational goals: In S-miles, one of the primary goals in Science experiments sessions is to help children discover new interests that often lead to fascinating hobbies or educational pursuits.
- Desirable behavior: Research has shown that engaging children in science experiment or project decreases disruptive behavior as children are busy and focused on exploring new things. Keeping children engaged in an activity of an interest helps them focus on the task and eliminate gradually undesirable behaviors.
- Social Skills and cooperative learning: Children need to engage in different conversations and discussions as they are working together on an experiment. S-miles specialists guide those conversations to foster cooperative behaviors and team work skills. Children are encouraged to talk and listen to each other about their predictions and observations, as well as their plan to answer questions popping in their heads.
- Children love to experiment independently. This is why hands-on science activities are essential for children to develop their individual skills taking into account their capacities and individual needs.
Children are born with marvelous imaginations and a keen desire to explore the world. We encourage this in our children and we help them to discover the beauty and wonder of everything around them.
In S-miles center, professionals' objective is to enhance the development of the child's brain and curiosity by ultimately exploring the world that they live in. Professionals at Smiles center assist children through the process by guiding them and modeling analysis steps and logical reasoning. Finally, children are especially encouraged to reflect on the outcome of their work.
Kindly note that additional classes might be open in different week days depending on request.
For more info please don't hesitate to contact us on +961 71 74 74 54
Please follow us on:
- Facebook: SpecialMiles
- Twitter: Special_Miles
- Instagram:special_miles
- Youtube: Special Miles
Special Miles
S-miles Center
Hannouche Building, 3rd Floor, Sabtiyeh roundabout, Bauchrieh
Beirut, Beirut

subset: commoncrawl


text:
Trump could win — but not necessarily the White House (Evan Horowitz, Boston Globe, October 21, 2016)
One widening fear is that Trump simply won't accept defeat, instead doubling down on his talk of a "rigged election," leading to an uprising against the established political order. But there's an obvious problem with this approach: It doesn't lead to victory. What chance would his outsider movement really have against the full resources of the US government? And where's the money in it?
WHAT CHANCE WOULD HIS OUTSIDER MOVEMENT REALLY HAVE AGAINST THE FULL RESOURCES OF THE US GOVERNMENT? This sounds like a threat against the people of the United States, to me: QUESTION OUR AUTHORITY, CHALLENGE THE LEGITIMACY OF OUR ELECTIONS, AND YOU WILL DIE…. am I right? Ever so quietly, Mr. Horowitz is telling the American people: if you dare to question HILLARY'S authority, or the legitimacy of HILLARY'S election—then the government of the United States will bring out its tanks and run over you in the streets, right? Just like Tienamen Square…. NOT so very long ago….like 27 years?
This was a followup to Horowitz' curiously dated "October 17, 2016" article entitled:
"When you call the Election Rigged, Everyone Loses"
discussing Donald Trump's comments during the Third Debate, which took place on "October 19, 2016" in which Trump refused to accept, in advance, the results of an election that hadn't happened yet:
I have to say, I just couldn't disagree more! When a major political candidate finally acknowledges, in 2016, that there is a possibility that the elections have been "rigged" or at the very least DRAMATICALLY manipulated, he is simply stating a completely obvious and widely known fact.
We need to eschew all convenient lies and accept what Al Gore might call certain "Inconvenient Truths"—elections in America since 2000 have been questionable when seen in the best possible light, but more likely constitute outrageous "continental and oceanic" frauds against the people from coast to coast.
The Boston Globe never (in recent memory) met a Socialist it didn't like… but it is still disheartening to think that the City of the Sons of Liberty has sunk this low. This is, quite simply, the diametric opposite of the Spirit of '76 in Eighteenth Century Boston (and Virginia) which led to the American Revolution, when Patrick Henry famously intoned from the pulpit of St. John's Church in Richmond:
Is life so dear or peace so sweet as to be purchased at the price of chains and slavery? Forbid it, Almighty God! I know not what course others may take, but as for me, give me liberty, or give me death!
A very dear old friend wrote back to me, after I announced that Trump's position against acceptance had finally convinced me to vote for him, after many months of vacillation and hesitation:
OMG! Maybe that should be WTF. This is what you got from the last debate?! How utterly depressing. . . . . . If you honestly think this clown would be safe in world politics, I fear for your sanity. I can't begin to express what a disaster I think he would be as President, except to say that in a million years, I would never have believed I would find myself voting for Hillary, but he made it a necessity. Just one more thing to despise this bloviated windbag and egomaniacal twit!
I don't necessarily deny that there are clownish and twitty things about Trump, but if he truly stands outside the current governmental-elite system, then he is worth his weight in god: I just couldn't believe that he really was until October 19, 2016.
And, does being a Clown or a Twit really disqualify anyone from office? I rather think history is against that.
Trump is often compared to Hitler in exactly this way, and the notion of Hitler as a clown is as old as the Three Stooges' early production called "Nasty Spy" and Charlie Chaplin's brilliant "The Great Dictator"—-not to mention later "Springtime for Hitler" and "The Producers"….or a thousand shorter skits involving Monty Python or other British Comedians.
Caricature and ridicule are very socially interesting and ritually powerful, as our dear old professor Dr. Victoria Reifler Bricker hath taught us to say, and understand.
The role of Royal Court Jesters in Royal Courts and the interplay between Kings and Court Jesters is likewise well-known and documented anthropologically and historically everywhere. The Maya God K— whether called Tezcatlipoca or Kakupacal, is iconographically represented as "The Jester God" and he is in fact the chief Deity of Mesoamerican Kings and Rulers, from the ancient Ahauwob of the Peten to the Huey Tlatoani of Tenochtitlan. Does that make them undignified or less royal, or does it inform us of the nature of nobility and royalty? What does it tell us that the words "Sac" or "Iztac" refer to things mythical and imaginary, and otherworldly and royal?
Hitler was obviously an actor who rehearsed a role. So was Ronald Reagan. Recently republished photographs from he 1920s show that Hitler learned his oratorical style and practiced it privately in front of the Camera. Well??? Some of his poses, while learning, were definitely funny. Most actors have to practice before becoming capable of world class, memorable presentations… Many people criticize Trump because he is not an actor—the express and explicit criticism is "he does not know how to act in public" or "he does not know how to act like a President."
Adolph Hitler did not know how to "Act like a Fuhrer" when he was a painter or a corporal in Kaiser Wilhelm's Army. Who disputes that?
Every lawyer who appears in Court either "represents" or "acts on behalf of" another—and a lawyer's acting is not metaphoric, but in fact had better be Oscar winning or else the lawyer loses…. Hillary is a lawyer and she knows how to "act" her role much better than Trump. We expect our rulers to be excellent actors. We accept that they should wear costumes and take positions (i.e. pose artificially) and effectively dance around their enemies.
Congress Assembled "Acts", as do Courts of Law, and "Leaders" in Parliamentary Politics, so what is surprising that Ritual and Theatre are so intimately linked. "Tragedy" was originally the name for the rituals of Dionysus…. So was Hitler a Tragic Figure or a Comedian? He may have been some of both. Hitler, like Benito Mussolini, was born a common man, not an aristocrat like Franklin Delano Roosevelt or Winston Spencer Churchill, who was born at Blenheim Palace, home of the Dukes of Marlborough for three hundred years now.
What seems certain is that, whether you regard him as a clown or a tragedian, Hitler's "acting" is so memorable that it made an indelible mark on the world, and that, out of the 20th Century, even if Stalin, Churchill, and Roosevelt are memories consigned to Marx's old Midden Heap or Dustbin of History…. the name and role of Adolph Hitler may well be remembered with mystery, awe, and fear…. and that is what my old Harvard Linguistics Professor, the late Calvert Watkins, would call "imperishable fame", or "the immortality of the Gods"….
I think what I really took away from the Third Debate on 19 October 2016 (which Evan Horowitz apparently knew all about on 17 October 2016? to write about it in the Boston Globe?) is that Trump may be enough of a clown to really ACT FOR or REPRESENT me (and 150,000,000-200,000,000 or so) other "traditional Americans" against the current global elite.
For those of us in that category (150,000,000 or so "Traditional Americans"), the past eight years have truly been an abomination marking the final crystallization of life into the future predicted by Huxley's Brave New World and Orwell's 1984.
Clowns stand, throughout the symbolism and iconography of the world, for established orders TURNED UPSIDE DOWN—and THAT is exactly what we need in America today—the Bush-Clinton-Obama Oligarchy MUST be stood on its head and shaken, the course of history must be reversed, and maybe this possibly over-sexed Orange-haired clown is just the man to do what needs to be done….


text:
374 members161 Comments 12 Likes
37 members16 Comments 2 Likes
Michael has not received any gifts yet
Posted on May 6, 2011 at 2:58pm 0 Comments 0 Likes
I'm down to hit I also manage an up and coming player training to go pro about to start playing the futures and all that man. Def be a good fit. We can meet up or come down there if your still training for tennis. Let me know
Hey man wanna hit some time this week ?
© 2019 Created by Mark / The Mayor. Powered by


text:
Hello Friend
(It is my first talk/discution post on kde.org.Sorry for my mistakes and "don't know about ...")
In CMake Totorial I found line:
CMAKE_INCLUDE_PATH, eg. export CMAKE_INCLUDE_PATH=/sw/include CMAKE_LIBRARY_PATH, eg. export CMAKE_LIBRARY_PATH=/sw/lib CMAKE_PROGRAM_PATH, eg. export CMAKE_LIBRARY_PATH=/sw/bin
in third line CMAKE_LIBRARY_PATH is ok? It don't have to be CMAKE_PROGRAM_PATH?
Greetings --Serkamil 02:46, 23 January 2010 (UTC)


text:
What's your favorite kid-friendly app?
I like Pull Ups Big Kids Apps from Huggies & Sea World's Turtle Trek
Lisa is a winner of Top 25 Tech Moms - 2013
I like Pull Ups Big Kids Apps from Huggies & Sea World's Turtle Trek
You can learn a lot by using Google. Just check out apps or app reviews and you'll learn a lot. Also pick up a trade magazine and you can see the latest gadgets that will be coming out soon or visit a trade show.
I have to say the Iphone. I know they didn't make it for kids but every parent reading this right now knows that we all have given our kids the phone to keep them entertained at one time or another. Well most of us have. People are amazed that my daughter who is not even two yet can work my phone. She can search for pictures scroll, move, play movies people are amazed. I am too because I never showed her any of that she figured it out herself. It's great because it's also an educational tool I can play the alphabet songs or other things for her.
It's also why I created my baby product the SnuggWugg diaper changing pillow with the smart phone option. My daughter loves my Iphone. - Next Ipad.
This is the latest video from Circle of Moms by POPSUGAR and I have to… More


text:
As supporters of the Obama and Romney tickets hold their breath through tomorrow's election, another subset of individuals — often forgotten by the mainstream media — are also bracing for the results. Third-party candidates — heralded by some as encouraging debate and criticized by others as "delusional" — are set on influencing the national conversation [...]
Learn More Providing Support for pbs.org
- Please try again a little later.
Need to Know is a production of Creative News Group (CNG) in association with WNET. Marc Rosenwasser is Executive Producer. Need to Know is made possible by Bernard and Irene Schwartz, Mutual of America, Citi Foundation, John D. and Catherine T. MacArthur Foundation, Miriam and Ira D. Wallach Foundation, Margaret A. Cargill Foundation, The Corporation for Public Broadcasting and PBS.
© 2019 WNET.ORG. All rights reserved. pbs.org Terms of Use Privacy Policy


text: Peace and Justice Minor Requirements The Peace and Justice Minor is an interdisciplinary program that prepares students with the theoretical and practical knowledge and critical thinking skills needed to help shape a more just and peaceful world. Courses familiarize students with the major ideas, concepts, and theories of peace and justice; detailed knowledge of problems, issues, and challenges such as poverty, racism, and war; and various approaches to solutions. Community engaged learning is an integral part of the Minor. Many of the courses require students to engage in community service, community education, or political advocacy either as individuals or in a group.


text:
Search For Properties In Rio Vista
View All Rio Vista Listings ›
Current Properties in Rio Vista
No properties found
Fort Lauderdale Homes for Sale in Rio Vista Isles
A premier island community nestled among the canals adjacent to Lauderdale Beach, Rio Vista Isles combines the exclusivity and vicinity that discerning home buyers in Fort Lauderdale search for. Coveted addresses on the three islands boast the most elegant waterfront luxury properties for sale in Fort Lauderdale. Let Premier Estate Properties guide you to your dream home for sale in Rio Vista Isles so you can begin living life as an extended tropical vacation.
Exclusive Private Community in Fort Lauderdale
Elegant fireplaces, sweeping marble foyers, glittering swimming pools and breezy, bloom-lined porticos will wow home buyers of even the highest echelon at Rio Vista Isles. Elite private enclaves, whimsical Mediterranean inspired manors and sophisticated contemporary builds give every style of taste a luxury home for sale in Rio Vista Isles to desire.
Your Lavish Lifestyle in Rio Vista Isles
Your prestigious address in Rio Vista Isles gives you VIP access to all of the culture, art, music, theatre, recreation and leisure activities of Fort Lauderdale. Just steps (or a quick float) away, you'll find the bustling beach in all its pristine, powder-fine grandeur, the coveted shopping and dining district of Las Olas Boulevard and championship golf and tennis clubs. Fancy quiet respite from your colorful city? Simply head back to the tranquil haven of your luxury home in Rio Vista Isles.
Our Mission
It takes a vision to know what select clients want in their dream home. Premier Estate Properties offers the highest level of customized service, only exceeded by an unsurpassed level of performance and dedication to selecting the perfectly matched luxury Fort Lauderdale real estate for each client.
We extend to you our firm's principles of reliability, integrity, personal attention as well as breakthrough innovations. It is this unique combination of traditional ideals and dynamic new ideas that sets Premier Estate Properties apart.


text:
MILLEDGEVILLE, Ga. – Senior golfer Joe Young (Cochran, Ga.) was named GC Athlete of the Week as announced by the Georgia College Athletic Department.
This marks the second consecutive week that Young has claimed the award, becoming the second Bobcat athlete to accomplish this feat during the 2010-11 school year.
Young led the Bobcats to a third place finish at the Bearcat Invitational, earning the individual title by finishing six under par. He shot a 70 and 68 in the two rounds, bettering the field by two strokes.
The Georgia College golf team continues its season Monday April 11, when they head to Savannah, Ga. for the Peach Belt Conference (PBC) Championships. They are coming off an impressive third place finish and are the defending PBC Champions this past Tuesday.
The Georgia College Department of Athletics, back-to-back winners of the PBC Commissioner's Cup, sponsors 10 varsity athletic programs at the NCAA Division II level. As a Division II program, Bobcat Athletics prides itself on balancing the life of the student-athlete, evidenced by the teams' multiple appearances in post-season competition as well as documented academic success and community-service involvement. Sign up at www.twitter.com/BobcatSports and www.facebook.com/gcbobcats for up-to-the-minute reports, and visit www.GCBobcats.com for more information, and to nominate your favorite former Bobcats and Colonials to the GC Athletics Hall of Fame.


text:
Swimming Pool Blog
by Rob Cox February 20, 2013
Correcting a Pool Main Drain Hazard
Main drain entrapment, or being suctioned down to the main drain of a pool or spa, has had fatal consequences for dozens of swimmers.
The problem occurs when suction is so great through a single main drain, that a person can be stuck in or on the drain, and be unable to escape.
Recently, with the passage of the Virginia Graeme Baker Act (VGB), public pools and spas are required to install dual main drains with anti-vortex main drain covers.
Residential pools are not required to retrofit their pool for dual drains, but most pool builders are now installing two main drains instead of one. Service companies and pool owners should check for non-compliant main drain covers. Generally speaking, flat grates encourage entrapment, while domed covers, with holes on the side of the main drain cover, do not. Almost as important, however - is that drain covers are properly secured, with both screws.
Many residential swimming pools have main drains that are connected into the skimmer, with one pipe running to the pool pump. In these cases, entrapment is more difficult, as the suction from the drain is offset by the suction from the skimmer. That is, if the main drain were to be blocked (by a person) the suction should shift to the skimmer - in theory anyway.
For residential pools that have a dedicated main drain line - running all the way back to the pump, a hazard exists. If the skimmer valves were closed, and all of the pump suction is from the main drain only, a swimmer could become trapped on the main drain - in a pool or spa.
There are 3 methods of correcting a hazardous situation from a dedicated main drain line.
Abandon the Main Drain line
In some older pools, it's not uncommon to find the main drain line has leaked or collapsed and been sealed up in the main drain pot, and the piping removed from the suction side of the pump. The APSP has produced a case study on pools without main drains, and the CPSC has this to say about it.
"CPSC staff recommends that to ELIMINATE and not just MITIGATE the drain entrapment hazard in pools and spas, pool owners should disable old drains or build new pools without any drains and use gutters, overflows and/or skimmers to provide water to the pump."
If your pool is shallow depth, not having a main drain will have less of an effect on water quality. To compensate for the lack of a main drain, return jets can direct filtered water to the deep end of the pool. Automatic pool cleaners can also take up the slack, helping to distribute filtered water and improve circulation.
To abandon the main drain line, you can fill in the main drain pot with concrete, but you don't have to. It may be a good idea to plug the line to prevent future leaks. On the other end of the main drain pipe, in front of the pump, cut and cap the pipe.
Install a Vacuum Release System
A Vacuum Release System, or VRS, senses the vacuum pressure that is before the pool pump. When a drain is blocked, fully or partially, this will raise the vacuum pressure on the main drain line quickly and immensely. The VRS senses the pressure change and shuts off the pump.
Vacuum Release Systems have saved countless lives, and are required equipment for many commercial pools. Installation takes about an hour, and in many cases, installing a VRS is the most cost effective solution to a hazardous main drain. Correctly installed and compliant main drain covers should also be used.
Install Dual Main Drains
This may seem like the most work, but it is what most commercial pools with single main drains are required to do, to bring their pools into compliance. Adding a second main drain to your residential pool can be done for plaster or vinyl liner pools, and the steps would look like this.
- Drain Pool completely, open up any hydrostatic relief valves.
- Using a large Chop Saw, cut open a channel in the pool floor.
- Using a small Jackhammer, break up the gunite and plaster.
- Cut the pipe that enters the main drain and install a Tee fitting.
- Connect two main drains, 3-4 feet apart, to the Tee fitting.
- Fill the hole back in with hydraulic cement, cover with plaster.
For vinyl liner pools, the process is similar, with the exception of pulling back the liner first, to access the floor. The liner will also need to be replaced, now that the hole for the single main drain will no longer line up.
Residential pools are not required to do anything at this point, but if you are worried about entrapment in your pool or spa, it would be wise to take one of the listed steps to correct the situation.
If you do nothing, at least do this - make sure that your main drain covers are secured tightly - limb entrapments also occur, not from the suction, but from getting toes or hands caught in a main drain. If you main drains have flat grates, you should also install anti-vortex main drain covers.
This is important for pools, but perhaps more important for the pool/spa combo. Inground spas often do not have a skimmer, but isolate ALL of the suction through the main drain only. If incorrect or loose fitting spa drain covers are in place, a tragedy could occur.
If you have a pool and spa combo, and only a single drain in the spa (some have drains also on the side), you may have an even more hazardous situation, as swimmers are much closer to the drain. Exactly how the world lost Virginia Graeme Baker, in a spa with a single drain.


text:
Diamond & Pearl: Mysterious Treasures
Original Release Date: August 22nd 2007
The Diamond & Pearl: Mysterious Treasures set is the second fourth generation set. This set focuses upon the Pokémon of the lakes of Sinnoh as well as the Fossil Pokémon. It also introduces a new aspect to the Pokémon in the form of Hold Items. These act similar to Poké-Bodies in that their effect tends to always be on when the Pokémon is in play.
Special thanks to SkittyOnWailord for scanning these for us
All Content is
©Copyright of Serebii.net 1999-2019. | Privacy Policy | Manage Cookie Settings
Pokémon And All Respective Names are Trademark & © of Nintendo 1996-2019


text:
Before the holidays, Philips brought a new technology to market for those with disposable incomes and a knackering for ambient lighting. The Hue concept is simple (and reminds us of Philip's earlier attempts at lighting for TVs): the bulbs have variable range of color support via LEDs and they're network enabled, allowing you control the light level and color via your iPhone.
Sure, a set of three bulbs will set you back $280 (Amazon.com) but the effect is quite impressive, especially with the iOS support coming native to the system. But that's just the problem as those on other platforms were left in the cold.
Now a new company called Oni seems to be embracing Windows Phone by releasing their first (of a few) "lifestyle" apps. Oni: Light Control, now available for $3.99 on the Store, is a fully-featured light control system for Philips Hue. It even adds some features like voice control and the ability to pick colors from photos, allowing you to make custom templates for your home.
We're not going to lie: we have more important things at the moment to spend our money on instead of those Philips Hue bulbs (and presumably a new lighting system for our home). But while we laughed at the notion back in October, we're now considering for the future because…well, it's just darn awesome looking.
We also like Oni (www.oni.io). They seem like a serious software company prepared to bring high-quality apps to Windows Phone and Windows 8 (see 'Hub' for Kinect coming soon and two other "classified" apps in the works).
Look, what we're trying to say is forget the rent, mortgage payment, your kids lunch for the month, your car loan and go invest in Philips Hue's ambient lighting system for your home, crank up the disco music and grab this app so we keep Oni around. That and if you live the Glenn Quagmire life-style, you'll thank us later.
Pick up Oni: Light Control for $3.99 here in the Store with a free trial (Windows Phone 8 only). And you must watch the accompanying videos. Thanks, Hiiiiiiiii, for the tip
Update: You can actually buy the 3-pack Start kit of Philips Hue for $200 ($80 less) from Apple.com.
This post may contain affiliate links. See our disclosure policy for more details.


text:
MILLEDGEVILLE, Ga. – The Junior Bobcat Volleyball Clinics are back, a great introduction to Georgia College's newest sport. Held at Georgia College's Centennial Center, these clinics are designed for children ages 7-12 years old.
During each session, the skills of volleyball will be taught by head coach Gretchen Krumdieck and the members of the Bobcat Volleyball Team. The clinics will run Feb. 16, Feb. 23, March 9, March 30, and April 6 from 1-2:30 p.m. at a cost of $10 per session.
"I'm very excited to be teaching volleyball to the community," Krumdieck said. "Starting at a young age will help develop their skills and create a love for the game that can be played at any age."
Registration for each clinic will be at 12:45, before each session.
The Georgia College Department of Athletics, two-time winners of the PBC Commissioner's Cup, sponsors 11 varsity athletic programs at the NCAA Division II level. As a Division II program, Bobcat Athletics prides itself on balancing the life of the student-athlete, evidenced by the teams' multiple appearances in post-season competition as well as documented academic success and community-service involvement. Sign up at @GCBobcats on Twitter and Facebook for up-to-the-minute reports, and visit GCBobcats.PhotoReflect.com to purchase photo prints from home athletic contests.


text:
Darren Criss Gives Katy Perry's 'Last Friday Night (T.G.I.F.)' the 'Glee' Touch
On Nov. 1, 'Glee' will return to FOX, bringing with it new drama — and new characters. But perhaps what has us most excited is the much-anticipated cover of Katy Perry's 'Last Friday Night (T.G.I.F.),' as performed by Blaine (Darren Criss).
As expected, this performance will be a big scene, with almost all of the New Directions members participating (sans Santana, but we don't know what that's about). Blaine gets help from all of his new friends acting out the crazy lyrics while they sing it out in the choir room. Mike Chang keeps it real with his dances, while Artie rolls across the floor shooting pictures on his phone. By the end of the scene, everyone's dancing in sweet 'Glee' harmony.
We're loving the mood in this clip from Season 3, Episode 4, especially because we were really itching for some new Top 40 covers to covet — but we really can't wait to see it in practice on our television screens. 'Pot O' Gold' airs on Nov. 1.
Watch Blaine Perform 'Last Friday Night (T.G.I.F.)' on 'Glee'


text:
To start with Quick Hit Slots can be downloaded free of cost. Consequently, you would not have to stress about any concealed costs. Alternative designs are readily available for both Android and iPhone, therefore this is another concern that you can forget about.
The following thing that would impress you about Quick Hit Slots is that it is fairly secure. There's no need to fear about your private details being stolen if this is the game that you opt for.
Furthermore, it offers you a vast number of Free Coins, and for that reason you would be spoilt for options. It is not likely that you won't be able to discover something that would match your need as the choice of Free Coins is also available.
In case you do not like a concrete game, you have all opportunities to jump onto yet another one.
By the way, make sure to check our Facebook.


text:
AutoNation Nissan ChandlerAutoNation Nissan Chandler is a first-class Nissan dealership selling new, certified pre-owned and pre-owned Nissan models to Chandler, Mesa, Scottsdale, Phoenix, Gilbert and Tempe. Visit the relaxed and accommodating showroom to find your next Nissan model where you can choose from a vast selection of new and pre-owned Nissan vehicles including cars, trucks and crossover SUVs with financing options. A great car needs expert care and AutoNation Nissan Chandler makes it easy and convenient to schedule maintenance and repair services.
New Nissan Cars and Trucks in Chandler
Explore the expansive selection of brand-new Nissan models with no hassle or hurry. AutoNation Nissan Chandler strives to make every customer experience pleasant and stress-free. The vast inventory of new Nissan models ensures there is one that you'll fall in love with and ultimately drive around for many years to come. Consider the best-selling Nissan Altima - we keep a full stock of them at our dealership.
Family Cars, SUVs and Trucks
Families will be interested in Nissan's unique safety features including Nissan Intelligent Forward Collision which watches two cars ahead of you and can warn you to slow down. This safety feature comes standard on the Nissan Maxima and Nissan Armada. NissanConnect Services is available and provides hands-free capabilities, security and convenience, entertainment and information, navigation and communication through Bluetooth connectivity. The newest models of Nissan four-door vehicles come standard with Nissan Rear Door Alert which reminds the driver to check the back seat for precious cargo.
Sports Cars and Sedans
Search all Nissan models like the sporty Nissan GT-R or Nissan 370Z in standard or NISMO models. If you're trying to decide between the Nissan Maxima, Altima and Sentra, each model has its own advantages. Those looking for performance without sacrificing practicality may want to choose the new Nissan Maxima. You can't go wrong with this iconic 4-door sports car or the fuel-efficient and affordable Nisan Altima.
Search all Nissan models like the sporty Nissan GT-R or Nissan 370Z in standard or NISMO models. If you're trying to decide between the Nissan Maxima, Altima and Sentra, each model has its own advantages. Those looking for performance without sacrificing practicality may want to choose the new Nissan Maxima. You can't go wrong with this iconic 4-door sports car or the fuel-efficient and affordable Nisan Altima.
Crossover SUVs
The Nissan Rogue is a small crossover SUV with lots of room for growing families. Or maybe you're looking for a crossover with the look and feel of a luxury SUV? The Nissan Murano can accomplish the job and has plenty of room for five passengers to stretch out in. Nissan Kicks is the newest model of Compact SUVs (CUVs).
Nissan Trucks
Look out for the boundary-defying Nissan Titan XD truck available as gas and diesel-powered or the gas-powered Nissan Titan. Use it for work of play. This versatile, full-sized truck, known as The Every-Duty Truck™, is available in both diesel and gas and can tow up to 12,030 lbs. Or check out the Nissan Frontier, America's most affordable pickup.
EV Cars
Drivers in search of a sustainable car will find the popular and eco-friendly Nissan LEAF. The LEAF continues to have record-breaking national sales and is a standout in the electric vehicle (EV) category. It is the best-selling electric car based on cumulative data from December 2010-December 2017.
Wondering Whether to Lease or Finance a New Nissan Vehicle?
Expert finance specialists are available and prepared to guide you through financing your new Nissan. AutoNation Nissan Chandler features an extensive inventory of new Nissan models, and exciting new Nissan lease specials to help you get into the car of your dreams today!
Lease a New Nissan Near Maricopa County
Leasing the new Nissan you want has never been easier. AutoNation Nissan Chandler provides multiple leasing options to get you quickly behind the wheel of your new Nissan.
Pre-Owned Nissan Dealer Serving Chandler Area
Since all of AutoNation Nissan Chandler pre-owned cars are inspected by the certified Nissan automotive department, you know that you're getting a great pre-owned Nissan in the Chandler area. Many people want to know the difference between used/pre-owned and certified pre-owned. Most used cars are certified pre-owned which includes a multi-point inspection and CarFax® report. AutoNation Nissan Chandler has an extensive pre-owned Nissan vehicle inventory including many used Nissan cars and trucks.
Nissan Service & Parts Near Scottsdale
Maintenance or repairs at AutoNation Nissan Chandler are a breeze with easy drop-off and pick up. Looking for a certified Nissan service near you? This dealership has only factory-trained professional technicians on hand, an extensive selection of OEM Nissan parts, and Nissan accessories. AutoNation Nissan Chandler technicians can provide tips for maintenance in Summer, Fall, Winter, and Spring. AutoNation Nissan Chandler will cover all of your Nissan service needs in the Chandler area. Schedule an appointment today and get back out on the road in an efficient and timely manner.


text:
Call-Level Design
Within the framework core each DSP component such as Acoustic Echo Cancellation, Tone Generator, Tone Detector, etc., should be made into a modular block. These blocks can then be joined together to form a data processing pipeline (see Figure 2). An inbound endpoint connection would consist of the inbound pipeline and an outbound pipeline.
To complete a call connection within the VPF, two endpoints need to be connected together. Figure 3 shows the setup for an endpoint IP call.
This provides a very powerful and flexible method of configuration call connections. N-way calls can be set up by connecting the endpoints together, and forking can be configured just by disabling the inbound pipeline of an endpoint.
A number of blocks can be strung together within a pipeline to perform the necessary soft DSP for the incoming data. Below are example configurations of the pipeline for IP and PCM inbound and outbound. Each block can be turned on or off as needed. The following pipeline configurations provide the flexibility to support many scenarios.
The Sample Rate Converter component is one example of how a flexible configuration can reduce CPU usage of the pipeline. Narrowband data requires less processing than wideband data within each component; therefore, to minimize CPU usage, as many blocks as possible should be run in narrowband mode. The following examples show how placement of the SRC block can be used to reduce the CPU usage of the system.


text:
Great Experience, Class Act
Fund: MeriTech Capital Partners
Posted by Anonymous on 2013-01-15
Pitched these guys recently. Specifically, Craig Sherman and George Bischof. They were smart, insightful, and most surprising, could not have been more welcoming, supportive and genuinely interested. These guys made you want to work with them. Unfortunately for us, we were a bit too early for them and they passed but not until Craig called me and spent another 30 minutes on the phone explaining their decision. Class acts all around. Hope to have the chance to work with them at some point. This is what you hope a VC experience is like...PRIVATE: Members Only


text:
If you're one of those people who think that you could accomplish a lot more with your life if only you had more free time, you're not alone… and you're wrong. For years I blamed the long hours I worked, exhaustion after those long hours, or the "necessary" errands that consumed what little free time I did have. I thought that if I ever had a job that didn't consume my evenings and weekends I'd have the time to accomplish all the things I always dreamed I would do. Yet when I look back over the years since I've scaled back my working hours by becoming a consultant, the peak moments of productivity – personally and professionally – have seldom been the moments when I had the most free time. I am not now at my most productive, and understanding why has become one of my primary self-improvement goals.
Since 2006 I have seldom worked more than 38 or so hours per week. Here are examples of some of the clients I've had both in New York and Florida. Client A was a very short commute (less than half an hour), and what I'd call an "early office" – I made it in around 8:00 am most days and usually left by 4:00. Client B was a long commute (almost two hours each way), and while I seldom worked more than 8 hours in a day I did stay late on occasion. It was a "late office" – most of the people in my department drifted in around 9:30 or 10:00, so it was hard to justify arriving at 8 and leaving at 4. Client C was a short commute (by New York standards) of one hour, and the client was very flexible about the hours, not really caring if I arrived at 8 or at 10. It was very much a ROWE office. Client D was a driving commute, about 45 minutes, depending on traffic (often much longer in the evenings) and required that you be glued to your desk every minute of the day.
So when was I most productive while working? Client A was a horrific environment, with a no-wall cubicle farm, frequent last-minute meetings and a lot of work taking place on a trading desk. If you've ever seen the movie "Boiler Room," that's the environment I was working in. Client B was the exact opposite. They gave me a quiet cubicle on the opposite side of the floor from the rest of the department. They never had meetings, and email was the preferred method of communication. Client C was back to the Client A world – a huge conference room shared by 45 consultants, all talking on mobile phones, yelling back and forth to each other and sitting two feet apart. Client D was extremely restrictive – quiet, with a boss who didn't like hearing her staff socialize. So where was I the most productive, both professionally and personally? I was far more productive while working at Client B with four hours of commuting time than I ever was before or after. Why?
Having so little free time while at Client B forced me to be organized and disciplined with my time while at home. It also made me focused at work, knowing that whatever tasks I could accomplish there would free up time at home. I was focused on completing my work quickly and efficiently, and getting out as soon as possible, even if it meant working less than eight hours, because the commute was so long. I did not spend endless hours reading Sports Illustrated or The New York Times during my commute. I made good use of my time on the train by reading, and as any writer can tell you reading is the best inspiration. Although we only had one child at the time, we didn't have a babysitter and I seldom had any real free time until 9 or 10 pm. So again, I knew I had to make the most of an hour or two late at night.
My busiest time was a time of tremendous productivity for me. Most of the "most popular" posts I wrote on brip blap were written during that time. I was tired, and I felt like I had no free time, but everything got done that needed to get done. While at Clients A, C and D, almost nothing got done. The oppressive work environment meant that I was less productive professionally. The noise and lack of space made it hard to accomplish anything. Because I took longer to do my work, I came home and started writing, and it wasn't good. Because the commutes were short, I quit reading books and started listening to morning shock jock bits (this was before I discovered podcasts). My personal and professional productivity took a beating.
Now, with more free time, you might expect to be more productive. In my experience, I am not. I find that in a non-structured environment I have difficulty focusing on even the simplest tasks, which is surprising to me. I have trouble reading. I spend more time than I should with my kids, but not always in a focused or in-the-moment way. I cannot get organized about my computer time – I check email again and again throughout the day, which is a terrible idea. I waste time on Facebook and countless other nonproductive sites.
Some of us, despite what we like to think, need the structure of a job to be productive. Sometimes getting up and leaving the house forces you to be more productive whether you like it or not. I have had to confront a simple fact: everything I thought I knew about organizing my time has to be thrown out the window. I have never been good about organization and productivity, because I was only organized and productive when forced to be by circumstance! I have to relearn so much to be as organized as I need to be; but right now I have far more free time than I did in the past to do nothing but learn, so I have no excuses now.
Stephen King says in his masterpiece "On Writing" that the most important part of writing is learning to close the door. He's a brilliant writer (if you think of him only as a hack horror writer, try picking up one of his books sometime – they are as well-written as anything you'll ever read). His point is that if you fail to close the door when writing, both figuratively and literally, you'll never have a chance to succeed. It is too easy to let the world distract. Although he is talking about writing, he could just as easily be talking about cooking or exercising or almost any productive venture. We have too much to distract us, and too little time to do anything well if we fail to concentrate on what we are doing at that moment. The challenge is to learn that focus.


text:
Today we are launching an exciting feature that you, our users, have been demanding for a while, and which has kept us busy for the last few months: voice recording!
Pronunciation is an essential part of language learning and we are thrilled that we can offer this new feature to you.
From now on, you can record your own voice on busuu.com and get it corrected by a native speaker from our worldwide community! There are 150 fun new dialogues in seven languages, recorded by professional voice artists, for you to practice on and improve your pronunciation skills. The recording exercise is a dialogue that consists of a conversation between two people.
There is one new exercise within our existing learning units. You choose the character you want to practice (e.g. receptionist or hotel guest) and record your own voice. Our system will automatically mix your recording with the voice of the professional voice artist, who plays the second person in the role play. You can then send the new dialogue with your own voice to a native speaker for correction.
How does voice recording work?
You can access the new dialogues by clicking on the voice recording icon in the learning unit overview:
You are only able to do the pronunciation exercise if you have a microphone. You can either use the microphone that is built in your computer or an external one. First of all, you will need to enable your microphone. If it is disabled, the window below will appear.
It is important that you make sure that the allow button is clicked on the right hand side and the remember box ticked. You are now ready to record!
Once your microphone is enabled, you will choose your character by clicking on one of the two characters you would like to be. A green frame will indicate your choice of character. If you don't choose one, the system will automatically choose the second one for you.
The image below shows the first screen you see when entering the voice recording exercise. You can now listen to your character's part as well as the other character's part by clicking on the play button next to the text box.
As shown above, your character's part that you have to record will be shown in green. To record it, click on the red record button and wait until the 30 second countdown appears. Record the sentence by speaking clearly, slowly and matching the volume of the voice artist.
You will listen to what you recorded by clicking on the play button and you can record as many times as you want.
Before submitting it at the end, you will be able to hear the full dialogue matched with the voice artist's voice. If you are not satisfied with the recording, you can record it again by clicking on .
Once you are happy with the results, you can then submit the voice recording for corrections to the community or to friends that you select by notifying them. You will also receive five juicy busuu-berries for completing this pronunciation exercise.
All voice recordings done by the community will be in the section review posts of others, followed by this icon .
Normally, this feature is only available to our Premium Users, but as this is a new tool we want you to try it for free! So, you have until Sunday 27th of March 2011 to use our new voice recording absolutely free. Try it out now!
Hurry and take advantage of our new feature! We wish you a great and entertaining pronunciation practice! Try it out now!
Update: We have issued a special 10% off discount during the trial period of the new recording functionality. Use the code: ADFG2011 when upgrading to a Premium Membership. Only valid until the 27th of March!


text:
I'm very excited to say that I've been invited to blog over at Diabetes Daily!
David and Elizabeth Edelman have built an awesome home away from home over there, and I'm also following in the footsteps of two of my good friends and favorite bloggers, Amylia Grace and Bernard Farrell.
While it is hard to pick up and move after such a long time here, it was an offer I simply could not refuse.
And after all, the only thing that is changing is the URL (address) of the blog. Same Scott, same posts, same ride. Please join me for future posts at my new address http://www.diabetesdaily.com/johnson/.
Please update your subscriptions and links. I'm leaving this up and running for archival purposes, but all future posts will be at diabetes daily.