ES Websoft

Speed Up Your Site! 8 ASP.NET Performance Tips 6

2009-08-03T12:55:00.001+07:00

Lack of Indexes

The ability to index data is one of the key benefits of storing information in a database. Imagine for a moment that you need to look up a name in a telephone book. You take advantage of the fact that the last names are sorted in alphabetic order -- it would take forever to find a name if the entries were listed in random order. Databases take advantage of the way your information is sorted for the same reason. The default sort order in a table is called a clustered index.

Of course, you may want to search for your information in several different ways. To continue with the phone book example, you may want to look up businesses by zip code, business type, or name. The common approach to implementing this capability in a database is to order the data based on the most common search order, then place additional indexes to facilitate other search criteria. The data is sorted by the clustered index, but the database stores additional information to help it look up rows using other criteria. This additional lookup information is called a non-clustered index.

One of the most common reasons for slow queries is that the database is performing a table scan, which occurs when the database lacks an appropriate index to use to look up data. Asking your database to perform a table scan is equivalent to asking someone to look up a person in a phone book that lists entries in random order. To summarize, proper indexes are a necessity for database performance.

Incorrect Indexes

If indexes are good, more indexes are great, right?

Actually, no. There's a cost incurred when you add indexes to a database. Each time a row is added or updated, all the indexes need to be updated, and too many indexes can slow your database down. It's important to select a limited number of indexes that'll give you quick lookups without slowing down your updates. We'll be talking about some tools to help you with this task later in this chapter.

Poorly Written Queries

It's easy to land yourself in trouble if you don't really understand SQL. SQL is not just another programming language -- it's a declarative, set-based query language. A lot of your standard programming tricks don't apply here.

We'll talk about troubleshooting query plans and poorly written queries in the section called "How can I troubleshoot a slow query?" later in this chapter.

Deadlocks

Databases use locks to prevent your data from being messed up by conflicting updates.

For example, we can't apply a 10% discount to all of our product prices and delete all products that are priced over $100 at the same time -- we need to process one product at a time. Locks allow us to do this. The SQL Server engine is reasonably clever about how it uses database locks -- it'll often lock portions of a table (called pages) and, sometimes, individual rows.

Yet there's always the potential for two transactions to arrive at a state where both are waiting for the freeing of a lock that's simultaneously held by the other transaction. This situation is called a deadlock.

For example, consider two queries that use the Products and Orders tables. The first query, which we'll call ProductsThenOrders, uses the Products table first; the second query, OrdersThenProducts, uses the Orders table first.

ProductsThenOrders locks the Products table and begins to make updates. Meanwhile, OrdersThenProducts locks the Orders table and performs its updates. No problems so far.

Now ProductsThenOrders is ready to update the Orders table, but it can't -- the other query has it locked. Likewise, OrdersThenProducts wants to update the Products table, but is also blocked for the same reason. We're deadlocked!

When SQL Server eventually detects a deadlock, it will pick one query as the "deadlock victim" and kill it, while the survivors are released. The result of this conflict resolution process is that one of the queries will return with an error that it was unable to complete -- not the most efficient use of resources.

Deadlocks don't happen too frequently -- unless your application executes a lot of transactions. It's important to be aware of them and to fix deadlock conditions quickly. Deadlocks can be avoided by:

minimizing transaction length
accessing tables in the same order in competing queries

In the above example, accessing the Products table first in both queries would have prevented the deadlock.

The NOLOCK Query Optimizer Hint
Even if you're not encountering deadlocks, locks have a definite performance impact. Locks restrict access to your data in such a way that only one query can use it at any time -- an approach that's safe but slow.

In some cases, you mightn't need to lock your rows. You might query historical data that isn't subject to change, or it mightn't be crucial that the data returned in the query is perfectly up to date -- comments on a weblog might fall into this category.

In these cases, you can use the NOLOCK hint to tell SQL Server you want to read directly from the table without honoring any locks. Note that this only makes sense for SELECT statements -- any data modification will always require a lock. Best practices avoid using table hints -- parameters that override the default behavior of a query -- when possible. However, this one is relatively innocuous as long as you understand that you may be viewing uncommitted changes. Just don't use it when displaying critical information, such as financial data.

Here's how you'd use it:

SELECT COUNT(1) FROM Orders WITH (NOLOCK)

Since this statement places no locks on the data that it's reading, other queries won't be forced to wait for the query to complete before they can use the Orders table.

You can read more about deadlocks in the MSDN article, "Analyzing Deadlocks with SQL Server Profiler."

Hardware Issues

As with any software application, SQL Server performs at its optimum when it's running on sufficiently powerful hardware.

If upgrading your server is an option, the first thing you should look at is memory, as SQL Server makes heavy use of available memory to cache frequently used data. And the cost of new memory is relatively cheap -- often cheaper than the time required to tune an underpowered database server. Adding memory can compensate for slow CPU or drive access, since caching can significantly reduce the work that SQL Server needs to complete.

After you've exhausted your memory upgrade options, the next most common hardware issue is a disk read/write bottleneck. Database hardware configuration is a large topic and falls well beyond the scope of an ASP.NET book, but a great first step is to put your log files on a drive that's as fast possible, and is separate from the operating system and database files.

Using a production database server for other tasks -- especially IIS -- is a bad idea. It's often necessary in a development environment, but it will have a performance impact in production.

How can I troubleshoot a slow query?

Optimizing database performance is a complex topic that's the subject of numerous very thick books, so I'm not going to pretend that we can make you an expert in query optimization in a few short pages. Instead, I'll focus on some of my favorite "developer to developer" tips to point you in the right direction.

Solution

Before you begin to look for a solution, it's important to verify the problem at hand. You can then begin the process of elimination.

Verifying the Problem

First, verify that the SQL you think is being executed is actually being executed. The best way to confirm this is to duplicate the problem: run the query in SQL Server Management Studio (SSMS).

If you have any doubt about which SQL commands are being executed, run the SQL Profiler for confirmation (see the section called "How do I speed up my database queries?" earlier in this chapter for details on using the SQL Profiler). This tool is especially helpful when used with applications that make use of declarative data binding, or with frameworks that handle data access for you.

Clearing the SQL Cache when Testing in SSMS
SQL Server uses an intelligent caching system to enhance performance. If you run frequent queries against a certain table, SQL Server will recognize that fact and store the source (and result data) of those queries in its internal cache. By doing so, future matching queries won't need to look up this data until the next time it changes.

This functionality, while useful, can be confusing if you conduct your tests by running your queries from SSMS -- some of your query information may be cached, so your queries will run faster the second time you execute them.

To ensure that you make valid comparisons that don't return cached information, clear your cache each time you run the query. The following script does just this -- first it drops caches, then it calls a CHECKPOINT to flush pending changes from memory to disk, and finally it clears any data that has been stored in memory:

DBCC FREESESSIONCACHE DBCC FREEPROCCACHE DBCC FREESYSTEMCACHE('ALL') CHECKPOINT DBCC DROPCLEANBUFFERS GO -- Your query goes here

Once you're able to duplicate the problem in SSMS, you can dig into the query itself.

Checking for Large Result Sets

If your query returns more rows than you expected it to, there are two main problems to look at -- cross joins and incomplete WHERE clauses.

A cross join occurs when you fail to specify a join correctly. Here's an example:

SELECT * FROM Customers, Orders, [Order Details], Products

In the above query, we haven't specified how the tables should be joined, so the SQL interpreter will attempt to return every possible combination. That means that our result set will include every Order combined with every Customer (not just the Orders that each Customer made). So this query returns about 12.5 billion rows (91 Customers × 830 Orders × 2155 Order Details × 77 Products) -- that's roughly 7.5GB of data.

That return is obviously way out of line, considering there are only 830 orders in the system. Of course, this is a slightly exaggerated example for demonstration purposes, but it's easy to see how a single cross join can waste a lot of database resources (CPU and memory) and delay network traffic between the database and web server.

An incomplete WHERE clause isn't quite as bad, but can still return more rows than you need. The following query returns 2155 rows:

SELECT * FROM [Order Details]

This one, on the other hand, returns three rows:

SELECT * FROM [Order Details] WHERE OrderID = 10252

ADO.NET makes it really easy to filter your data on the server, but unfortunately this feature is a double-edged sword -- it can mask problems with a large result set. That's why it's important to verify the problem with real, systematic measurement rather than just assume that a Gridview displaying only a handful of rows couldn't possibly be the source of the problem.

Checking the Query Plan

If your query is indeed returning the correct number of rows, but still takes too long, the next step is to look at the query plan, which is a visual representation of the steps that your query takes to return its result set.

You can view the estimated query execution plan in SSMS if you first select the query, then select Display Estimated Execution Plan from the Query menu (tor use the toolbar button or the keyboard shortcut -- Ctrl-L). You'll also have the option to include the actual query execution plan (also available from the Query menu, the toolbar, and via the keyboard shortcut Ctrl-M). The actual plan is a little more accurate than the estimated one, but requires that you actually execute the query and wait for it to complete.

Let's look at the actual execution plan for the uspGetBillOfMaterials stored procedure in the AdventureWorks sample database that comes with SQL Server. Enter the following text in the SSMS query window, then turn on the Include Actual Execution Plan option and execute the query:

EXEC dbo.uspGetBillOfMaterials 800, '2001-01-09'

Figure 15.16 shows the result.

Figure 15.16. The execution plan for the uspGetBillOfMaterials stored procedure (click to view image)

Figure 15.17 shows a close-up of the bottom right-hand corner of our plan.

Figure 15.17. A close-up of the execution plan for the uspGetBillOfMaterials stored procedure (click to view image)

You'll need to look for a few important things when you're analyzing an execution plan:

Thick lines in the execution plan indicate large amounts of data being passed between steps. I was once troubleshooting an extremely slow summary report query that returned only a dozen rows. When I looked at the execution plan, I saw that some of the lines between steps were an inch thick -- this indicated billions of rows being passed between those steps, which were then filtered down to the final dozen rows displayed in the browser. The solution was to modify the query to ensure that the data was filtered as early as possible.
Large percentage numbers indicate the most expensive operations -- the value of 44% in Figure 15.17 is one example of this.
If one of the steps on your plan contains the word "scan" (or, in particular, "Table Scan"), this is an indication that the SQL engine had to step through every row in a table to find the data that it was after. This is usually associated with a high Cost value. There are occasions when a table scan is acceptable -- such as when you're performing a lookup against a very small table -- but in general they're best avoided.

If you see a problem, you can troubleshoot it in SSMS: modify the query and view the effect of your change on the execution plan.

If it looks as though your issue may be the result of an indexing problem, the best solution is to right-click the query and select Analyze Query in Database Engine Tuning Advisor. The DTA will launch with all the necessary options preselected, so all you need to do is click the Start Analysis button. Figure 15.18 shows the results of one such analysis.

Figure 15.18. Analyzing a query in the DTA (click to view image)

As you can see, the DTA has recommended two index changes and one statistical change that should improve this query's performance by 31%. Of course, you'll need to consider the effect that these additional indexes will have on updates to the affected tables. In this case, since the tables in this particular example are probably updated rather infrequently, I think that these new indexes make sense. You can apply or save these changes via the Actions menu.

Eliminating Cursors

You'll want to look for and eliminate any unnecessary cursors -- pointers for traversing records in the database.

Cursors let you write in a procedural style, applying logic to a single table row at a time. While it can be tempting to drop back to those skills that are most familiar to you in sticky situations, cursor-based queries will prevent the database engine from taking advantage of the index optimizations and set-based operations for which it was designed.

Resist the urge and get rid of your cursors!

I've written a lot of SQL in ten years of professional programming, and I've yet to encounter a case where cursors were required. I recently rewrote someone else's complex query from using cursors to standard SQL, and the time for the resulting operation dropped from eight hours to just over one minute.

Think about how to describe the problem as a bulk operation. For example, suppose your mode of thinking about a query was something like this:

"I'll loop through the orders table, get the product ID, then grab the price, and compare it to ..."

Instead, consider rephrasing it to something like this:

"I want to find all orders for products that have prices greater than a certain amount ..."

Remember that you can use common table expressions (CTEs), table variables, and temporary tables if you're stuck. While these fallback options aren't as efficient as performing a bulk operation, they at least allow the query engine to make use of indexes.

The Problem with SELECT *

Most developers will tell you that SELECT * queries are bad, but for the wrong reason.

The commonly understood reason is that SELECT * is wasteful because it returns columns that you don't need. While this is true, most normalized tables don't contain that many columns, so these extra rows usually won't have a noticeable impact on your site's performance unless they number in the millions.

Often, the bigger problem with SELECT * is the effect it will have on the execution plan. While SQL Server primarily uses indexes to look up your data, if the index happens to contain all of the columns you request, it won't even need to look in the table. This concept is known as index coverage.

Compare the following two queries (against the sample AdventureWorks database):

SELECT * FROM Production.TransactionHistoryArchive WHERE ReferenceOrderID < 100 SELECT ReferenceOrderLineID FROM Production.TransactionHistoryArchive WHERE ReferenceOrderID <>

  In both cases, we're returning the same number of rows, and the SELECT * query only returns 15KB more data than the second query. However, take a look at the execution plans shown in Figure 15.19.
  Figure 15.19. The execution plan for two queries -- one using SELECT *, and one using the table name (click to view image)
  You'll notice that the first query took 99% of the relative work for both queries. The second query was able to look up the values in the index via an index seek -- a search that touches on only those rows that qualify. The first query, however, had to scan all the rows in the table. In this case, the fact that the requested columns were all contained in the search index resulted in a performance difference of nearly one hundred-fold.
  It's important to include commonly queried data in your indexes -- something that's simply not feasible if you're using SELECT *. If you just query the rows you need, the DTA will be able to recommend indexes to cover them.
  Accessing More Information
  There's a plethora of resources to which you can turn when you're stuck on a really difficult SQL database issue. Here are just a few of them:
  The Microsoft TechNet article on troubleshooting performance problems in SQL Server 2005
SQLTeam.com -- one of many SQL Server community forums
The SitePoint Databases Forum
   Summary
    Performance optimization is an iterative process -- be prepared to follow the repetitive steps of analyzing your site's performance, tuning your application, analyzing the performance again, then tuning some more, until your site performs the way you want it to. Premature optimization -- tuning without understanding what's causing the slowdown -- is likely to cause more problems than it solves.
  ASP.NET and SQL Server 2005 power some of the most popular and powerful sites upon the planet, including MySpace, which serves billions of page views per day. You've got all the tools you need to get the maximum possible use out of your web server -- I hope the tips in this chapter will help you to put them to work.
  That's it for this chpater of The ASP.NET 2.0 Anthology, 101 Essential Tips, Tricks & Hacks. Feel free to download this chapter -- along with three others -- for offline reference.
www.sitepoint.com



Speed Up Your Site! 8 ASP.NET Performance Tips 5
2009-08-03T12:54:00.000+07:00
How can I gain more control over the ASP.NET cache?
    As we've seen, declarative caching provides a great return on investment -- it's very easy to enable, and will give you some immediate performance benefits. However, you can gain even more benefit from the ASP.NET cache with only a little more work.
  Solution
  If you'd like to really take advantage of caching in ASP.NET, it's time you met the Cache API. Declarative caching might be easy to set up, but it can only take you so far. Unlike declarative caching, which stores and reuses rendered HTML, the Cache API allows you to store data efficiently in your application logic or code-behind code.
  The simplest way to think of the ASP.NET cache is to compare it to the Application object. They're similar in that you can use both to store objects or values by a string key:
  Cache["States"] = new string[] {"Alabama","Arkansas","Alaska"};
Cache["ProductData"] = GetProductDataset();
So what's the difference between the Application object and the cache for the storage of information? ASP.NET can remove items from the cache whenever it needs to free up memory. The cache has a limited amount of memory to work with, so when new content is added to the cache, the cache usually has to delete some older, cached data.
  Different classes of information can be stored in your cache:
  Expensive data is information that you want to keep in the cache whenever possible. The term "expensive" refers to the fact that the generation of this class of data involves valuable resources (database or processing power).
Inexpensive data refers to all of the other types of information that you'd like to put in the cache if there happens to be room, but is not particularly resource-intensive to generate.
   The challenge is to prevent the inexpensive data from pushing the expensive data out of the cache.
  The Cache object comes with some features that give you some control over which items are placed in the cache, and how long they stay there. Using the Cache object, you can apply custom cache dependencies, explicitly set cache expiration policies, and define callback events that fire when an item is removed from the cache (so you can decide whether you'd like to add it to the cache again).
  One of my favorite features is the sliding expiration, which is a setting that lets you specify that an item should stay in the cache -- as long as it has been used within a certain period of time:
  Cache.Insert("ProductData", GetProducts(), null, 
    System.Web.Caching.Cache.NoAbsoluteExpiration,
    TimeSpan.FromMinutes(10));
  The above code tells the cache that we'd like it to keep our Products data set, as long as it has been used in the past ten minutes. The benefit of this approach is that frequently used data will stay cached, and infrequently used data will expire and stop taking up valuable space.
  We can customize the settings for our cache, for example, setting a longer sliding expiration timeframe on data that's more expensive (such as that which results from a web service call). We could even add a cache dependency on the results of a GetLastUpdateTimestamp web service call to keep the data current if needed. Remember, though, that any data can still be removed from the cache at any time -- our sliding expiration time setting is really just a suggestion to the cache system.
  Discussion
  Once you've begun to cache your data, you'll begin to see the benefit of what are some tried and true cache access patterns. Steven Smith wrote about the cache data reference pattern in his excellent MSDN article. Here's some code that implements this pattern:
  public DataTable GetCustomers(bool BypassCache)
{
  string cacheKey = "CustomersDataTable";
  object cacheItem = Cache[cacheKey] as DataTable;
  if((BypassCache) || (cacheItem == null))
  {
    cacheItem = GetCustomersFromDataSource();
    Cache.Insert(cacheKey, cacheItem, null,
        DateTime.Now.AddSeconds(GetCacheSecondsFromConfig(cacheKey),
        TimeSpan.Zero);
  }
  return (DataTable)cacheItem;
}
  Smith's article explains the technique in more detail, but the most important point to note is the possibility that the object may not be in cache, or could potentially be removed at any time. The above code is safe because it loads the cached object, checks whether the object is null, and, if so, loads the object data and adds it back to the cache.
  Another of my favorite cache patterns is one that Gavin Joyce uses on his DotNetKicks site -- the reluctant cache pattern, which relies on his ReluctantCacheHelper class.  This pattern prevents an application from adding to the cache information that's unlikely to be used.
  For example, when Google indexes your site, it will load every page that it can find. If your site implements a cache that is used by a large number of pages, your server will perform a lot of unnecessary work adding data to the cache, only for that data to be immediately dropped from the cache as other pages are added. Similar to the sliding expiration pattern, but in reverse, this pattern only adds data to the cache if it's been used a lot recently. Here's an example that implements this pattern:
  public static List GetCustomers() {
  string cacheKey = "Customers";
  int cacheDurationInSeconds = 5; // low number for demo purposes
  object customers = HttpRuntime.Cache[cacheKey] as List;
  if (customers == null) {
    customers = CustomerDao.GetCustomers();
    if (new ReluctantCacheHelper(cacheKey, 
        cacheDurationInSeconds, 2).ThresholdHasBeenReached)
    {
      HttpRuntime.Cache.Insert(cacheKey,
          customers, 
          null, 
          DateTime.Now.AddSeconds(cacheDurationInSeconds),
          System.Web.Caching.Cache.NoSlidingExpiration);
    }
  }
  return (List)customers;
}
  How do I speed up my database queries?
    We've looked at a few ways to optimize your ASP.NET code, but if your queries are slow, you'll still have a site that drags its heels. You can hide the problem to some degree if you cache your data or add servers to your web farm, but eventually you will need to deal with your slow queries.
  Of course, the best bet is to work with a good Database Administrator (DBA). We're ASP.NET developers, and while we can't help but learn about databases as we work with them, database administration is not our full-time job. A good DBA is by far the best solution to a database problem, but sometimes, it's just not an option. If you work on a team without a DBA, or you have limited access to your DBA, you need to do your best to solve problems when you can.
  Slow Query or Slow Database?
It's important to decide whether you're dealing with one slow query or a whole slow database. Is one particular page slow, or is the whole site groaning? This solution will focus on the former; if you can narrow your database performance problems down to individual queries, refer to the section called "How can I troubleshoot a slow query?" later in this chapter.
  Solution
  Use the SQL Profiler and Database Tuning Advisor, located in the SQL Server Performance Tools folder.
  Tuning a database server is hard. Initially, it can be difficult to find out what's responsible for slowing things down. Even then, fixing one problem (for example, applying indexes to a table to improve the speed of SELECT statements) can introduce new problems (such as slower INSERTs and UPDATEs).
  Fortunately, the existence of the SQL Performance Tools means you don't have to bother with guesswork.
  The SQL Profiler captures what's going on in your database, including which SQL statements are being executed, who's executing them, and how long they're taking. The profiler is the first step to determining what's actually happening on your server.
  Note that the profiler captures both ad hoc and dynamic SQL. This means that the profiler is especially useful when control, library, or framework code is making a call in your database -- you may not have access to the ASP.NET code, but the profiler will reveal exactly which queries are being executed, and how long they are taking.
  It's best if you can run a profiler trace on your actual production system, but this may not always be possible -- profiling a server slows the server down, and the site's regular users may not appreciate the extra delays. If you can't run on the production system, you can still gain a reasonable idea of server activity on a local or development server by simulating the way real users would using your site on the live server.
  Running the profiler can be a bit daunting the first time -- there are numerous advanced settings to monitor and tweak. It's best to start out with a predefined template like the one I've chosen in Figure 15.9. The two most useful templates for general performance diagnostics are the TSQL_Duration and Tuning templates.
  Figure 15.9. Selecting the TSQL_Duration template (click to view image)
  The TSQL_Duration template is useful for giving you a quick snapshot of the queries and stored procedures that take the longest time to execute. Figure 15.10 shows some sample queries running against the Northwind example database. The slowest query -- the query with the greatest duration value -- is highlighted at the bottom of the list.
  Figure 15.10. Query duration times in SQL Server Profiler (click to view image)
  In a simple case like the one above, you may be able to deduce enough information from the TSQL_Duration trace to begin tuning a specific query. If you're at all in doubt, however, it's best to run the profiler with the Tuning template and analyze the results in the Database Tuning Advisor (also referred to as the DTA), a tool for analyzing database performance and suggesting which tables should be indexed.
  To do this, first save your trace file from the profiler, as shown in Figure 15.11.
  Figure 15.11. Saving a trace file from SQL Server Profiler (click to view image)
  Now, we'll use the DTA to open the trace file that we just saved, as I've done in Figure 15.12, and click the Start Analysis button.
  Figure 15.12. Loading the trace file in the Database Tuning Advisor (click to view image)
  For my sample queries, DTA recommended that I apply a few indexes, to produce an estimated performance improvement of 5%, as shown in Figure 15.13. (The Northwind database is already more or less indexed; your estimated improvement should be a lot higher, with any luck.)
  Figure 15.13. The index recommendations suggested by the DTA (click to view image)
  If you scroll to the right, so that the Description column is visible, you'll see exactly which indexes and statistical changes the DTA recommends. Click on a recommendation to see a preview of the script that will add the proposed index, as shown in Figure 15.14.
  Figure 15.14. Viewing a preview of the script for applying one of the recommended indexes (click to view image)
  To implement these changes, I suggest you save the recommendations (Actions > Save Recommendations...), review them in SQL Server Management Studio (SSMS), and apply them if you feel comfortable with them. Once you've done this, repeat your original profiling test and verify that the changes have improved your database performance.
  Running the DTA with a SQL Workload Script File
Our walkthrough of the DTA used a SQL Server Trace file for the workload, but you can also use the DTA against a SQL script. Here's an abbreviated copy of the script I used for this walkthrough:
  Example 15.10. SampleSqlWorkload.sql (excerpt)

USE [Northwind]
GO
SELECT * FROM [Order Details] od
INNER JOIN Orders o on o.OrderID = od.OrderID
GO
SELECT * FROM [Category Sales for 1997]
GO
SELECT * FROM Invoices
GO
SELECT COUNT(OrderID) OrderCount, ShipPostalCode 
    FROM Orders
GROUP BY ShipPostalCode
ORDER BY COUNT(OrderID) DESC
GO
EXEC [Ten Most Expensive Products]
GO
SELECT COUNT(OrderID) OrderCount, c.CustomerID, 
    c.ContactName
FROM Orders o INNER JOIN Customers c 
    ON o.CustomerID = c.CustomerID
GROUP BY c.CustomerID, c.ContactName 
sORDER BY COUNT(OrderID) DESC
GO
SELECT LEN(ContactName), ContactName
FROM Customers ORDER BY LEN(ContactName) DESC
GO
  The important point to note is that there are GO separators between statements, which ensures that they're executed independently. You'll want your SQL workload script file to simulate actual usage, which means that you should include repeated calls to the most commonly used queries.
  Using the Performance Dashboard
SQL Server includes Dynamic Management Views (DMVs) -- database views that contain lots of useful management and troubleshooting information about your database. All the DMV views begin with the prefix sys.dm_; for example: sys.dm_index_usage_stats.
  SSMS includes some built-in reports that leverage SQL Server Reporting Services as well as the DMVs. You can view these reports in SSMS if you right-click a database and select Reports > Standard Reports....
  SQL Server SP2 includes the ability to include custom reports, and one of the first to be released is the Performance Dashboard. Once it's installed, the Performance Dashboard gives you a graphical snapshot that's visible in your browser, without you having to run a trace. Figure 15.15 shows the dashboard in action.
  Figure 15.15. Viewing a handy third-party custom report in the Performance Dashboard (click to view image)
  Discussion
  One important aspect of troubleshooting a slow database is to understand what's making it run slowly. There are many potential causes of slow performance, but some common problems head the list. Let's look at a few of them.
www.sitepoint.com



Speed Up Your Site! 8 ASP.NET Performance Tips 4
2009-08-03T12:51:00.000+07:00
How can I improve the speed of my site?
    Most ASP.NET web servers perform a lot of unnecessarily repetitive work.
  For example, suppose you have a page with a DataGrid bound to a table called Products. Every time a user requests the Products page, ASP.NET has to:
  Look up the products data in the database.

Process the page.

Databind the product data.

Render the results to HTML.

Output the results to the browser.
   If we assume the products list changes infrequently in comparison to how often it is requested by a user, most of that work is unnecessary. Instead of doing all that work to send the same HTML to all users, why not just store the HTML and reuse it until the Products table changes?
  Solution
  The ASP.NET cache provides the key to efficient storage and reuse of our HTML.
  There are several ways to use the cache; we'll focus on the easiest tricks to get you started, then point you toward some resources that will help you tackle more advanced ways to utilize the cache.
  The simplest solution is to use the OutputCache directive on your pages or user controls. For example, the following page will be cached for one hour (3600 seconds). You can refresh the page all you like, but the value of DateTime. Now won't change until the page is cleared from the cache. Here's the code that retrieves the current time:
  Example 15.7. OutputCacheSimple.aspx (excerpt)



<%@ Page Language="C#" AutoEventWireup="true"   

    CodeBehind="OutputCacheSimple.aspx.cs"

    Inherits="chapter_15_performance.Performance.OutputCacheSimple" 

%>

<%@ OutputCache Duration="3600" VaryByParam="none" %>





  Output Cache Example





  


    Output Cache Example

    

      <%= DateTime.Now.ToLongTimeString() %>

    

  



  Figure 15.5 represents our page at 11:01:41 p.m.
  Figure 15.5. Loading a cached page for the first time (click to view image)
  Figure 15.6 shows what it looks like at 11:23:01 p.m.
  Figure 15.6. Subsequent reloads of a cached page showing no changes to the page content (click to view image)
  Notice that the time didn't change, as the page wasn't re-rendered.
  Now let's look at a slightly more complex caching example:
  Example 15.8. OutputCache.aspx (excerpt)



<%@ Page Language="C#" AutoEventWireup="true"

    CodeBehind="OutputCache.aspx.cs" 

    Inherits="chapter_15_performance.Performance.OutputCache" %>

<%@ OutputCache Duration="30" VaryByParam="none" %>





  Output Cache Example

  





  


  

  <% System.Threading.Thread.Sleep(5000); %>

  Output Cache Example

  

    Time written by ASP.NET:

    <%= DateTime.Now.ToLongTimeString() %>

  

  

    Time written by Javascript:

    

  

  

    

  





  The above page writes out the current time according to both ASP.NET (server side, cached) and JavaScript (client side, not cached). Additionally, if the JavaScript time is more than two seconds after the ASP.NET time, the page will report that it has probably been cached.
  The first time this page is viewed, there's a five-second delay (due to the call to Thread.Sleep), then the page shown in Figure 15.7 is displayed.
  Figure 15.7. The page output on first load (click to view image)
  But if you refresh the page within 30 seconds, you'll notice two differences. First, the page will return immediately. Second, it looks like Figure 15.8.
  Figure 15.8. The page output 30 seconds after its initial load (click to view image)
  Using VaryByParam to Cache Parameterized Pages

When you start to consider which pages in your application could be cached, you'll probably discover that many of them contain content that's 90% static. The remaining 10% of these pages is likely to contain one or two tiny portions that vary frequently. For example, consider a page in the example Northwind database that displays catalog information, including products filtered by category. The category is set by a parameter in the query string, so the following two URLs will yield different results:
  http://www.contoso.com/Northwind/Products.aspx?Category=Seafood

http://www.contoso.com/Northwind/Products.aspx?Category=Produce
  The novice programmer might apply the following code to cache these pages:
  <%@ OutputCache Duration="30" %>
  However, if you were to apply this code you'd quickly discover a problem -- the category filter would stop working. The first version of the page that was displayed would be cached, so the filtering logic would be ignored on subsequent page views.
  That's the exact function for which the VaryByParam attribute is used. In this case, we'd change the OutputCache directive to the following:
  <%@ OutputCache Duration="30" VaryByParam="Category" %>
The VaryByParam attribute tells the cache system to store a different version of the page every time it sees a new value for Category in the URL. Once this attribute is in place, our users will be able to access a cached copy of the page for both the Seafood and Produce categories.
  Keep in mind that storing different versions of the page for each parameter value isn't always the best idea -- in cases where you have many different parameter values, you can quickly use a large amount of memory to hold all possible variations of the page. Use VaryByParam when your pages utilizes a limited number of parameter values.
  Note that the number of seconds displayed in the JavaScript-generated time has updated to 59 seconds, while the ASP.NET time still shows 39. What this discrepancy suggests is that the server is sending the same HTML to the client for each request. Suppose that instead of just displaying the current time, we'd bound several GridViews to the results of several expensive database queries. With caching applied to such a page, the savings would be considerable.
  You don't have to cache a page for long to see significant performance increases -- a cache of one minute or less can improve your site's performance dramatically. For example, adding a cache to a simple page that just binds a GridView to the Products table in the example Northwind database will increase the performance of that page by about 500%, and for a page that performs a complex database query or processor-intensive calculation, this saving is likely to be amplified even further.
  Using Post-cache Substitution

While the OutputCache directive allows you to specify that the cache should vary with a specific parameter, it's not really efficient to cache a multitude of copies of one page that are nearly all identical.
  Post-cache substitution, using the Substitution control, allows you to inject dynamic content into a cached page. The result is that you can cache some pages that you probably thought were unable to be cached. Read more on this subject in Scott Guthrie's article on the topic.
  One of the problems you might notice with this approach, however, is latency -- the time delay between the point at which your data is updated and the moment when that same updated data reaches a user's browser. In the examples we've looked at in this solution, we displayed the same timestamp for 30 seconds after the page was rendered -- this is great for performance, but might be a problem if your users require the data to always be up to date.
  Fortunately, ASP.NET 2.0 has a solution to this problem, which we'll look at next.
  How do I refresh my cache when the data changes?
    As we saw in the previous tip, judicious use of output caching can provide dramatic improvements in your site's performance. Output caching works by saving the generated HTML for a rendered ASP.NET page. As long as the cache is valid, future requests for that page will just return that stored HTML, rather than processing the page again, which means no page parsing, hits to the database, data binding -- any of those tasks that require precious bandwidth or processor cycles. Used correctly, caching can improve your requests-per-second on a high-traffic page by a factor of 100 or more.
  For example, suppose you had a page that contained a DataGrid bound to a table called Products. Without caching, every page request would require ASP.NET to look up the product data in the database, process the page, data bind the product data, render the results to HTML, and output the results to the browser.
  If the page was cached, only the first request for this page would require all that work; after that, ASP.NET would just skip all the hard work and serve up the HTML until the cache expired. The end result would be the same whether or not a cache was used: the same HTML would be sent to the browser. However, since a lot less work and network traffic is required to display cached HTML, the server can serve the cached page much faster and to more people.
  One problem with cached pages is that they don't pick up data that has changed right away. To continue with the example above: if we were to add a new product to the Products table, it wouldn't show up on the page until the cache expired. Fortunately, ASP.NET 2.0 provides a good mechanism to refresh your cache automatically when the underlying data changes.
  Solution
  The SQL Cache Dependency was created to solve this problem. A few steps are required to set it up, but once it's up and running, you can use it throughout your whole application.
  Using SQL Cache Dependencies with Older Versions of SQL Server

In this book I'll only cover the steps for configuring SQL Server Cache Dependencies on SQL Server 2005; there's a wealth of information on MSDN about how to set it up on SQL Server 2000:
  ASP.NET SQL Server Registration Tool (Aspnet_regsql.exe)
Caching in ASP.NET with the SqlCacheDependency Class
Walkthrough: Using ASP.NET Output Caching with SQL Server
   First, you'll need to make sure you've enabled SQL Server Service Broker for your database. You can confirm that with the following query:
  ALTER DATABASE Northwind SET ENABLE_BROKER;
  Next, you'll need to start the SQL Dependency event listener. The recommended place to make the change that triggers this listener is in the Application_Start method of Global.asax:
  Example 15.9. Global.asax (excerpt)



void Application_Start(object sender, EventArgs e)

{

  string northwindConnection = WebConfigurationManager.ConnectionStr

➥ings["NorthwindConnectionString1"].ConnectionString;

  SqlDependency.Start(northwindConnection);

}
  Once the above code has been added to the Global.asax file, our connection can employ an SQL Cache Dependency.
  To illustrate how an SQL Dependency is utilized, let's look at an example -- a simple GridView that's bound to a table. We'll drag the good old Northwind Products table onto a new page, then set the following two attributes in the SqlDataSource control:
  EnableCaching = "True" SqlCacheDependency =

    "NorthwindConnectionString1:Products"
  With this simple line of code in place, the GridView won't read the Products table again until it changes. As soon as the Products table changes, though, SQL Server will notify ASP.NET to dump the cache, and the subsequent page request will reload the page from the database. The end result is that our application gains all of the performance benefits that come with caching, but our users will never see stale data.
www.sitepoint.com




Speed Up Your Site! 8 ASP.NET Performance Tips 3
2009-08-03T12:41:00.003+07:00
How can I decrease the bandwidth that my site uses?
    ASP.NET abstracts a lot of traditional web development details from the developer. Just drag and drop a few controls on a form, set some properties, write a little bit of code, and -- bam! -- you've got a functioning web site.
  However, that doesn't mean the resulting HTML markup will necessarily be efficient or small. It's not unusual to see ASP.NET pages that contain more than 100 kilobytes of markup. I recommend that you keep a close eye on the HTML markup that results from your ASP.NET web pages -- to keep these file sizes in check can sometimes require additional effort, which is one reason we covered the topic of web standards in Chapter 9, ASP.NET and Web Standards.
  Solutions
  The first rule of ASP.NET bandwidth control is to know how large your pages are. In Internet Explorer, the File > Properties dialog will tell you how many kilobytes of HTML markup the current page has produced, as Figure 15.2 shows. Firefox has a similar dialog, pictured in Figure 15.3, which can be accessed by selecting Tools > Page Info.
  Figure 15.2. Viewing page information in Internet Explorer (click to view image)
  Figure 15.3. Viewing page information in Firefox (click to view image)

However, note that the Size field in Firefox reports a much smaller number than does IE 7 -- 13,976 bytes versus 49,774 bytes. That's because Firefox shows the actual number of bytes that came down over the wire, whereas IE 7 shows the size of the page after it has been received by the browser.How is such a discrepancy possible? Well, the ASP.NET web site uses HTTP compression to decrease the page size before sending the page. HTTP compression is a W3C standard that allows the server to provide a GZIP-compressed version of the HTML content to the client, at the cost of a very minor increase in CPU time. The client receives the compressed content, then decompresses it on the fly before rendering the page. Right off the bat, you can see that this is just one easy way to reduce the amount of bandwidth you use by an impressive 72% -- simply flip the switch to enable HTTP compression for your web site.You can enable HTTP compression in two ways. The first takes place at the web server level; the second is implemented via a custom HTTP module at the ASP.NET application level.       Enabling HTTP Compression Support in IIS 6
  Use the IIS Service Manager to enable HTTP Compression in IIS 6. Right-click the node for your web site and select Properties. The Service tab contains the settings relevant to compression, as Figure 15.4 shows.
  Manual Configuration is Only Necessary in IIS 6
That's right: it's only necessary to configure IIS to enable HTTP compression in IIS 6 and earlier, as IIS 7 enables static compression by default. Windows Server 2008 (which had yet to be released at the time of this writing) may offer a user interface to configure dynamic HTTP compression, but Vista's IIS Manager doesn't.
  Figure 15.4. Configuring HTTP compression in IIS 6 (click to view image)
  The compression setting available in the GUI works; however, it only affects static content, such as HTML pages and CSS files. This setting won't do anything to compress dynamic content in ASPX pages. We must resort to editing the metabase -- the IIS database for configuration and metadata storage -- to deploy dynamic content compression:
  Open the metabase in Notepad. For IIS 6, this is located at C:\WINDOWS\system32\inetsrv\MetaBase.xml. For IIS 5, the file is a binary file, so you'll need to download the Meta-data Edit tool instead.
Search for the  tag. There should be two  entries: one for deflate and one for GZIP -- the two methods of compression that IIS supports. By default, IIS uses GZIP; deflate is rarely used.
Search for the HcScriptFileExtensions section. Add to the list aspx, asmx, php, cgi, and any other file extensions that you want dynamically compressed. Follow the existing format carefully -- it's return-delimited, and any extra spaces will prevent the file extensions from working. Make the same changes in both deflate and GZIP.
Set HcDynamicCompressionLevel to level 9 (it has a default value of 0, which means "no compression"). I recommend level 9, based on several reports that I've read on the Web suggesting that level 10 requires much more CPU time, while offering only a minimal reduction in file size over level 9. Make this change for both deflate and GZIP.
   Note that this is a global compression rule that will affect all web sites. This setting is usually what you'll want, since HTTP compression is so effective and the cost is nominal. However, some poorly coded ASP.NET web sites may be incompatible with compression. In those circumstances, you may want to enable or disable compression on a per-site or per-folder basis -- a setting that's also supported by IIS. The easiest way to configure this setting is to use the command line adsutil.vbs utility:
  C:\Inetpub\AdminScripts\>adsutil.vbs set w3svc/ (site#) /root/DoStat
➥icCompression False
C:\Inetpub\AdminScripts\>adsutil.vbs set w3svc/ (site#) /root/DoDyna
➥micCompression False
  The (site#) number can be obtained from the log properties dialog in the IIS server properties, and usually takes the form W3SVCn, where n is an arbitrary site number.
  Enabling HTTP Compression Support in an ASP.NET Application
  Perhaps you don't have control over the IIS settings on your server. Or maybe you'd just like a way to enable compression for your specific ASP.NET application. That's possible too.
  The open source HttpCompress library is very easy to incorporate into an ASP.NET web site. First, download the latest version of HttpCompress from the official web site. 
  Place the blowery.Web.HttpCompress.dll binary somewhere logical, and add a reference to it.
  Next, add the following compression-specific configuration section to your site's Web.config:
  Example 15.5. Web.config (excerpt)



 





 
   
   
   
 

  Finally, bring the actual compression HTTP module into the pipeline:
  Example 15.6. Web.config (excerpt)



 

  Once this is in place, you should see compressed ASPX content being returned to the browser. To verify that this is the case, use Port80 Software's convenient Real-Time Compression Checker.
  One limitation of the HttpCompress module approach is that only ASPX content that forms part of your application will be compressed; the CSS and JavaScript aren't served through the ASP.NET ISAPI handler, and will therefore remain uncompressed. As such, I recommend that you enable compression at the web server level whenever possible, so that these files also gain the benefits of compression.
www.sitepoint.com



Speed Up Your Site! 8 ASP.NET Performance Tips 2
2009-08-03T12:40:00.002+07:00
How can I decrease the size of the view state?
    One convenience of ASP.NET controls is that they can preserve state across postbacks -- a topic we've covered in depth in Chapter 6, Maintaining State. This, of course, is a feature that comes at a price -- to implement it, we add a hidden field to the page to store the control settings for transmission between the client and server, but depending on the controls the page uses, the view state can sometimes become quite large.
  One obvious way to reduce the size of view state is to turn it off if you don't need it. This adjustment can be performed either at the page level, or at the control level. If, for whatever reason, you can't disable the view state (for example, your page uses controls that are dependent upon the view state), there are a few other steps you can take to at least reduce its impact on your page size.
  Solutions
  You have two options for reducing the impact that view state has on your page size -- either compress the view state, or store it on the server.
  Compressing the View State
  The following simple CompressedViewStatePage class implements basic GZIP compression on the page's view state. It reduced the size of the ViewState object on my sample page from 20,442 bytes to 6,056 bytes -- an impressive 70% reduction in size! Here's the class in all its glory:
  Example 15.3. CompressedViewStatePage.cs (excerpt)

using System;
using System.IO.Compression;
using System.IO;
using System.Web.UI;
public class CompressedViewStatePage : System.Web.UI.Page
{
 static public byte[] Compress(byte[] b)
 {
   MemoryStream ms = new MemoryStream();
   GZipStream zs = new GZipStream(ms, CompressionMode.Compress);
   zs.Write(b, 0, b.Length);
   return ms.ToArray();
 }
 static public byte[] Decompress(byte[] b)
 {
   MemoryStream ms = new MemoryStream(b.Length);
   ms.Write(b, 0, b.Length);
   // last 4 bytes of GZipStream = length of decompressed data
   ms.Seek(-4, SeekOrigin.Current);
   byte[] lb = new byte[4];
   ms.Read(lb, 0, 4);
   int len = BitConverter.ToInt32(lb, 0);
   ms.Seek(0, SeekOrigin.Begin);
   byte[] ob = new byte[len];
   GZipStream zs = new GZipStream(ms, CompressionMode.Decompress);
   zs.Read(ob, 0, len);
   return ob;
 }
 protected override object LoadPageStateFromPersistenceMedium()
 {
   byte[] b = Convert.FromBase64String(Request.Form["__VSTATE"]);
   LosFormatter lf = new LosFormatter();
   return lf.Deserialize(Convert.ToBase64String(Decompress(b)));
 }
 protected override void SavePageStateToPersistenceMedium(
     object state
 )
 {
   LosFormatter lf = new LosFormatter();
   StringWriter sw = new StringWriter();
   lf.Serialize(sw, state);
   byte[] b = Convert.FromBase64String(sw.ToString());
   ClientScript.RegisterHiddenField("__VSTATE",
   Convert.ToBase64String(Compress(b)));
 }
}
  
 To use GZIP compression, simply inherit a specific page from the class, like this:
  public partial class MyPage : CompressedViewStatePage
  If you're worried about the performance implications of compressing your view state, don't be. It's far more likely that bandwidth is a greater bottleneck than CPU time on any given web server. Although there are exceptions to this rule, the GZIP algorithm is blazingly fast on the CPUs of today. Besides, if your server's CPU operates at 100% all the time, you have far graver problems to worry about than the size of a handful of pages.
  This compression algorithm could also be implemented as an HTTP module, which could then be applied to an entire site with a simple Web.config modification. I suggest you try implementing this module as an exercise, if you're keen. The MSDN article on building an HTTP module is a good place to start. 
  Storing View State on the Server
  The second option for reducing view state's impact on page size is to prevent view state data from being sent to the client altogether, and instead store the data on the server.
  The following ServerViewStatePage class allows us to use the Session object to store the view state:
  Example 15.4. ServerViewStatePage.cs (excerpt)

using System;
using System.Web.UI;
using System.Configuration;
using System.IO;
public class ServerViewStatePage : System.Web.UI.Page
{
 private const string _configKey = "ServerViewStateMode";
 private const string _formField = "__SERVERVIEWSTATEKEY";
 private string ViewStateData
 {
   get { return Request.Form[_formField]; }
   set { ClientScript.RegisterHiddenField(_formField, value); }
 }
 private string PersistenceType
 {
   get { return (ConfigurationManager.AppSettings[_configKey]
   ?? "").ToLower(); }
 }

 private object ToObject(string viewstate)
 {
   byte[] b = Convert.FromBase64String(viewstate);
   LosFormatter lf = new LosFormatter();
   return lf.Deserialize(Convert.ToBase64String(b));
 }
 private string ToBase64String(object state)
 {
   LosFormatter lf = new LosFormatter();
   StringWriter sw = new StringWriter();
   lf.Serialize(sw, state);
   byte[] b = Convert.FromBase64String(sw.ToString());
   return Convert.ToBase64String(b);
 }
 private string ToSession(string value)
 {
   string key = Guid.NewGuid().ToString();
   Session.Add(key, value);
   return key;
 }
 private string FromSession(string key)
 {
   string value = Convert.ToString(Session[key]);
   Session.Remove(key);
   return value;
 }
 protected override object LoadPageStateFromPersistenceMedium()
 {
   switch (PersistenceType)
   {
   case "session":
     return ToObject(FromSession(ViewStateData));
   default:
     return base.LoadPageStateFromPersistenceMedium();
   }
 }
 protected override void SavePageStateToPersistenceMedium(
     object ViewStateObject
 )
 {
   switch (PersistenceType)
   {
     case "session":
       ViewStateData = ToSession(ToBase64String(ViewStateObject));
       break;
     default:
       base.SavePageStateToPersistenceMedium(ViewStateObject);
       break;
   }
 }
}
  To use ServerViewStatePage, simply inherit a specific page from this class, like this:
  public partial class MyPage : ServerViewStatePage
  This class is configured via a single setting in Web.config: ServerViewStateMode. Once you've configured this setting, you'll notice that the ViewState object disappears from the page -- in its place is a simple ID that's used to look up the contents of the page's view state on the server, in the Session object. If you feel uncomfortable storing view state in Session, this class could easily be extended to store view state wherever you like -- in the file system, in the ASP.NET cache, or in a database.
  As usual, there's no free lunch here. The decision to push view state to the server and store it in Session has its own drawbacks. For example, the Session object could be lost if the IIS worker process recycles (a loss that does occur every so often in IIS, unless you've disabled this default behavior). Furthermore, any change to the underlying application files (such as editing Web.config, or adding new binaries to the bin folder of your application) will also cause the web application to recycle and Session data to be lost. And if you use more than one web server (such as in a web farm environment) you'll need to manage any shared session state that's stored in a database.
www.sitepoint.com



Speed Up Your Site! 8 ASP.NET Performance Tips 1
2009-08-03T12:36:00.002+07:00
Now that you've added the finishing touches to your web site and unleashed it onto the world, fame, fortune, and success will surely follow -- won't it?
  Unfortunately, your web application's success can lead to something less desirable -- performance and scaling problems. On a traditional desktop application, one thousand users translate to one thousand client computers chugging away, sharing the load of running your application. The application is effectively spread among all the users' machines. When it comes to a web application, though, those same thousand users are usually serviced by a single machine -- your web server.
  Success can come at a cost for web applications: a cost in bandwidth and server hardware. However, there are a few clever ways you can reduce -- and sometimes eliminate -- these problems. We'll take a look at some of the different approaches to improving the performance of an ASP.NET site in this chapter, which has been extracted from The ASP.NET 2.0 Anthology, 101 Essential Tips, Tricks & Hacks. Feel free to download this chapter -- along with three others -- for offline reference.
  How do I determine what to optimize?
    You want your web application to be the best, right? Like all of us, by "best" you mean "fastest." And what better way to create a blazingly fast application than to optimize everything? Optimize, optimize, optimize -- right? Wrong.
  Premature optimization refers to the fixing of a performance problem before you understand the problem, or before there even is a problem, and it's a bad idea.
  That's not to say that you should write sloppy, inefficient code. My point is that you should trust the ASP.NET Framework, and make use of the features that make it such a terrific environment in which to develop, until you hit a problem. Once you hit a problem, you should take the time to understand what that problem is, and only then should you start to look at how best to address it. Dr. Joseph M. Newcomer's essay, "Optimization: Your Worst Enemy," gives a fascinating overview of the perils of optimizing in the dark. 
  The tips in this chapter propose fairly lightweight solutions for some common performance issues. I've steered away from dramatic changes, because I don't want you to end up doubling your development or maintenance time in order to shave a meagre 2% off your page load time. While it is possible to bypass the in-built ASP.NET Page mechanism completely (by using Response.Write, or building an ASHX-based sites), I'm not a fan of these approaches. The ASP.NET system as a whole has been tuned and improved for more than half a decade, and it's reasonably fast straight out of the box. There's a good chance that trying to improve on it will result in a slower and less maintainable web site.
  So, with all that out of the way, let's assume that some of your pages are running slowly. How do you figure out what to fix?
  Solution
  Isolate the bottleneck in your site by measuring the actual speed of the site. This exercise can be performed using logs, database profiling, and tracing.
  We've discussed the task of logging using log4net in Chapter 13, Handling Errors. If you suspect that the database is the cause of the slowdown (for example, you know that your application makes use of some large queries), you can either step through the page in debug mode to see whether the database calls are taking a long time to return, or you can use the SQL Server Profiler discussed in the section called "How do I speed up my database queries?" later in this chapter. For a very basic analysis of what's going on in your pages, you can use the ASP.NET trace; while it's not nearly as good as a full-featured logging system, it's easy to implement and will provide you with plenty of timing information.
  The first step in using the trace is to get into the habit of adding trace statements. Write to the trace whenever you think there's something you might want to see when you debug future problems. Tracing doesn't have any real performance impact on your site until it's enabled in the Web.config, and when you need to troubleshoot a problem, you'll be glad it's there.
  There's more information on tracing in Chapter 13, Handling Errors, but the general idea is that you can write to the Trace object like this:
  Trace.Write("Here's a trace message.");
  Tracing is disabled by default; when you want your Trace.Write statements to actually do something, you'll need to turn tracing on in the Web.config file, as follows:
  Example 15.1. Web.config (excerpt)




 

  In this solution, we'll look at a sample page that performs a few different actions -- it makes a call to a web service, retrieves some data from a database, and throws an exception. Each function that we'll use writes a trace message when it begins and ends, via a straightforward utility method called writeTrace. However, it has one slightly complex aspect -- it uses the System.Diagnostics object to figure out the method name, so we don't have to pass it in. The code for our sample page is as follows:
  Example 15.2. Trace.aspx.cs (excerpt)

using System;
using System.Web;
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
 hitAWebservice();
 getSomeData();
 doSomeProcessing();
 breakSomething();
 displayTheResults();
}
private void getSomeData()
{
 writeTrace(true);
 simulateWaiting(8000);
 writeTrace(false);
}
private void hitAWebservice()
{
 writeTrace(true);
 Trace.Write("A message to demonstrate tracing.");
 simulateWaiting(2000);
 writeTrace(false);
}
private void doSomeProcessing()
{
 writeTrace(true);
 simulateWaiting(1000);
 writeTrace(false);
}
private void displayTheResults()
{
 writeTrace(true);
 simulateWaiting(500);
 writeTrace(false);
}
private void breakSomething()
{
 writeTrace(true);
 try
 {
   int superBig = int.MaxValue;
   superBig += 1;
 }
 catch (Exception ex)
 {
   Trace.Warn("Exception", "Oops", ex);
 }
}
private void writeTrace(bool enteringFunction)
{
 if (!Trace.IsEnabled)
 return;
 string callingFunctionName = "Undetermined method";
 string action = enteringFunction ? "Entering" : "Exiting";
 try
 {
   //Determine the name of the calling function.
   System.Diagnostics.StackTrace stackTrace =
   new System.Diagnostics.StackTrace();
   callingFunctionName =
   stackTrace.GetFrame(1).GetMethod().Name;
 }
 catch { }
 Trace.Write(action, callingFunctionName);
}
/// 

/// Wait a bit.
/// 

/// Time in milliseconds to wait.
private void simulateWaiting(int waitTime)
{
 System.Threading.Thread.Sleep(waitTime);
}
}
  Right, we've got our trace statements in place. Now, let's assume that this page is taking abnormally long to load, and we'd like to get to the bottom of the problem. With tracing enabled, we can simply load the page, then browse to Trace.axd within our web site; it's at http://localhost:1209/MySite/Trace.axd.
  Figure 15.1 shows the first part of the Trace.axd output that was returned from the previous code.
  Figure 15.1. Trace output for our sample page (click to view image)
  Table 15.1 shows the relevant portion of the trace output.
  Right away, we can see which aspect of our page load is taking the majority of time -- getSomeData takes eight seconds to execute. Without this information, we might have assumed the web service call was at fault and spent valuable time solving the wrong problem. This example shows how, armed with some real information, we can begin to fix the right problem.
  Snapshot of Trace Output for our Sample Page (click to view image)

         

www.sitepoint.com



16 Design Tools for Prototyping and Wireframing
2009-08-03T12:30:00.003+07:00
In recent years the number of tools available to help you document and design your web site has just exploded. It seems that we all need a wireframing or prototyping tool at our fingertips (at least in the design arena). So in order to save you the hard work required to find one, I've assembled this list. It can be expanded upon, so if you use an unlisted application, please let me know and I’ll add it to the list.
  The tools tend to fall into two categories:
  purpose-built applications
multifunctional applications
   Within these two groups I’ve found that usefulness can vary markedly among tools; some are only suitable for diagramming and wireframing, while others focus only on prototyping. The best are blessed with both capabilities and more.
  Purpose-built Applications
    1. Visio
    I will state upfront that I’m not a big fan of Visio (price: from $US259, demo available); I’ve used it from time to time on various projects, but I’ve always found it fiddly and time-consuming.
  Visio first started as an add-on to MS Word, filling the need for a business and technical diagramming tool and eventually graduating to separate product status. Visio’s power remains in the area of diagrammatical documentation; as a prototyping tool its functionality is limited at best. However Visio, like Omigraffle (below), is particularly suited to content map generation from CSV files. In the recent version, Visio 2007, the addition of the UML plugin has allowed for smoother importing of UML.
  
 Visio has also spawned a number of add-on tools; Swipr (which is free) is the most relevant as it allows for rapid export of wireframes and screen flows into a clickable HTML prototype. This is very handy for creating the entire prototype in one go and not having to link it together after exporting.
  Visio is only available on the Windows platform.
  2. OmniGraffle Pro
    Yes, I’m a little biased here; I do like OmniGraffle (price: $US199, demo available), especially the latest version. OmniGraffle is best suited as a tool for wireframes, screen flows, and content maps. It can also be used as a prototyping tool, with the ability to link canvases (pages). This allows you to produce a complete HTML prototype in one operation from OmniGraffle. You can, via the use of the notes function, easily annotate and complete the specification documentation for your prototype objects as you go.
  OmniGraffle Pro (click to view image)
  OmniGraffle provides an extensive series of Visio import and export functions, allowing for cross-platform team compatibility. It also allows you to import your base content structure from a CSV or XML file via a fully customizable rule-based layout function; this can be especially handy for documenting large and ever changing content maps.
  Support for OmniGraffle is supplemented by a large online community, as is evidenced by the resources available at Graffletopia. OmniGraffle is only available for the Mac.

3. Axure RP Pro
    Axure (price: $US589, demo available) has rapidly become the darling of the user experience and information architecture communities. The application allows you to construct wireframe models, document functional specifications, and generate prototypes, all using a built-in version control system. 
  Axure is an extremely rapid wireframing and prototype generation system that I’ve personally found pays for itself very quickly—in terms of increased productivity—despite its mid-level price tag. 
  Axure RP Pro (click to view image)
  Axure allows for complete flexibility when designing an interface, from standard widgets, to custom builds, to an open-ended canvas. However, Axure’s true killer functionality is the generation of rich HTML prototypes and Ajax-like interactions between states. It’s a little like Dreamweaver and its JavaScript generation, but good.
  A word of caution: if you do go looking under the hood of your HTML prototype, the code it generates is not for the fainthearted and should never be considered for use beyond a testing prototype. 
  The one downside for me is that it only runs on Windows. If it was available on the Mac, I would be very happy with Axure. 
  4. iRise Pro
    iRise (price: from $US6,995, demo available) was the first product of its type to market, and has advantages and disadvantages. The iRise product suite is very Axure-like in its functionality, and as the price suggests, is clearly geared towards an enterprise-level market. 
  Price aside, the one thing that I dislike about iRise is the user interface. Now this may be a personal preference, but you would think that if you’re going to be producing a tool for user experience professionals that you would at least make sure the UI is right. iRise suffers from a legacy interface that uses older GUI methods and techniques. I believe it’s in real need of an overhaul. 
  Still, if you’re looking at working with very large teams and need a comprehensive suite of products to span your entire prototype development life cycle, then iRise is worth a look. 
  5. Pencil 
    Pencil (free) is a Firefox plugin that professes to enable you to build wireframes and prototypes. As a prototyping tool it’s quite good, allowing you to quickly put together a reasonably high fidelity mockup. However, be aware you’ll still need to produce the visual design elements for Pencil, as it relies on dragging and dropping pre-made graphical elements.
  The output wireframe elements that ship with Pencil do tend to be based on the look and feel of a Windows desktop application. This really is undesirable for a web application, however you could modify this with your own page elements. 
  Another downside of Pencil is that its export functionality provides only a few image formats. This means that Pencil falls short of being a real interactive prototype development tool. 
  6. SmartDraw
    SmartDraw (price: from $US297, demo available) is marketed at the business diagramming sector, it’s not really a dedicated wireframing and prototyping application, but that doesn’t mean that it should be dismissed completely.
  It’s at the lower end of the market so you would expect a reduced functionality set compared to Axure. SmartDraw is aimed at the same market as Visio or OmniGraffle, with a standard template suite and few auto generation features. For prototyping SmartDraw allows you to add simple dynamic elements to a page, with the final output being a PDF file. There is no allowance for the representation of the transition between states on prototypes. 
  SmartDraw is only available for Windows, offering a degree of MS-Office Suite integration. 
  7. MockupScreens
    MockupScreens (price: from $US79, demo available) is a Windows-only application. It focuses primarily on the building of simple prototypes from a series of wireframes based around common screen elements.
  The prototyping functionality is limited, and only available within the MockupScreens application. I do note that you can export the screens as image files or as a very limited HTML rendering. This product is very much at the bottom end of the market in terms of cost and functionality, however this may suit your needs.
8. Balsamiq Mockups
    Balsamiq Mockups (price:$US79, demo available) is an interesting product running on Adobe AIR. Its representation of the interface elements has a refreshing hand-drawn, sketch-like quality to them. This does help promote the degree of changeability of the wireframes, as they look very much like a draft. If you lack the skills to create hand-drawn sketches then Balsamiq is a useful tool, as it allows you to produce quality roughs. Balsamiq also offers a standard collection of interactive screen elements, which is helpful to start off with. 
  
  
 Balsamiq Mockups also introduces BMML (a flavor of XML), which enables you to export your wireframes.  
  However rather than a prototyping tool, it’s more targeted at communicating the concepts of a proposed interface via wireframing and the like.
  9. Lucid Spec
    Lucid Spec (price: from $US499, demo available) from Elegance Technologies is a windows-based .NET application that’s almost a clone of Axure. It has a series of rapid screen drawing tools and a prototyping testing mode they call “instant application simulation,” which can be viewed in full screen mode or within the application. There’s even a stand-alone Lucid Spec Player that allows you to conduct prototype testing without the need for the full application. 
  The one aspect that Lucid Spec lacks is allowance for those between state, Ajax-like interactions. The interactions presented are very much based on the traditional, page-by-page screen flow. 
  10. ConceptDraw Pro
    ConceptDraw Pro (price: from $US249, demo available) promotes itself as an alternative to OmniGraffle and Visio, aiming at the business and technical diagramming market. 
  I’m pleased to say it does live up to these claims with various functions that are comparable to its competitors. 
  In addition to this it also has its own scripting language, ConceptDraw Basic. It’s possible with this scripting language to generate complex, customized prototypes. If you want to avoid going down the custom scripting route, you can use the standard export to HTML or PDF for prototyping. 
  ConceptDraw also has a Web Design plugin for us web designers, WebWave Plugin (price: from $US99, demo available). The WebWave Plugin streamlines the design process, allowing easier development of site and content structures to the mocking up of medium resolution wireframes—a bit like coloring in the gray boxes. You can then take the final mockup pages from ConceptDraw and produce the CSS and pages for a prototype. 
  ConceptDraw Pro is available for both Windows and Mac platforms.
  11. iPlotz
    iPlotz (price: free to $US99 per year) is a new web application aimed at the design and developmental life cycle market. It bundles project management functionality as well as wireframing, collaborative commenting, and testing prototype generation. Being browser-based this application can be used anywhere there is web access, allowing for true remote collaborative design and implementation. 
  Visually, iPlotz presents itself as an attractive and professional application. It’s a Flex application, and hence all the features from management to preview are accessed via the Flash interface, and so will require the latest Flash plugin, an easy ask for a designer or developer.
  
  The rapid generation of wireframes within this application reminds me of the speed and ease of use of Axure, but with the hand-sketched look of Balsamiq Mockups. Another nice thing about iPlotz is that its focus is just on web design, nothing else. This is a pleasant change.
  It’s early days for iPlotz, however there are a few items that do need addressing. The commenting interface can be a little distracting; the comments tend to crowd the screen if you have more than a few. There is only one font face available—comic sans. Also, at present the export functionality is limited to JPG, PNG, or a PDF. Still, this application is definitely one to watch. 
  12. Go Analogue 
    There is a lot to be said for stepping away from the computer and doing the initial wireframing with pencil and paper. You could extend this to paper prototyping as well. It’s fast (to build), cheap, and easy to use. For groups you can prototype using a large whiteboard, markers, and a few magnetic page elements. Both these methods tend to be highly interactive with the audience and can bring a moderate degree of humor to an otherwise dry process.
  There are downsides to these analogue methods as it can be slow to produce and revise the screens, as well as being easily disregarded by management because of the disposable nature of the final product. I have found that they’re useful for the generation process, but the final documentation needs to be presented in a formal tool. 
  Multifunctional Applications 
    13. PowerPoint or Keynote 
    Often an organization is unable to afford specialized software for prototyping or wireframing. This is where applications like Microsoft PowerPoint (price: from $US229, demo available) or Apple Keynote (price: from $US79, with iWorks, demo available) can be used. Both these packages are well-suited to producing very rapid, simple prototypes. They’re highly compatible with the wide range of most teams’ skill set, so by using these tools you can usually have any team members immediately contributing to a prototype with ease. The downside is many of the finer interactive elements, such as between states, are missing, and your logic path tends to be of a very linear nature. Still, you can often export the prototype to HTML or Flash as well.
  14. Adobe Fireworks
    Adobe Fireworks (price: from $US299, demo available) is a tool I’d yet to consider using for prototyping—being a Photoshop devotee from way back. However, all this has changed with the release of Adobe CS4. 
  Fireworks is now shaping up to be a viable tool for producing both low and high fidelity prototypes, using nested symbols, smart guides, as well as generating all the code behind it. As usual this code suffers a little from the automatic generation process, so it’s going to need to be massaged into a reasonable shape if you want to reuse it for your final production model. 
  A side note here is that I know of others also using Adobe Photoshop and Illustrator, or Microsoft Expression Studio as wireframe documentation tools. These tend to work well when you have a good library of objects, such as brushes and the like. 
  15. HTML
    If you have the skills, you could just develop your prototypes in HTML. This is especially useful if you are producing the front-end code that’s going to be consistent in standards with the final web site anyway. Doing it this way will save you time and money by reducing the overall production time. 
  These days—with the use of various jQuery plugins—you can represent nearly all the between states or major interface types that have been proposed with ease. 
  Functionality is also available via the use of Protonotes; you can have your team collaborate on your prototype by leaving dynamic, virtual Post-it like notes. 
  Even if your skill set falls short of being technically-oriented, you could use developmental platforms like Adobe Dreamweaver and its improved JavaScript Spry components to produce a reasonable visual representation. 
  I will admit I have often done this, quickly pulling together a working HTML prototype from within Dreamweaver with little regard to the underlying code. Remember, it’s just a prototype and so only has to be visually representative of the final product. I shudder to say this, but in this case the code is secondary.
  16. Adobe Flash
    Adobe Flash (price: from $US699, demo available) is a great tool for producing rapid interactive prototypes or screen flows, but is unsuitable for wireframing and specification documentation. However, via the use of the library objects, the timeline, and drawing tools it’s very easy to produce an interactive prototype. The one area Flash is especially suited is in the reproduction of those in-between states that many static presentation tools lack.
  This functionality of using Flash as a prototyping tool is now being extended by Adobe with the introduction of an entirely new tool for designers and developers alike: Catalyst. Now I’ve yet to try Catalyst personally—I can only go off the Adobe video and the reports from colleagues that have seen it in operation. But trust me here, this application is going to change the marketplace and make RIA development the next big thing! There, I said it; some of you will disagree, and that’s fine. 
  Another thing that Catalyst is promising for people like me that use a Mac, is that it will give us the jump on our colleagues using Axure. We shall see on that one.
www.sitepoint.com



Learn Apache mod_rewrite: 13 Real-world Examples
2009-08-02T22:40:00.000+07:00
Apache's low-cost, powerful set of features make it the server of choice for organizations around the world. One of its most valuable treasures is the mod_rewrite module, the purpose of which is to rewrite a visitor's request URI in the manner specified by a set of rules.

This article will lead you through rewrite rules, regular expressions, and rewrite conditions, and provide a great list of examples.

First off, I'm going to assume that you understand the common reasons for wanting a URI rewriting feature for your web site. If you'd like information about this field, there's a good primer in the SitePoint article, mod_rewrite: A Beginner's Guide to URL Rewriting. There, you'll also find instructions on how to enable it on your own server.
Testing Your Server Setup

Some hosts do not have mod_rewrite enabled (by default it is not enabled). You can find out if your server has mod_rewrite enabled by creating a PHP script with one simple line of PHP code:

phpinfo();

If you load the script with a browser, look in the Apache Modules section. If mod_rewrite isn't listed there, you'll have to ask your host to enable it -- or find a "good host". Most hosts will have it enabled, so you'll be good to go.
The Magic of mod_rewrite

Here's a simple example for you: create three text files named test.html, test.php, and .htaccess.

In the test.html file, enter the following:

<h1>This is the HTML file.</h1>

In the test.php file, add this:

<h1>This is the PHP file.</h1>

Create the third file, .htaccess, with the following:

RewriteEngine on
RewriteRule ^/?test\.html$ test.php [L]

Upload all three files (in ASCII mode) to a directory on your server, and type:

http://www.example.com/path/to/test.html

into the location box -- using your own domain and directory path of course! If the page shows "This is the PHP file", it's working properly! If it shows "This is the HTML file," something's gone wrong.

If your test worked, you'll notice that the test.html URI has remained in the browser's location box, yet we've seen the contents of the test.php file. You've just witnessed the magic of mod_rewrite!
mod-rewrite Regular Expressions

Now we can begin rewriting your URIs! Let's imagine we have a web site that displays city information. The city is selected via the URI like this:

http://www.example.com/display.php?country=USA&state=California&city=San_Diego

Our problem is that this is way too long an unfriendly to users. We'd much prefer it if visitors could use:

http://www.example.com/USA/California/San_Diego

We need to be able to tell Apache to rewrite the latter URI into the former. In order for the display.php script to read and parse the query string, we'll need to use regular expressions to tell mod_rewrite how to match the two URIs. If you're not familiar with regular expressions (regex), many sites provide excellent tutorials. At the end of this article, I've listed the best pages I've found on the topic. If you're not able to follow my explanations, I recommend reviewing the first two of those links.

A very common approach is to use the expression (.*). This expression combines two metacharacters: the dot character, which means ANY character, and the asterisk character, which specifies zero or more of the preceding character. Thus, (.*) matches everything in the {REQUEST_URI} string. {REQUEST_URI} is that part of the URI which follows the domain up to but not including the ? character of a query string, and is the only Apache variable that a rewrite rule attempts to match.

Wrapping the expression in brackets stores it in an "atom," which is a variable that allows the matched characters to be reused within the rule. Thus, the expression above would store USA/California/San_Diego in the atom. To solve our problem, we'd need three of these atoms, separated by the subdirectory slashes (/), so the regex would become:

(.*)/(.*)/(.*)

Given the above expression, the regex engine will match (and save) three values separated by two slashes anywhere in the {REQUEST_URI} string. To solve our specific problem, though, we'll need to restrict this somewhat -- after all, the first and last atoms above could match anything!

To begin with, we can add the start and end anchor characters. The ^ character matches matching characters at the start of a string, and the $ character matches characters at the end of a string.

^(.*)/(.*)/(.*)$

This expression specifies that the whole string must be matched by our regex; there cannot be anything else before or after it.

However, this approach still allows too many matches. We're storing our matches as atoms, and will be passing them to a query string, so we have to be able to trust what we match. Matching anything with (.*) is too much of a potential security hazard, and, when used inappropriately, could even cause mod_rewrite to get stuck in a loop!

To avoid unnecessary problems, let's change the atoms to specify precisely the characters that we will allow. Because the atoms represent location names, we should limit the matched characters to upper and lowercase letters from A to Z, and because we use it to represent spaces in the name, the underscore character (_) should also be allowed. We specify a set using square brackets, and a range using the - character. So the set of allowed characters is written as [a-zA-Z_]. And because we want to avoid matching blank names, we add the + metacharacter, which specifies a match only on one or more of the preceding character. Thus, our regex is now:

^([a-zA-Z_]+)/([a-zA-Z_]+)/([a-zA-Z_]+)$

The {REQUEST_URI} string starts with a / character. Apache changed regex engines when it changed versions, so Apache version 1 requires the leading slash while Apache 2 forbids it! We can satisfy both versions by making the leading slash optional with the expression ^/? (? is the metacharacter for zero or one of the preceding character). So now we have:

^/?([a-zA-Z_]+)/([a-zA-Z_]+)/([a-zA-Z_]+)$

With regex in hand, we can now map the atoms to the query string:

display.php?country=$1&state=$2&city=$3

$1 is the first (country) atom, $2 is the second (state) atom and $3 is the third (city) atom. Note that there can only be nine atoms created, in the order in which the opening brackets appear -- $1 ... $9 in a regular expression.

We're almost there! Create a new .htaccess file with the text:

RewriteRule ^/?([a-zA-Z_]+)/([a-zA-Z_]+)/([a-zA-Z_]+)$ display.php?country=$1&state=$2&city=$3 [L]

Save this to the directory in which display.php resides. The rewrite rule must go on one line with one space between the RewriteRule statement, the regex, and the redirection (and before any optional flags). We've used the [L], or 'last' flag, which is the terminating flag (more on flags later).

Our rewrite rule is now complete! The atom values are being extracted from the request string and added to the query string of our rewritten URI. The display.php script will likely extract these values from the query string and use them in a database query or something similar.

If, however, you have only a short list of allowable countries, it might be best to avoid potential database problems by specifying the acceptable values within the regex. Here's an example:

^/?(USA|Canada|Mexico)/([a-zA-Z_]+)/([a-zA-Z_]+)$

If you're concerned about capitalization because the values in your database are strictly lowercase, you can make the regex engine ignore the case by adding the No Case flag, [NC], after the rewritten URI. Just don't forget to convert the values to lowercase in your script after you obtain the $_GET array.

If you want to use numbers (0, 1, ... 9) for, say, Congressional Districts, then you'll need to change an atom's specification from ([a-zA-Z_]+) to ([0-9]) to match a single digit, ([0-9]{1,2}) to match one or two digits (0 through 99), or ([0-9]+) for one or more digits, which is useful for database IDs.
The RewriteCond Statement

Now that you've learned how to use mod_rewrite's basic RewriteRule statement with the {REQUEST_URI} string, it's time to see how we can use conditionals to access other variables with the RewriteCond statement. The RewriteCond statement is used to specify the conditions under which a RewriteRule statement should be applied.

RewriteCond is similar in format to RewriteRule in that you have the command name, RewriteCond, a variable to be matched, the regex, and flags. The logical OR flag, [OR], is a useful flag to remember because all RewriteCond and RewriteRule statements are inclusive, in the sense of a logical AND relationship, until terminated by the Last, [L], flag.

You can test many server variables with a RewriteCond statement. You can find a list in the SitePoint article I mentioned previously, but this is the best list of server variables I've found.

As an example, let's assume that we want to force the www in your domain name. To do this, you'll need to test the Apache {HTTP_HOST} variable to see if the www. is already there and, if it's not, redirect to the desired host name:

RewriteCond %{HTTP_HOST} !^www\.example\.com$ [NC]
RewriteRule .? http://www.example.com%{REQUEST_URI} [R=301,L]

Here, to denote that {HTTP_HOST} is an Apache variable, we must prepend a % character to it. The regex begins with the ! character, which will cause the condition to be true if it doesn't match the pattern. We also have to escape the dot character so that it matches a literal dot and not any character, as is the case with the dot metacharacter. We've also added the No Case flag to make this operation case-insensitive.

The RewriteRule will match zero or one of any character, and will redirect to http://www.example.com plus the original {REQUEST_URI} value. The R=301, or redirect, flag will cause Apache to issue a HTTP 301 response, which indicates that this is a permanent redirection; the Last flag tells mod_rewrite that you've completed this block statement.

RewriteCond statements can also create atoms, but these are denoted with %1 ... %9 in the same way that RewriteRule atoms are denoted with $1 ... $9. You'll see these atom variables in operation in the examples later on.


mod_rewrite Flags

mod_rewrite uses "flags" to give our rewrite conditions and rules additional features. We add flags at the end of a condition or rule using square brackets, and separate multiple flags with a comma. The main flags with which you'll need to be familiar are:

 last|L - The Last flag tells Apache to terminate a series of rewrite conditions and rewrite rules in the same way that } will terminate a statement block in PHP. Note that this flag does not terminate mod_rewrite processing!

 nocase|NC - The No Case flag tells Apache to ignore the case of the string in the regex and is often necessary when writing a RewriteCond statement that matches the {HTTP_HOST} variable for a domain name, which is not case sensitive.

 redirect|R - The Redirect flag is used to trigger an external (visible) redirection. By default, this means that Apache will issue an HTTP 302 response to indicate that the document has been moved temporarily, but you can specify the HTTP code if you like. For example, you could use [R=301] to make Apache issue a HTTP 301 response (moved permanently), which is often useful if you need search engines to reindex a changed URI.

 qsappend|QSA - The Query String Appended flag is used to "pass through" existing query strings. You can also define a new query sting to which the old string will be appended, just be careful not to replicate key names. Failure to use the QSA flag will cause the creation of a query string during a redirection to destroy an existing query string.

 forbidden|F - The Forbidden flag is used to tell Apache when not to provide a page in response to a request. As a result, Apache will issue a HTTP 403 response, which can be used to protect files from being viewed by unauthorized visitors, bandwidth leeches, and so on.

 ornext|OR - The OR flag allows you to combine rewrite conditions with a logical OR relationship as opposed to the default AND.

 next|N - The Next flag tells mod_rewrite to restart the rewriting process from the first rule, but to use the URI that was returned from the last processed rewrite rule. This is useful for replacing characters in the {REQUEST_URI} when you don't know how many there will be.


You can read about the other available flags at Apache.org's mod_rewrite documentation page.
mod_rewrite Comments

The RewriteEngine on statement is needed at the start of any mod_rewrite code, but it is also useful in another role. As a good programmer, you know how important comments are in your code. mod_rewrite allows you to comment out an entire block of mod_rewrite code by wrapping the code in RewriteEngine off and RewriteEngine on statements:

RewriteEngine off
RewriteCond %{HTTP_HOST} !^www\.example\.com$ [NC]
RewriteRule .? http://www.example.com%{REQUEST_URI} [R=301,L]
RewriteEngine on





None of the statements above will be read by the mod_rewrite engine. RewriteEngine statements can be very helpful when developing new mod_rewrite code -- just use them as you would the /* ... */ wrapper for PHP comments.
mod_rewrite Tips

As a webmaster, it's up to you to determine how your pages will be identified to visitors, as well as how to rewrite those URIs so that Apache can serve the appropriate content. Be sure to put some careful consideration into the creation of your new URI scheme. And don't forget that after implementing your new URI scheme, you may have to go back over old content, updating existing links to match the new scheme.

When you design your new URI scheme, make use of unique keys whenever you can. In a previous example, I used countries, states and cities as keys -- items that would be unique in a database. But as I build web sites for clients to update themselves, it's unreasonable for me to insist that they provide unique titles for all their articles. Articles in the database are typically identified by an auto-incremented ID, which would be perfect for my friendly URI scheme. It makes your rewrite rules a lot simpler because you can map a URI atom to a query string value directly.

People often attempt to use a database to redirect from a title or other such field to a specific ID value. mod_rewrite has a RewriteMap statement for this purpose, but you need to have access to your Apache main configuration file: httpd.conf. Typically, you'll only have access to this file if you own and operate the server. Instead, avoid the problem completely, and use the ID field to create your links.

Remember that spaces appear as %20 in URIs, so you'll need to replace them in your PHP code. PHP's str_replace function is perfect for this task. Generally, we need to replace spaces with %20 when generating links, and convert %20 back to spaces when reading in query string values from the $_GET array. However, when working with unique database field values that contain spaces, I prefer to use the underscore character to replace the spaces in resulting links. To do so, you can use the following PHP code:

$name = str_replace ( ' ', '_', $name );

Be careful not to break existing relative links when you implement your new URI scheme. Developers are often surprised when suddenly their CSS, JavaScript files, and images cease to work. Remember that relative links are relative to the current URI at the browser end -- that's the requested URI, not the rewritten one. Depending on your site's configuration, you may need to use absolute URIs, or the HTML <base> tag, for all your static resources.
13 mod_rewrite Examples

Earlier, we looked at an example that forced the inclusion of the www part of a domain name for every request. Let's have a look at some more examples and see how useful mod_rewrite can be.

1. Forcing www for a domain while preserving subdomains

RewriteCond %{HTTP_HOST} ^([a-z.]+)?example\.com$ [NC]
RewriteCond %{HTTP_HOST} !^www\. [NC]
RewriteRule .? http://www.%1example.com%{REQUEST_URI} [R=301,L]

This rule captures the optional subdomain using the %1 variable, and, if it doesn't start with www., redirects with www. prepended to the subdomain. The domain and the original {REQUEST_URI} are appended to the result.

2. Eliminating www from a domain

RewriteCond %{HTTP_HOST} !^example\.com$ [NC]
RewriteRule .? http://example.com%{REQUEST_URI} [R=301,L]

3. Getting rid of the www but preserving a subdomain

RewriteCond %{HTTP_HOST} ^www\.(([a-z0-9_]+\.)?example\.com)$ [NC]
RewriteRule .? http://%1%{REQUEST_URI} [R=301,L]

Here, the subdomain is captured in %2 (the inner atom) but, since it's optional and already captured in the %1 variable, all you need is the %1 for the subdomain.

4. Preventing image hotlinking

If some unscrupulous webmasters are leeching your bandwidth by linking to images from your site to post on theirs, you can use the following rule to block the requests:

RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{HTTP_REFERER} !^http://(www\.)?example\.com/ [NC]
RewriteRule \.(gif|jpg|png)$ - [F]

If the {HTTP_REFERER} value is not blank, or from your own domain (example.com), this rule will block the viewing of URIs ending in .gif, .jpg, or .png using the forbidden flag, F.

If you are upset enough at these hotlinkers, you could change the image and let visitors to the site know that you know that they're hotlinking:

RewriteCond %{HTTP_REFERER} !^$
RewriteCond %{HTTP_REFERER} !^http://(www\.)?example\.com/.*$ [NC]
RewriteRule \.(gif|jpg|png)$ http://www.example.com/hotlinked.gif [R=301,L]

Instead of blocking the URI, the above rule rewrites it to a specific image in our domain. What appears in this image is completely up to your imagination!

You can block specific domains using:

RewriteCond %{HTTP_REFERER} !^http://(www\.)?leech_site\.com/ [NC]
RewriteRule \.(gif|jpg|png)$ - [F,L]

This rule blocks all requests where the {HTTP_REFERER} field is set to the bad domain.

Of course, the above rules rely on the {HTTP_REFERER} value being set correctly. It usually is, but if you'd rather rely on the IP Address, use {REMOTE_ADDR} instead.

5. Redirecting to a 404 page if the directory and file do not exist

If your host doesn't provide for a "file not found" redirection, create it yourself!

RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule .? /404.php [L]

Here, -f matches an existing filename and -d matches an existing directory name. This script checks to see that the requested filename is not an existing filename or directory name before it redirects to the 404.php script. You can extend this script: include the URI in a query string by adding ?url=$1 immediately after the URI:

RewriteRule ^/?(.*)$ /404.php?url=$1 [L]

This way, your 404.php script can do something with the requested URL: display it in a message, send it in an email alert, perform a search, and so on.

6. Renaming your directories

If you've shifted files around on your site, changing directory names, try this:

RewriteRule ^/?old_directory/([a-z/.]+)$ new_directory/$1 [R=301,L]

I've included the literal dot character (not the "any character" metacharacter) inside the set to allow file extensions.

7. Converting old .html links to new .php links 

Updating your web site but need to be sure that bookmarked links will still work?

RewriteRule ^/?([a-z/]+)\.html$ $1.php [L]

This is not a redirection, so it will be invisible to your visitors. To make it permanent (and visible), change the flag to [R=301,L].

8. Creating extensionless links

If your site uses PHP files, and you want to make your links easier to remember -- or you just want to hide the file extension, try this:

RewriteRule ^/?([a-z]+)$ $1.php [L]

If you have a mixture of both .html and .php files, you can use RewriteCond statements to check whether the filename with either extension exists as a file:

RewriteCond %{REQUEST_FILENAME}.php -f
RewriteRule ^/?([a-zA-Z0-9]+)$ $1.php [L]
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^/?([a-zA-Z0-9]+)$ $1.html [L]

If the file name exists with the .php extension, that rule will be chosen.

9. Checking for a key in a query string

If you need to have a specific key's value in your query string, you can check for its existence with a RewriteCond statement:

RewriteCond %{QUERY_STRING} !uniquekey=
RewriteRule ^/?script_that_requires_uniquekey\.php$ other_script.php [QSA,L]

The above code will check the {QUERY_STRING} variable for a lack of the key uniquekey and, if the {REQUEST_URI} is the script_that_requires_uniquekey, it will redirect to an alternative URI.

10. Deleting the query string

Apache's mod_rewrite automatically passes through a query string unless you do either of the following:

 Assign a new query string (you can keep the original query string by adding a QSA flag, e.g., [QSA,L]).

 Add a ? after a filename (for example, index.php?). The ? will not be shown in the browser's location field.


11. Redirecting a working URI to a new format

Here's a curly one. Let's say, for example, that we've got a set of working URLs that look like this: /index.php?id=nnnn. However, we'd really like to change them to /nnnn and make sure search engines update their indexes to the new URI format. First, we'd have to redirect the old URIs to the new ones so that search engines update their indexes, but we'd still have to rewrite the new URI back to the old one so that the index.php script would run. Have I got your head spinning?

The trick here is to place into the query string a marker code that will not be seen by visitors. We redirect from the old link to the new format only if the "marker" is not present in the query string. Then we rewrite the new format link back to the old format, and add a marker to the query string, using the QSA flag to ensure we're not eliminating an existing query string. Here's how it's done:

RewriteCond %{QUERY_STRING} !marker
RewriteCond %{QUERY_STRING} id=([-a-zA-Z0-9_+]+)
RewriteRule ^/?index\.php$ %1? [R=301,L]

RewriteRule ^/?([-a-zA-Z0-9_+]+)$ index.php?marker&id=$1 [L]

Here, the original URI, http://www.example.com/index.php?id=nnnn, does not contain the marker, so it's redirected by the first rule to http://www.example.com/nnnn with a HTTP 301 response. The second rule rewrites http://www.example.com/nnnn back to http://www.example.com/index.php?marker&id=nnnn, adding marker and id=nnnn in a new query string; then, the mod_rewrite process is started over.

In the second iteration, the marker is matched so the first rule is ignored and, since there's a dot character in index.php?marker&id=nnnn, the second rule is also ignored ... and we're finished!

Note that, while useful, this solution does require additional processing by Apache, so be careful if you're using it on shared servers with a lot of traffic.

12. Ensuring that a secure server is used

Apache can determine whether you're using a secure server in two ways: using the {HTTPS}, or {SERVER_PORT}, variables:

RewriteCond %{REQUEST_URI} ^secure_page\.php$
RewriteCond %{HTTPS} !on
RewriteRule ^/?(secure_page\.php)$ https://www.example.com/$1 [R=301,L]

The above example tests that the {REQUEST_URI} value is equal to our secure page script, and that the {HTTPS} value is not equal to on. If both these conditions re met, the request is redirected to the secure server URI. Alternatively, you could do the same thing by testing the {server_port} value, where 443 is typically the secure server port:

RewriteCond %{REQUEST_URI} ^secure_page\.php$
RewriteCond %{SERVER_PORT} !^443$
RewriteRule ^/?(secure_page\.php)$ https://www.example.com/$1 [R=301,L]

13. Enforcing secure server only on selected pages

In situations where secure and unsecured domains share the web server's DocumentRoot directory, you'll need a RewriteCond statement to check that the secure server port isn't being used, and then only redirect the request if the requested script is one in the list of those that require a secure server:

RewriteCond %{SERVER_PORT} !^443$
RewriteRule ^/?(page1|page2|page3|page4|page5)$  https://www.example.com/%1 [R=301,L]

Here's how you'd redirect requests for pages not requiring a secure server back to port 80:

RewriteCond %{ SERVER_PORT } ^443$
RewriteRule !^/?(page6|page7|page8|page9)$ http://www.example.com%{REQUEST_URI} [R=301,L]
Summary

Apache mod_rewrite is primarily used to allow SEO and user friendly URIs, but it's also an extremely flexible tool for other important redirection tasks. If you want to learn more, here are some very useful resources I've found:

Regular Expressions

 Great tutorial: http://gnosis.cx/publish/programming/regular_expressions.html

 Cheat sheet: http://regexlib.com/CheatSheet.aspx

 A regex-capable text editor: http://www.editpadpro.com

 Regex Coach: http://weitz.de/regex-coach/


mod_rewrite

 Cheat sheet: http://www.ilovejackdaniels.com/cheat-sheets/mod_rewrite-cheat-sheet/


www.sitepoint.com



Writing the Pac-Man Game in JavaFX - Part 3
2009-08-02T17:22:00.004+07:00
 Previous parts in the Pac-Man series

Writing the Pac-Man Game in JavaFX - Part 1

Writing the Pac-Man Game in JavaFX - Part 2

  We are now ready to create the ghosts in our game. The four ghosts, namely Blinky(red), Pinky(pink),  Inky(cyan) and Clyde(orange), are trapped inside a cage when a game starts. After some time, they get out of the cage one by one and start roaming the maze. Their goal is to catch the Pac-Man. The Pac-Man dies if he is touched by one of the ghosts. If the Pac-Man swallows a magic dot, he has the power to eat ghosts for a while. During this  time, the ghosts turn hollow and move more slowly. 
  There are two parts for writing the code for ghosts. First part is to create the animation. The second part is to implement an algorithm to control how the ghosts move inside the maze. The second part is the most interesting and crucial thing of this game. We will elaborate the algorithm in the next article. For now, we just use a simpler one for testing the animation.
  Animation of Ghosts
  A ghost can have three kinds of appearance. One is its normal look in its original color. The second is  a hollow ghost. The third is a flashing hollow style when it is about to turn back to its original color. So we need three sets of frames for the animation. Just like the Pac-Man character, every set of frames contains   4 pictures. To make a ghost look differently, we can switch the set of frames when  the status of a ghost changes. For example, below are three set of pictures for the red ghost Blinky.
  
  In terms of moving approaches, the ghosts have three styles: roaming the maze, crawling slowly when they turn hollow, and circling in the cage. Since the first two are the same except the moving speed is different, we basically need to have two kinds of logic to handle the moving of a ghost: outside and inside the cage respectively. 
  When we wrote the code of the Pac-Man character, we subclassed from MovingObject. This class abstracts the common logic needed for a character. Let's write the Ghost class by extending  MovingObject again. Below is the code of Ghost.fx:  
    
/*

* Ghost.fx

*

* Created on 2009-1-28, 14:26:09

*/



package pacman;



import java.lang.Math;

import javafx.animation.KeyFrame;

import javafx.animation.Timeline;

import javafx.scene.CustomNode;

import javafx.scene.image.Image;

import javafx.scene.image.ImageView;

import javafx.scene.Node;

import pacman.MazeData;



/**

* @author Henry Zhang

*/



public class Ghost extends CustomNode, MovingObject{



 public def TRAPPED=10;



 // the pacman character

 public var pacMan: PacMan;



 public var hollowImage1 = Image {

    url: "{__DIR__}images/ghosthollow2.png"

    }

 public var hollowImage2 = Image {

    url: "{__DIR__}images/ghosthollow3.png"

    }

 public var hollowImage3 = Image {

    url: "{__DIR__}images/ghosthollow1.png"

    }



 // images for ghosts when they become hollow

 public var hollowImg =

   [ hollowImage1,

     hollowImage2,

     hollowImage1,

     hollowImage2 ];



 // images for ghosts when they become hollow and flashing

 public var flashHollowImg =

   [ hollowImage1,

     hollowImage3,

     hollowImage1,

     hollowImage3 ];



 // time for a ghost to stay hollow

 var hollowMaxTime: Integer = 80;

 var hollowCounter : Integer;



 // the images of animation

 public var defaultImage1: Image;

 public var defaultImage2: Image;



 def  defaultImg  = [

       defaultImage1,

       defaultImage2,

       defaultImage1,

       defaultImage2,

 ];



 // animation images

 var images = defaultImg;



 // initial direction and position of a ghost, used in status reset

 public var initialLocationX : Number;

 public var initialLocationY : Number;

 public var initialDirectionX : Number;

 public var initialDirectionY : Number;



 // time to stay in the cage

 public var trapTime: Integer;

 public var trapCounter: Integer=0;



 // variables to decide if ghost should chase man, and with what probability

 public var changeFactor = 0.75;





 // the flag is set if a ghost becomes hollow

 public var isHollow: Boolean = false;



 // the GUI of a ghost

 var ghostNode : ImageView = ImageView {

    x: bind imageX  - 13

    y: bind imageY  - 13

    image: bind images[currentImage]

    }



 postinit {

    initialLocationX = x;

    initialLocationY = y;

    initialDirectionX = xDirection;

    initialDirectionY = yDirection;



    resetStatus();

  }



 // reset the status of a ghost and place it into the cage

 public function resetStatus() {

    x = initialLocationX;

    y = initialLocationY;



    xDirection = initialDirectionX;

    yDirection = initialDirectionY;



    isHollow = false;



    moveCounter = 0;

    trapCounter = 0;

    currentImage = 0;



    imageX = MazeData.calcGridX(x);

    imageY = MazeData.calcGridY(y);



    images = defaultImg;

    state = TRAPPED;

      

    timeline.keyFrames[0].time = 50ms;



    visible = true;

    start();

  }





 public function changeToHollowGhost() {

    hollowCounter = 0;

    isHollow = true;



    // switch the animation images

    images = hollowImg;



    // make it moves slower

    timeline.stop();

    timeline.keyFrames[0].time = 140ms;

    timeline.play();

  }



 // decide whether to change the current direction of a ghost

 public function changeDirectionXtoY(mustChange: Boolean): Void {

    if ( not mustChange and Math.random() > changeFactor ) {

       return;  // no change of direction

     }



    // will change to a Y direction if possible

    var goUp = MoveDecision {

       x: this.x

       y: this.y - 1 };

    var goDown = MoveDecision {

       x: this.x

       y: this.y + 1

     };



    // evaluate the moving choices to pick the best one

    goUp.evaluate();

    goDown.evaluate();



    if ( goUp.score < class="category1">and goDown.score < class="category1">return;  // no change of direction



    var continueGo =  MoveDecision {

       x: this.x + xDirection

       y: this.y

     };



    continueGo.evaluate();



    if ( continueGo.score > 0 and continueGo.score > goUp.score

         and continueGo.score > goDown.score ) {

       return;

     }



    var decision = -1; // make it goes up first, then decide if we need to change it

    if ( goUp.score  < decision =" 1" class="category1">else

      if ( goDown.score > 0 ) {

         // random pick

         if ( Math.random() > 0.5 )

           decision = 1;

     }



    yDirection = decision;

    xDirection = 0;



  }



 // decide whether to change the current direction of a ghost

 public function changeDirectionYtoX(mustChange: Boolean): Void {



    if ( not mustChange and Math.random() > changeFactor )

      return;  // no change of direction



    // will change to X directions if possible

    var goLeft = MoveDecision {

       x: this.x - 1

       y: this.y

     };



    var goRight = MoveDecision {

       x: this.x + 1

       y: this.y

     };



    // evaluate the moving choices to pick the best one

    goLeft.evaluate();

    goRight.evaluate();



    if ( goLeft.score < class="category1">and goRight.score < class="category1">return;  // no change of direction

     }



    var continueGo = MoveDecision {

       x: this.x

       y: this.y + yDirection

     };



    continueGo.evaluate();



    if ( continueGo.score > 0 and continueGo.score > goLeft.score

         and continueGo.score > goRight.score ) {

       return;

     }



    // make it goes up first, then decide if we need to change it to down

    var decision = -1;

    if ( goLeft.score  < decision =" 1" class="category1">else

      if ( goRight.score > 0 ) {

         // random pick

         if ( Math.random() > 0.5 )

           decision = 1;

     }



    xDirection=decision;

    yDirection = 0;

  }



 // move the ghost horizontally

 public function moveHorizontally() {



    moveCounter++;



    if ( moveCounter > ANIMATION_STEP - 1) {

       moveCounter=0;

       x += xDirection;

       imageX= MazeData.calcGridX(x);



       var nextX = xDirection + x;



       if ( y == 14 and ( nextX <= 1 or nextX >= 28) ) {

          if ( nextX < - 1 and xDirection < class="category2">x=MazeData.GRID_SIZE;

             imageX= MazeData.calcGridX(x);

           }

          else

            if ( nextX > 30 and xDirection > 0) {

               x=0;

               imageX= MazeData.calcGridX(x);

             }

        }

       else

         if (nextX < class="category1">or nextX > MazeData.GRID_SIZE) {

            changeDirectionXtoY(true)

          }

       else

         if ( MazeData.getData(nextX, y) == MazeData.BLOCK ) {

            changeDirectionXtoY(true)

          }

         else {

            changeDirectionXtoY(false);

          }

     }

    else {

       imageX += xDirection * MOVE_SPEED;

     }

  }



 // move the ghost vertically

 public function moveVertically() {

    

    moveCounter++;



    if ( moveCounter > ANIMATION_STEP - 1) {

       moveCounter = 0;

       y += yDirection;

       imageY = MazeData.calcGridX(y);



       var nextY= yDirection + y;

       if ( nextY < class="category1">or nextY > MazeData.GRID_SIZE) {

          changeDirectionYtoX(true);

        }

       else

         if ( MazeData.getData(x, nextY) == MazeData.BLOCK ) {

            changeDirectionYtoX(true);

          }

         else {

            changeDirectionYtoX(false);

          }

     }

    else {

       imageY += yDirection * MOVE_SPEED;

     }

  }



 // move the ghost horizontally in the cage

 public function moveHorizontallyInCage() {

  

    moveCounter++;



    if ( moveCounter > ANIMATION_STEP - 1) {



       moveCounter=0;

       x += xDirection;

       imageX = MazeData.calcGridX(x);



       var nextX = xDirection + x;



       if ( nextX < xdirection =" 0;" ydirection =" 1;" class="category1">else

         if ( nextX > 17) {

            xDirection = 0;

            yDirection = -1;

          }

     }

    else {

       imageX += xDirection * MOVE_SPEED;

     }

  }



 // move the ghost vertically in a cage

 public function moveVerticallyInCage() {



    moveCounter++;



    if ( moveCounter > ANIMATION_STEP - 1) {

       moveCounter=0;

       y += yDirection;

       imageY= MazeData.calcGridX(y) + 8;



       var nextY = yDirection + y;



       if ( nextY < ydirection =" 0;" xdirection =" -1;" class="category1">else

         if ( nextY > 15) {

            yDirection = 0;

            xDirection = 1;

          }

     }

    else {

       imageY += yDirection * MOVE_SPEED;

     }

  }



 public function hide() {

    visible=false;

        timeline.stop();

  }



 // move one tick

 public override function moveOneStep() {



    if ( state == MOVING or state == TRAPPED ) {

       if ( xDirection != 0 ) {

          if ( state == MOVING )

            moveHorizontally()

          else

            moveHorizontallyInCage();

        }

       else

         if ( yDirection != 0 ) {

            if ( state == MOVING )

              moveVertically()

            else

              moveVerticallyInCage();

          }



       if ( currentImage < class="category1">else {

          currentImage=0;

          if ( state == TRAPPED ) {

             trapCounter++;

 

             if ( trapCounter > trapTime and x == 14 and y == 13) {

                // go out of the cage

                y = 12;

  

                xDirection = 0;

                yDirection = -1;

                state = MOVING;

              }

           }

        }

     }



    // check to see if need to switch back to a normal status

    if ( isHollow ) {

   

       hollowCounter++;



       if ( hollowCounter == hollowMaxTime - 30 )

         images = flashHollowImg

       else

         if ( hollowCounter > hollowMaxTime ) {

            isHollow = false;

            images = defaultImg;

                

            timeline.stop();

            timeline.keyFrames[0].time = 50ms;

            timeline.play();

          }

     }

  }



 public override function create(): Node {

        return ghostNode;

  }



}
   
    The variable defaultImg is a sequence of images used as a ghost normal look.  The variable hollowImg and flashHollowImg store two sets of images for the states when a ghost becomes hollow and flashing. Similar to the PacMan class, the moving logic is handled in the function moveOneStep(). When a ghost is inside the cage, the function moveHorizontallyInCage() and moveVerticallyInCage() make the ghost turning around and around inside the cage. When a ghost gets out of the cage, two functions moveHorizontally() and moveVertically() control its roaming behavior. The variable trapTime determines how long a ghost stays in the cage before it gets out. Properly choosing  the values of this instance variable makes four ghosts coming out the cage in a fixed  order(Blinky-Pinky-Inky-Clyde). The below code in the function moveOneStep() sets free the ghost after a pre-defined time. 
 
  
public override function moveOneStep() {

       . . . . . .



       if ( state == TRAPPED ) {

          trapCounter++;



          if ( trapCounter > trapTime and x == 14 and y == 13) {

             // go out of the cage

             y = 12;



             xDirection = 0;

             yDirection = -1;

             state = MOVING;

           }

        }



      . . . . . .

 }
   
   The function changeToHollowGhost() turns a ghost into a hollow style. What it does is switching the animation pictures and slowing down the moving speed of a ghost. 
   
public function changeToHollowGhost() {

   hollowCounter = 0;

   isHollow = true;



   // switch the animation images

   images = hollowImg;



   // make it moves slower

   timeline.stop();

   timeline.keyFrames[0].time = 140ms;

   timeline.play();

 }
   
    After a ghost becomes hollow, it resumes to its normal color after a period of time.  The second half of the function moveOneStep() uses a counter to keep track of the  time and flashes the ghost just before it turns into its normal color. From this part, we can see how the switching of 3 sets of pictures works.  
   
public override function moveOneStep() {



   . . . . . .



   // check to see if need to switch back to a normal status

   if ( isHollow ) {

  

      hollowCounter++;



      if ( hollowCounter == hollowMaxTime - 30 )

        images = flashHollowImg

      else

        if ( hollowCounter > hollowMaxTime ) {

           isHollow = false;

           images = defaultImg;

               

           timeline.stop();

           timeline.keyFrames[0].time = 50ms;

           timeline.play();

         }

    }

 }
   
    Roaming the Maze 
  As we mentioned previously, the algorithm that governs the ghosts' moving is the heart of this program. For the purpose of testing the ghosts' animation, for now, we apply a "random" moving algorithm, ie. the ghosts run arbitrarily inside the maze. In next article, we will implement a more complex algorithm. The function changeDirectionYtoX( Boolean ) and changeDirectionXtoY( Boolean ) give out decisions of whether a ghost should keep its current direction, or make a left or right turn. For illustration, let's take an  in-depth look at the function changeDirectionYtoX( Boolean ).  
   
// decide whether to change the current direction of a ghost

public function changeDirectionYtoX(mustChange: Boolean): Void {



   if ( not mustChange and Math.random() > changeFactor )

     return;  // no change of direction



   // will change to a X direction if possible

   var goLeft = MoveDecision {

      x: this.x - 1

      y: this.y

    };



   var goRight = MoveDecision {

      x: this.x + 1

      y: this.y

    };



   // evaluate the moving choices to pick the best one

   goLeft.evaluate();

   goRight.evaluate();



   if ( goLeft.score < class="category1">and goRight.score < class="category1">return;  // no change of direction

    }



   var continueGo = MoveDecision {

      x: this.x

      y: this.y + yDirection

    };



   continueGo.evaluate();



   if ( continueGo.score > 0 and continueGo.score > goLeft.score

        and continueGo.score > goRight.score ) {

      return;

    }



   // make it goes up first, then decide if we need to change it to down

   var decision = -1;

   if ( goLeft.score  < decision =" 1" class="category1">else

     if ( goRight.score > 0 ) {

        // random pick

        if ( Math.random() > 0.5 )

          decision = 1;

    }



   xDirection=decision;

   yDirection = 0;

 }
   
        When a ghost is moving vertically, this function determines the next direction. Possible decisions include: turning left, turning right, and continue with the current direction. A class MoveDecision is used to model a tentative decision. See the below code:  
   
/*

* MoveDecision.fx

*

* Created on 2009-1-28, 14:42:00

*/



package pacman;



/**

* @author Henry Zhang

*/



public class MoveDecision {



 // x and y of an intended move

 public var x: Number;

 public var y: Number;



 public var score: Number;



 // evaluate if the move is valid,

 // if it is invalid, returns -1;

 // if it is valid, compute its score for ranking the final decision

 public function evaluate( ):Void {

    if ( x < class="category1">or y < class="category1">or y >= MazeData.GRID_SIZE or x >= MazeData.GRID_SIZE){

       score = -1;

       return ;

     }



    var status = MazeData.getData(x, y);

    if ( status == MazeData.BLOCK ) {

       score = -1;

       return ;

     }



    // rank it as a default score

    score = 1;

  }

}
   
  The evaluate() function evaluates a moving decision and gives a score.  A ghost simply picks the decision with highest ranking score. In a random moving algorithm, all decisions are given an equal score 1. If a move leads the ghost to hitting a wall, the ranking score is (-1), which automatically eliminates it from being a candidate decision. If a ghost reaches a wall, the argument mustChange of changeDirectionYtoX(Boolean) is set so that a ghost always gets a change of direction. If this argument is false, the decision to change direction is affected by a random factor changeFactor. This allows the moving behavior of a ghosts more unpredictable, hence the player cannot guess the moving pattern of a ghost. The changeDirectionXtoY(Boolean) has a similar logic and it determines the moving decision when a ghost is going horizontally.  
  Running the Game
  Now we are ready to put things together and have some fun running the program.  We add in some code to Maze.fx, putting four ghosts on stage:  
   
public class Maze extends CustomNode {



 . . . . .



 public var ghostBlinky = Ghost {

    defaultImage1: Image {

       url: "{__DIR__}images/ghostred1.png"

     }



    defaultImage2: Image {

       url: "{__DIR__}images/ghostred2.png"

     }



     maze: this

     pacMan: pacMan

     x: 17

     y: 15

     xDirection: 0

     yDirection: -1

     trapTime: 1

    };



  public var ghostPinky = Ghost {

     defaultImage1:Image {

         url: "{__DIR__}images/ghostpink1.png"

      }



     defaultImage2:Image {

        url: "{__DIR__}images/ghostpink2.png"

      }

   

     maze: this

     pacMan: pacMan

     x: 12

     y: 14

     xDirection: 0

     yDirection: 1

     trapTime: 10

   };



  public var ghostInky = Ghost {

     defaultImage1:Image {

        url: "{__DIR__}images/ghostcyan1.png"

      }

     defaultImage2:Image {

        url: "{__DIR__}images/ghostcyan2.png"

      }



     maze: this

     pacMan: pacMan

     x: 13

     y: 15

     xDirection: 1

     yDirection: 0

     trapTime: 40

   };



  public var ghostClyde = Ghost {

     defaultImage1:Image {

         url: "{__DIR__}images/ghostorange1.png"

      }

     defaultImage2:Image {

        url: "{__DIR__}images/ghostorange2.png"

      }



     maze: this

     pacMan: pacMan

     x: 15

     y: 14

     xDirection: -1

     yDirection: 0

     trapTime: 60

   };



  public var ghosts = [ghostBlinky, ghostPinky, ghostInky, ghostClyde];



   . . . . . .



  postinit {



    . . . . . .



     insert pacMan into group.content;



     insert ghosts into group.content;



     insert WallBlackRectangle{ x1:-3, y1:13, x2:0, y2:15 } into group.content;

     insert WallBlackRectangle{ x1:29, y1:13, x2:31, y2:15 } into group.content;

   }
   
    Run the program and you can see four ghosts roaming the maze. You can control the Pac-Man character by keyboard to eat dots. However, the ghosts cannot eat the Pac-Man even they meet each other. We will implement this  part in next article. Click on the below screenshot and see it for yourself:  
   



 
  Download Source Code

www.insideria.com



Writing the Pac-Man Game in JavaFX - Part 2
2009-08-02T17:17:00.002+07:00
In the last article, we designed a data model and drew a maze with dots spread into the maze. Now we are ready to create the Pac-Man character. The Pac-Man character is controlled by the game player to move  around the maze. While he is moving, he keeps gobbling dots along the path. To implement the Pac-Man character, we divide the coding into a few tasks so that we can create it bit by bit:  
Basic animation: the Pac-Man character continually open and close mouth, but he does not move
Moving animation: the Pac-Man character moves inside the maze
Player Controlling: the player controls the moving direction of the Pac-Man character
Gobbling dots: the Pac-Man gobbles dots
   Basic Animation
  Let's start from the simplest thing first. We create the basic animation of the Pac-Man character.  The Pac-Man character at this phase does not move but can keep opening  and closing his mouth. The javafx.animation package, part of the JavaFX API, provides  the easy-to-use functionality for animation. We are going to use the Timeline class to implement the animation. During an animation, properties such as speed, shape, color and location  are constantly changing to achieve the desired behavior.  The Timeline class allows us to update the values of animation properties along the progression of time. The Timeline.Keyframes attribute can be used to define the order of frames. We create four pictures shown below for Pac-Man's animation:
   
   When we keep switching the above pictures(frames) of the Pac-Man character, it generates the animation effect of opening and closing the mouth. We are going to write two classes:  MovingObject.fx and PacMan.fx. The MovingObject class abstracts some common attributes that we could later use to implement the Ghost class. The PacMan class extends MovingObject to display the Pac-Man character. Here is the code:  
 MovingObject.fx:  
  
/*
* MovingObject.fx
*
* Created on 2009-1-1, 11:40:49
*/

package pacman;

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import pacman.Maze;
import pacman.MazeData;

/**
* @author Henry Zhang
*/

public abstract class MovingObject {

// animation frames total and movement distance
public def ANIMATION_STEP=4;
public def MOVE_SPEED = MazeData.GRID_GAP / ANIMATION_STEP;

public def MOVING = 1;
public def STOP =0;

public def MOVE_LEFT=0;
public def MOVE_UP=1;
public def MOVE_RIGHT=2;
public def MOVE_DOWN=3;

public var maze: Maze;
public var state : Integer;

public var currentImage=0;
public var moveCounter: Integer=0;

// grid coordinates
public var x: Number;
public var y: Number;

// graphical coordinates
public var imageX: Number ;
public var imageY: Number ;

public var xDirection: Number = 0;
public var yDirection: Number = 0;

public var timeline: Timeline =  createTimeline();

public function stop() {
  timeline.stop();
}

public function pause() {
  timeline.pause();
}

public function start() {
  timeline.play();
}

// animation time line, moving the pacman
public function createTimeline(): Timeline {
  Timeline {
     repeatCount: Timeline.INDEFINITE
     keyFrames: [
       KeyFrame {
          time: 250ms
          action: function() {
             moveOneStep();
           }
        }
     ]
    }
}

public abstract function moveOneStep(): Void;
}
   
   PacMan.fx:  
  
/*
* PacMan.fx
*
* Created on 2009-1-1, 11:50:58
*/

package pacman;

import javafx.scene.CustomNode;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.Node;
import pacman.MazeData;

/**
* @author Henry Zhang
*/

public class PacMan extends CustomNode, MovingObject {

public var defaultImage: Image = Image {
  url: "{__DIR__}images/left1.png"
};

// images for animation
def images = [
 defaultImage,
 Image {
    url: "{__DIR__}images/left2.png"
  },
 defaultImage,
 Image {
    url: "{__DIR__}images/round.png"
  }
];

// GUI image of the man
var pacmanImage : ImageView = ImageView {
  x: bind imageX  - 13
  y: bind imageY  - 13
  image: bind images[currentImage]
  }

postinit {
  imageX = MazeData.calcGridX(x);
  imageY = MazeData.calcGridX(y);

  state = MOVING;
  start();
}


public override function create(): Node {
  return pacmanImage;
}

// handle animation of one tick
public override function moveOneStep() {

  if ( state == MOVING) {

     // switch to the image of the next frame
     if ( currentImage < class="category1">else {
        currentImage=0;
      }
   }
}
}
   
   The MovingObject class defines an abstract function moveOneStep() which is called every 200 millisecond. Subclasses should implement this function to create frames of the animation. The PacMan class extends both the  CustomNode and MovingObject classes. In Java, a class can implement a few interfaces. In JavaFX's grammar, there is no interface, so multiple inheritance is used here. The attribute images is a sequence containing four pictures of the animation frames.  When the function moveOneStep() is invoked every 200ms, the value of the attribute pacmanImage  is rotated to the next picture in the sequence. In this way, the animation of Pac-Man's opening and closing his  mouth is accomplished. 
  Let's add in some code to the Maze class so that we can see the result of our animation. First,  add a statement to create an instance of PacMan: 
  
public class Maze extends CustomNode {

// Pac Man Character
public var pacMan : PacMan = PacMan{ maze:this x:23 y:5};

. . . .
   
   Then in the postinit block, we put the PacMan instance into the maze:    
postinit {

 . . . . .

 insert pacMan into group.content;
}
   
   Now, let's run the program and you can see that the Pac-Man character keeps biting. For illustration and testing purpose, we set an interval of 200ms between frames. This is a relatively large interval and it is kind of slow for playing. We will reduce this interval a bit later as we move forward. Click on the below image to view how the program runs so far:   

 
  Animation of Pac-Man Moving
 We now can make the Pac-Man character moving inside the maze. First, let me explain the purpose of a pair of variables in  the MovingObject class: xDirection and yDirection. They are used to store the horizontal and vertical direction of a character. See below table: 
  
  Moving Direction xDirection  yDirection  
  Left -1 0  
  Right 1 0  
  Up 0 -1  
  Down 0 1  
 
   Since we have four frames for a cycle of animation,  we can change the position (i.e. x or y coordinates) of the character when we update the picture of a frame. So a constant variable MOVE_SPEED, the moving speed of a character is defined in the MovingObject class and is computed as: 
  
public def ANIMATION_STEP=4;
public def MOVE_SPEED = MazeData.GRID_GAP / ANIMATION_STEP;
   
  During every animation clock cycle, we update the x or y coordinates of a character by a delta of MOVE_SPEED. After 4 clock cycles, the Pac-Man character moves to the next point of the grid either horizontally or vertically. Based on this algorithm, we add two functions moveHorizontally() and moveVertically() into  PacMan class.    
public class PacMan extends CustomNode, MovingObject {

. . . . . .

// moving horizontally
public function moveHorizontally() {

  moveCounter++;

  if ( moveCounter < class="category1">else {
     moveCounter = 0;
     x += xDirection;
 
     imageX = MazeData.calcGridX(x);

     // the X coordinate of the next point in the grid
     var nextX = xDirection + x;

     // check if the character hits a wall
     if ( MazeData.getData(nextX, y) == MazeData.BLOCK ) {
        state = STOP;
      }
   }
}

// moving vertically
public function moveVertically() {

  moveCounter++;

  if ( moveCounter < class="category1">else {
     moveCounter = 0;
     y += yDirection;
     imageY = MazeData.calcGridX(y);

     // the Y coordinate of the next point in the grid
     var nextY = yDirection + y;

     // check if the character hits a wall
     if ( MazeData.getData(x, nextY) == MazeData.BLOCK ) {
        state = STOP;
      }
   }
}

. . . . . .
}
   
   The two functions are similar to each other, so let's take a look at the function moveHorizontally(). When the character's position is between two points of the grid, we use this statement to move it: 
   
  
imageX += xDirection * MOVE_SPEED;
   
   When the character reaches a point, we check whether it hits a wall of the maze. If it does, we make it stop: 
  
// check if the character hits a wall
if ( MazeData.getData(nextX, y) == MazeData.BLOCK ) {
 state = STOP;
}
   
    Now, we can write some codes to test the moving of the Pac-man character. In PacMan class,  we add in the moving code in the function moveOnetStep():  
  
// handle animation of one tick
public override function moveOneStep() {

 if ( state == MOVING) {

    if ( xDirection != 0 )
      moveHorizontally();

    if ( yDirection != 0 )
      moveVertically();

    // switch to the image of the next frame
    if ( currentImage < class="category1">else {
       currentImage=0;
     }
  }
}
   
   In the postinit block, we set the initial direction of the pac-man character:     
postinit {
 imageX = MazeData.calcGridX(x);
 imageY = MazeData.calcGridX(y);

 xDirection = -1;
 yDirection = 0;

 state = MOVING;
 start();
}
   
   Run the program now and we can see the Pac-Man moving to the left and stop at the border of the maze.  
 

 
 You can try other moving directions by changing the values of xDirection and yDirection  in the postinit block. Refer to the table in previous section for possible combinations. Since we have not yet handled the part to turn the Pac-man's mouth, he always faces to  the left no matter which direction he moves in.  
  One last thing is to deal with a special case in the Pac-man's passing through the tunnel. The Pac-man character can walk into the tunnel to reach the other side of the maze. We put in some handling in function moveHorizontally() for this purpose.   
  
public function moveHorizontally() {

 moveCounter++;

 if ( moveCounter < class="category1">else {
    moveCounter = 0;
    x += xDirection;

    imageX = MazeData.calcGridX(x);

    // the X coordinate of the next point in the grid
    var nextX = xDirection + x;

    if ( y == 14 and ( nextX <= 1 or nextX >= 28) ) {
       if ( nextX < -1 and xDirection < class="category2">x = MazeData.GRID_SIZE;
          imageX = MazeData.calcGridX(x);
        }
       else
         if ( nextX > 30 and xDirection > 0) {
            x = 0;
            imageX = MazeData.calcGridX(x);
           }
     }
    else // check if the character hits a wall
      if ( MazeData.getData(nextX, y) == MazeData.BLOCK ) {
         state = STOP;
     }
  }
}
   
   In Maze.fx, we add two WallBlackRectangle objects to create the clipping effect of the Pac-man passing the tunnel.   
postinit {

. . . . .

 insert pacMan into group.content;
 insert WallBlackRectangle{ x1:-3, y1:13, x2:0, y2:15} into group.content;
 insert WallBlackRectangle{ x1:29, y1:13, x2:31, y2:15} into group.content;
}
   
   Then we can test this code by placing the Pac-Man character at the position (5,14):  
  
public var pacMan : PacMan = PacMan{ maze:this x:5 y:14 };
   
   So far, we completed the moving part of the Pac-man character.   Player's Controlling
 Now, we start to work on the player's keyboard controlling. In PacMan class, we define two attributes:   
  
// buffer to keep the keyboard input
var keyboardBuffer: Integer = -1;

// current direction of Pacman
var currentDirection: Integer = MOVE_LEFT;
   
   The keyboardBuffer attribute is used to store the keyboard input(keypress event). It will be consumed when the pac-man character's position is valid for the turn. Buffered keyboard input can be overwritten by subsequent keypressed event. For this reason, an experienced player usually presses a key well before the Pac-man reaches a turning point.
  The currentDirection is an attribute to determine which direction the pac-man faces to. 
  In PacMan.fx, we create a few functions as below.  The function moveRight(), moveLeft(), moveUp() and moveDown() are to change the direction of the Pac-Man character based on keyboard events.  
   
// turn pac-man to the right
public function moveRight(): Void {

 if ( currentDirection == MOVE_RIGHT ) return;

 var nextX = x + 1;

 if ( nextX >= MazeData.GRID_SIZE) return;

 if ( MazeData.getData(nextX, y) == MazeData.BLOCK ) return;

 xDirection = 1;
 yDirection = 0;

 keyboardBuffer = -1;
 currentDirection = MOVE_RIGHT;

 state = MOVING;
}

// turn pac-man to the left
public function moveLeft(): Void {

 if ( currentDirection == MOVE_LEFT ) return;

 var nextX = x - 1;

 if ( nextX <= 1) return;

 if ( MazeData.getData(nextX, y) == MazeData.BLOCK ) return;

 xDirection = -1;
 yDirection = 0;

 keyboardBuffer = -1;
 currentDirection = MOVE_LEFT;

 state = MOVING;
}

// turn pac-man going up
public function moveUp(): Void {

 if ( currentDirection == MOVE_UP ) return;

 var nextY = y - 1;

 if ( nextY <= 1) return;

 if ( MazeData.getData(x,nextY) == MazeData.BLOCK ) return;

 xDirection = 0;
 yDirection = -1;

 keyboardBuffer = -1;
 currentDirection = MOVE_UP;

 state = MOVING;
}

// turn pac-man going down
public function moveDown(): Void {

 if ( currentDirection == MOVE_DOWN ) return;

 var nextY = y + 1;

 if ( nextY >= MazeData.GRID_SIZE ) return;

 if ( MazeData.getData(x,nextY) == MazeData.BLOCK ) return;

 xDirection = 0;
 yDirection = 1;

 keyboardBuffer = -1;
 currentDirection = MOVE_DOWN;

 state = MOVING;
}

// handle keyboard input
public function handleKeyboardInput(): Void {
 if ( keyboardBuffer < class="category1">return;

 if ( keyboardBuffer == MOVE_LEFT )
   moveLeft()
 else
   if ( keyboardBuffer == MOVE_RIGHT )
     moveRight()
   else
     if ( keyboardBuffer == MOVE_UP )
       moveUp()
     else
       if ( keyboardBuffer == MOVE_DOWN )
         moveDown();
}

public function setKeyboardBuffer( k: Integer): Void {
 keyboardBuffer = k;
}
   
   In moveOneSteop() function, add in two lines of code to handle keyboard events during each tick of the animation:    
public override function moveOneStep() {

 // handle keyboard input only when pac-man is at a point of the grid
 if ( currentImage==0 )
   handleKeyboardInput();

 . . . . . .
}
   
    As we mentioned previously, the Pac-Man always faces to the left in our code. Let's modify our codes a bit to enable the Pac-Man to "turn" his mouth. A common approach is to use a separate set of pictures when  the character is moving in a particular direction. However, we going to  utilize the transformation feature of  JavaFX to achieve this goal. Instead of switching to another set of pictures, we just rotate the picture of each frame to face to the correct direction. JavaFX makes it very simple to accomplish. Let's change some  code in PacMan. 
  
  
public class PacMan extends CustomNode, MovingObject {

. . . . .

// angles of rotating the images
def rotationDegree = [0, 90, 180, 270];

// GUI image of the man
var pacmanImage : ImageView = ImageView {
  x: bind imageX - 13
  y: bind imageY - 13
  image: bind images[currentImage]
  transforms: Rotate {
     angle: bind rotationDegree[currentDirection]
     pivotX: bind imageX
     pivotY: bind imageY
     }
 }

. . . . . 
   
   The transforms attribute of the ImageView class allows us to apply the rotation we need. An instance of Rotate defines the angle and the center of the rotation. Binding is used again to automatically update the GUI of the character. 
  To accept keyboard events, we override the onKeyPressed attribute of the Maze class:   
  
public override var onKeyPressed = function ( e: KeyEvent ) : Void {

 if ( e.code == KeyCode.VK_DOWN )
   pacMan.setKeyboardBuffer( pacMan.MOVE_DOWN )
 else
   if ( e.code == KeyCode.VK_UP )
     pacMan.setKeyboardBuffer( pacMan.MOVE_UP )
   else
     if ( e.code == KeyCode.VK_RIGHT )
       pacMan.setKeyboardBuffer( pacMan.MOVE_RIGHT )
     else
       if ( e.code == KeyCode.VK_LEFT )
         pacMan.setKeyboardBuffer( pacMan.MOVE_LEFT );
}
   
   To get better visual effect, we now reduce the interval of animation keyframes. In function MovingObject.createTimeline(), we change the time attribute to 50ms.  
  
public function createTimeline(): Timeline {
 Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames: [
      KeyFrame {
         time: 50ms
         action: function() {
            moveOneStep();
          }
       }
    ]
   }
}
   
   Run the program and you can control the pac-man character's moving by arrow keys. Click the below button to view it online:
   

 
  Gobbling Dots
 The last part of the Pac-man's animation is gobbling the dots. We first create two attributes in the  PacMan class: dotEatenCount and scores.  
  
// the number of dots eaten
public var dotEatenCount : Integer = 0;

// scores of the game
public var scores: Integer = 0;
   
   Then we write a function updateScores() to check if a dot is gobbled by the Pac-man character. The scores is updated accordingly.  
  
public function updateScores() : Void {
 if ( y != 14 or ( x > 0 and x < class="category1">var dot : Dot = MazeData.getDot( x, y ) as Dot ;

    if ( dot != null and dot.visible ) {
       scores += 10;
       dot.visible = false;
       dotEatenCount ++;
     }
  }
}
   
    In function moveOneStep(), we invoke the updateScores() as below: 
  
public override function moveOneStep() {

   . . . . . .

   if ( currentImage < class="category1">else {
      currentImage=0;
      updateScores();
    }
   . . . . . .

}
   
    Finally, we add a Text instance as a scoreboard under the maze. It displays the scores as Pac-man eats the dots. The content of the Text instance is bound to pacMan.scores. 
  
public class Maze extends CustomNode {

. . . . . .

var group : Group =
Group {
  content: [

    . . . . . .

    Text {
       font: Font {
              size: 20
              }
       x: MazeData.calcGridX(0),
       y: MazeData.calcGridY(MazeData.GRID_SIZE + 2)
       content: bind "SCORES: {pacMan.scores} "
       fill: Color.YELLOW
     }
   ]
 . . . . . .
   
   By now, we completed the all the animation part of the Pac-man character. A player can control the pac-man character by keyboard and score by gobbling the dots. Click on the below button to run and play it. 
  

 
  Download Source Code

www.insideria.com



Writing the Pac-Man Game in JavaFX - Part 1
2009-08-02T17:10:00.003+07:00
When I was young I was fascinated by arcade games. One of my favorites was the Pac-Man game.  Recently, when I was learning the JavaFX language, I decided to write the game in JavaFX.  Based on my experience in other programming languages, I assumed there would be some amount of work in building a game such as Pac-Man, giving me a good feel for RIA development in JavaFX.
  Data Model of the Maze
   Before writing the JavaFX code, it is first necessary to design the data model. A data model is a way to represent physical objects with data structures. The functional programming style of JavaFX makes it easy to bind the UI to the model. When designing a data model, I usually consider two aspects: performance and space. Performance means that the data should be accessed via an efficient approach. For example, a hash table is usually faster than a linked list when a keyword-based search is performed. Performance is an important consideration for games that are constantly taking a player's input and updating graphical objects. Games like Pac-Man or Space Invaders fall into this category.  The other design consideration for a data model is memory space. I still remember the time when I was programming on an APPLE II with only 48KB RAM. Much effort was spent on minimizing memory consumption. Fortunately, our Pac-Man game is not data-intensive, so I wasn't very concerned about the space issue. 
  Keeping the above analysis in mind, we will now start building the data model. We can treat the board as an NxN grid. The wall of the maze can be drawn by lines connecting the points of the grid. Naturally, a 2-dimensional array is the best way to model this grid. Each point of the grid may have one of the following four types: 
   
 Type Value Explanation
 BLOCK 1 The point is part of a "wall" of the maze
  NORMAL_DOT 2  The point contains a normal dot 
  MAGIC_DOT 3  The point contains a magic dot 
  EMPTY 0  The point does not have any of the above objects at it 
 
  For example, the picture shown below is the upper-left corner of the maze, and the corresponding data in the array is shown on the right:
   
    
    
0 1 2 3 4 5 6
 0 1 1 1 1 1 1 1
 1 1 2 2 2 2 2 2
 2 1 2 1 1 1 1 2
 3 1 3 1 0 0 1 2
 4 1 2 1 1 1 1 2
 5 1 2 2 2 2 2 2
 6 1 2 1 1 1 1 2
 7 1 2 1 1 1 1 2
 8 1 2 2 2 2 2 2
 9 1 1 1 1 1 1 2
  
  
 
   This data model will be accessed very frequently when the Pac-Man character and ghosts are moving inside the maze, therefore, an efficient data structure should be used. A 2-dimensional (2D) array is a good choice because its access time is almost a constant. Though it is common in modern programming languages to have 2D arrays, JavaFX sequences (an array-like structure in JavaFX) are single dimensional. For this reason, I decided to use a Java class to hold this array. I created a few methods for accessing the model or converting the grid data into drawing coordinates.  Note that the ability to leverage Java from within JavaFX is one of the very powerful features of JavaFX.
     
package pacman;

/**
* MazeData.java
*
* @author Henry Zhang
*
* a 2D array for data model of the maze
*
*/

public class MazeData {

public final static int GRID_SIZE = 29;
public final static int EMPTY = 0;
public final static int BLOCK = 1;
public final static int NORMAL_DOT = 2;
public final static int MAGIC_DOT = 3;

public static int DOT_TOTAL = 0;
public static int mazeData[][] = new int[GRID_SIZE + 1][GRID_SIZE + 1];

public final static int GRID_GAP = 16;
public final static int GRID_STROKE = 2;
final static int xoffset = GRID_GAP * 2;
final static int yoffset = GRID_GAP * 2;

public static int makeInRange(int a) {
 if (a < a =" 0;" class="category1">else if (a > GRID_SIZE) {
    a = GRID_SIZE;
  }

 return a;
}

// set the grid of maze data to be BLOCK
public static void setBlockMazeData(int x1, int y1, int x2, int y2) {
 x1 = makeInRange(x1);
 y1 = makeInRange(y1);
 x2 = makeInRange(x2);
 y2 = makeInRange(y2);

 for (int i = x1; i <= x2; i++) {         mazeData[i][y1] = BLOCK;         mazeData[i][y2] = BLOCK;       }       for (int i = y1; i <= y2; i++) {         mazeData[x1][i] = BLOCK;         mazeData[x2][i] = BLOCK;       }    }    public static double calcGridX(double x) {
 return GRID_GAP * x + xoffset;
}

public static double calcGridY(double y) {
 return GRID_GAP * y + yoffset;
}

public static int getData(int x, int y) {
 return mazeData[x][y];
}

public static void setData(int x, int y, int value) {
 mazeData[x][y] = value;

 if ((value == MAGIC_DOT) || (value == NORMAL_DOT)) {
    DOT_TOTAL++;
  }
} // end setData
}
   
    Drawing the Maze
  Once we have the data model of the maze, we can start drawing the maze based on this model. There are basically two approaches for drawing the maze. One approach is to draw the maze directly with JavaFX code.  Another approach is use an image file such as a PNG or JPG. The image could then be used as a background picture in our Pac-Man game. I choose the first approach because it is easier to link the GUI to our data model.
  JavaFX provides some standard APIs for basic shapes such as lines, circles and rectangles.  We can use Line and Rectangle classes as building blocks for  most parts of the maze. First, we write a class named WallRectangle to draw the walls of the maze. In the code shown below, (x1,y1) and (x2,y2) are the coordinates of the upper-left and bottom-right corner of a rectangle. Here is the code: 
     
/*
* WallRectangle.fx
*
* Created on 2008-12-25, 16:08:28
*/

package pacman;

import javafx.scene.CustomNode;
import javafx.scene.Node;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import pacman.MazeData;

/**
* @author Henry Zhang
*/

public class WallRectangle extends CustomNode {

public var x1: Number;
public var y1: Number;
public var x2: Number;
public var y2: Number;

public override function create(): Node {
 Rectangle {
    x: MazeData.calcGridX(x1)
    y: MazeData.calcGridY(y1)
    width: MazeData.calcGridX(x2) - MazeData.calcGridX(x1)
    height: MazeData.calcGridY(y2) - MazeData.calcGridY(y1)
    strokeWidth: MazeData.GRID_STROKE
    stroke: Color.BLUE
    arcWidth: 12
    arcHeight: 12
  }
}
}
   
    Next, we start to work on the Maze class. The Maze class  extends CustomNode class and  overrides the create() function. In the create() function,  we place WallRectangle and  Line instances to construct the maze. Here is the source code of the Maze class: 
    
/*
* Maze.fx
*
* Created on 2008-12-20, 20:22:15
*/

package pacman;

import javafx.scene.CustomNode;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.paint.Color;
import javafx.scene.shape.Line;
import javafx.scene.shape.Rectangle;
import pacman.MazeData;

/**
* @author Henry Zhang
*/

public class Maze extends CustomNode {

var group : Group =
Group {
 content: [
   Rectangle {
      x:0
      y:0
      width: MazeData.calcGridX(MazeData.GRID_SIZE + 2)
      height: MazeData.calcGridY(MazeData.GRID_SIZE + 3)
      fill: Color.BLACK
    },

   WallRectangle{ x1:0 y1:0 x2:MazeData.GRID_SIZE y2:MazeData.GRID_SIZE },

   WallRectangle { x1:14 y1:-0.5 x2:15 y2:4 },

   WallRectangle { x1:2 y1:2 x2:5 y2:4 },
   WallRectangle { x1:7 y1:2 x2:12 y2:4 },
   WallRectangle { x1:17 y1:2 x2:22 y2:4 },
   WallRectangle { x1:24 y1:2 x2:27 y2:4 },
   WallRectangle { x1:2 y1:6 x2:5 y2:7 },

   WallRectangle { x1:14 y1:6.2 x2:15 y2:10 },
   WallRectangle { x1:10 y1:6 x2:19 y2:7 },

   WallRectangle { x1:7.5 y1:9 x2:12 y2:10 },
   WallRectangle { x1:7 y1:6 x2:8 y2:13 },
   WallBlackLine { x1:8 y1:9 x2:8 y2:10 },

   WallRectangle { x1:17 y1:9 x2:21.5 y2:10 },
   WallRectangle { x1:21 y1:6 x2:22 y2:13 },

   WallRectangle { x1:24 y1:6 x2:27 y2:7 },

   WallRectangle { x1:-1 y1:9 x2:5 y2:13 },
   WallRectangle { x1:24 y1:9 x2:MazeData.GRID_SIZE + 1 y2:13 },

   //cage and the gate
   WallRectangle { x1:10 y1:12 x2:19 y2:17 },
   WallRectangle { x1:10.5 y1:12.5 x2:18.5 y2:16.5 },
   Rectangle {
      x: MazeData.calcGridX(13)
      width: MazeData.GRID_GAP * 3
      y: MazeData.calcGridY(12)
      height: MazeData.GRID_GAP / 2
      stroke: Color.GREY
      fill: Color.GREY
    },

   WallRectangle { x1:7.5 y1:19 x2:12 y2:20 },
   WallRectangle { x1:7 y1:15 x2:8 y2:23 },

   WallRectangle { x1:17 y1:19 x2:21.5 y2:20 },
   WallRectangle { x1:21 y1:15 x2:22 y2:23 },

   WallRectangle { x1:14 y1:19 x2:15 y2:27 },
   WallRectangle { x1:10 y1:22 x2:19 y2:23 },

   WallRectangle { x1:2 y1:25 x2:5 y2:27 },
   WallRectangle { x1:17 y1:25 x2:22 y2:27 },

   WallRectangle { x1:7 y1:25 x2:12 y2:27 },
   WallRectangle { x1:24 y1:25 x2:27 y2:27 },

   WallRectangle { x1:-1 y1:15 x2:5 y2:17 },
   WallRectangle { x1:4 y1:19 x2:5 y2:23 },
   WallRectangle { x1:2 y1:19 x2:4.5 y2:20 },
   WallRectangle { x1:-1 y1:22 x2:2 y2:23 },

   WallRectangle { x1:24 y1:15 x2:MazeData.GRID_SIZE + 1 y2:17 },
   WallRectangle { x1:24 y1:19 x2:25 y2:23 },
   WallRectangle { x1:24.5 y1:19 x2:27 y2:20 },
   WallRectangle { x1:27 y1:22 x2:MazeData.GRID_SIZE + 1 y2:23 },

   WallBlackRectangle { x1:-2 y1:8 x2:0 y2:MazeData.GRID_SIZE },
   WallBlackRectangle {
       x1:MazeData.GRID_SIZE
       y1:8
       x2:MazeData.GRID_SIZE + 2
       y2:MazeData.GRID_SIZE
    },

   Rectangle {
      x: MazeData.calcGridX(-0.5)
      y: MazeData.calcGridY(-0.5)
      width: (MazeData.GRID_SIZE + 1) * MazeData.GRID_GAP
      height: (MazeData.GRID_SIZE + 1) * MazeData.GRID_GAP
      strokeWidth: MazeData.GRID_STROKE
      stroke: Color.BLUE
      fill: null
      arcWidth: 12
      arcHeight: 12
    },
   Line {
      startX: MazeData.calcGridX(-0.5)
      endX: MazeData.calcGridX(-0.5)
      startY: MazeData.calcGridY(13)
      endY: MazeData.calcGridY(15)
      stroke: Color.BLACK
      strokeWidth: MazeData.GRID_STROKE + 1
    },
   Line {
      startX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
      endX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
      startY: MazeData.calcGridY(13)
      endY: MazeData.calcGridY(15)
      stroke: Color.BLACK
      strokeWidth: MazeData.GRID_STROKE + 1
    },
   Line {
      startX: MazeData.calcGridX(-0.5)
      endX: MazeData.calcGridX(0)
      startY: MazeData.calcGridY(13)
      endY: MazeData.calcGridY(13)
      stroke: Color.BLUE
      strokeWidth: MazeData.GRID_STROKE
    },
   Line {
      startX: MazeData.calcGridX(-0.5)
      endX: MazeData.calcGridX(0)
      startY: MazeData.calcGridY(15)
      endY: MazeData.calcGridY(15)
      stroke: Color.BLUE
      strokeWidth: MazeData.GRID_STROKE
    },
   Line {
      startX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
      endX: MazeData.calcGridX(MazeData.GRID_SIZE)
      startY: MazeData.calcGridY(13)
      endY: MazeData.calcGridY(13)
      stroke: Color.BLUE
      strokeWidth: MazeData.GRID_STROKE
    },
   Line {
      startX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
      endX: MazeData.calcGridX(MazeData.GRID_SIZE)
      startY: MazeData.calcGridY(15)
      endY: MazeData.calcGridY(15)
      stroke: Color.BLUE
      strokeWidth: MazeData.GRID_STROKE
    },

 ]
}; // end Group

public override function create(): Node {
    return group;
} // end create()

}
   
   Now we'll write a Main class to put the maze onto the stage and display it:
     
/*
* Main.fx
*
* Created on 2008-12-20, 12:02:26
*/

package pacman;

import javafx.scene.Scene;
import javafx.stage.Stage;

/**
* @author Henry Zhang
*/

Stage{
title: "PACMAN"
width: MazeData.calcGridX(MazeData.GRID_SIZE + 2)
height: MazeData.calcGridY(MazeData.GRID_SIZE + 5)
scene: Scene{
         content: [ Maze {}
         ]
        }
}
   
    Run the program and we have the first version of our maze: 
  

Launch 
  The maze is almost done except that some lines are overlapping each other.  This is not a problem, because we can put some black lines and rectangles to hide  those overlapping areas so that the maze looks nice. Let's write two classes,  WallBlackRectangle and WallBlackLine, for this purpose. The WallBlackRectangle  class covers a rectangular area. The WallBlackLine class draws a black line in the  maze. In the previous section, our WallRectangle class extends the CustomNode class.  We do the same thing for the WallBlackRectangle here. The WallBlackLine class demonstrates  another way to achieve the same functionality. We subclass the JavaFX Line class and use  a postinit block (which is invoked upon instantiation after the instance variables have been  assigned values) to change the details of the Line object.
     
/*
* WallBlackRectangle.fx
*
* Created on 2008-12-27, 16:35:42
*/

package pacman;

import javafx.scene.CustomNode;
import javafx.scene.Node;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import pacman.MazeData;

/**
* @author Henry Zhang
*/

public class WallBlackRectangle extends CustomNode {

public var x1: Number;
public var y1: Number;
public var x2: Number;
public var y2: Number;

public override function create(): Node {
 Rectangle {
    x: MazeData.calcGridX(x1) + MazeData.GRID_STROKE
    y: MazeData.calcGridY(y1) + MazeData.GRID_STROKE
    width: MazeData.GRID_GAP * (x2-x1) - MazeData.GRID_STROKE * 2
    height: MazeData.GRID_GAP * (y2-y1) - MazeData.GRID_STROKE * 2
    strokeWidth: MazeData.GRID_STROKE
    stroke: Color.BLACK
    arcWidth: 3
    arcHeight: 3
  }
}
}
   
     
/*
* WallBlackLine.fx
*
* Created on 2008-12-27, 17:52:58
*/

package pacman;

import javafx.scene.paint.Color;
import javafx.scene.shape.Line;
import pacman.MazeData;

/**
* @author Henry Zhang
*/

public class WallBlackLine extends Line {

public var x1: Number;
public var y1: Number;
public var x2: Number;
public var y2: Number;

postinit {
 strokeWidth = MazeData.GRID_STROKE + 1;
 stroke = Color.BLACK;

 if ( x1 == x2 ) { // vertically line
    startX = MazeData.calcGridX(x1);
    startY = MazeData.calcGridY(y1) + MazeData.GRID_STROKE;
    endX = MazeData.calcGridX(x2);
    endY = MazeData.calcGridY(y2) - MazeData.GRID_STROKE;
  }
 else  { // horizontal line
    startX = MazeData.calcGridX(x1) + MazeData.GRID_STROKE;
    startY = MazeData.calcGridY(y1);
    endX = MazeData.calcGridX(x2) - MazeData.GRID_STROKE;
    endY = MazeData.calcGridY(y2);
  }
} // end postinit
}
   
   In the Maze class, we put in some instances of the above classes into the group variable:
    
var group : Group =
Group {
content: [
  Rectangle {
     x:0
     y:0
     width: MazeData.calcGridX(MazeData.GRID_SIZE + 2)
     height: MazeData.calcGridY(MazeData.GRID_SIZE + 3)
     fill: Color.BLACK
   },

  WallRectangle{ x1:0 y1:0 x2:MazeData.GRID_SIZE y2:MazeData.GRID_SIZE },

  WallRectangle { x1:14 y1:-0.5 x2:15 y2:4 },
  WallBlackRectangle { x1:13.8 y1:-1 x2:15.3 y2:0 },

  WallRectangle { x1:2 y1:2 x2:5 y2:4 },
  WallRectangle { x1:7 y1:2 x2:12 y2:4 },
  WallRectangle { x1:17 y1:2 x2:22 y2:4 },
  WallRectangle { x1:24 y1:2 x2:27 y2:4 },
  WallRectangle { x1:2 y1:6 x2:5 y2:7 },

  WallRectangle { x1:14 y1:6.2 x2:15 y2:10 },
  WallRectangle { x1:10 y1:6 x2:19 y2:7 },
  WallBlackLine { x1:14 y1:7 x2:15 y2:7 },

  WallRectangle { x1:7.5 y1:9 x2:12 y2:10 },
  WallRectangle { x1:7 y1:6 x2:8 y2:13 },
  WallBlackLine { x1:8 y1:9 x2:8 y2:10 },

  WallRectangle { x1:17 y1:9 x2:21.5 y2:10 },
  WallRectangle { x1:21 y1:6 x2:22 y2:13 },
  WallBlackLine { x1:21 y1:9 x2:21 y2:10 },

  WallRectangle { x1:24 y1:6 x2:27 y2:7 },

  WallRectangle { x1:-1 y1:9 x2:5 y2:13 },
  WallRectangle { x1:24 y1:9 x2:MazeData.GRID_SIZE + 1 y2:13 },
  WallBlackLine { x1:0 y1:13 x2:0 y2:15  },
  WallBlackLine { x1:MazeData.GRID_SIZE y1:13 x2:MazeData.GRID_SIZE y2:15},

  //cage and the gate
  WallRectangle { x1:10 y1:12 x2:19 y2:17 },
  WallRectangle { x1:10.5 y1:12.5 x2:18.5 y2:16.5 },
  Rectangle {
     x: MazeData.calcGridX(13)
     width: MazeData.GRID_GAP * 3
     y: MazeData.calcGridY(12)
     height: MazeData.GRID_GAP / 2
     stroke: Color.GREY
     fill: Color.GREY
   },

  WallRectangle { x1:7.5 y1:19 x2:12 y2:20 },
  WallRectangle { x1:7 y1:15 x2:8 y2:23 },
  WallBlackLine { x1:8 y1:19 x2:8 y2:20 },

  WallRectangle { x1:17 y1:19 x2:21.5 y2:20 },
  WallRectangle { x1:21 y1:15 x2:22 y2:23 },
  WallBlackLine { x1:21 y1:19 x2:21 y2:20 },

  WallRectangle { x1:14 y1:19 x2:15 y2:27 },
  WallRectangle { x1:10 y1:22 x2:19 y2:23 },
  WallBlackLine { x1:14 y1:22 x2:15 y2:22 },
  WallBlackLine { x1:14 y1:23 x2:15 y2:23 },

  WallRectangle { x1:2 y1:25 x2:5 y2:27 },
  WallRectangle { x1:17 y1:25 x2:22 y2:27 },

  WallRectangle { x1:7 y1:25 x2:12 y2:27 },
  WallRectangle { x1:24 y1:25 x2:27 y2:27 },

  WallRectangle { x1:-1 y1:15 x2:5 y2:17 },
  WallRectangle { x1:4 y1:19 x2:5 y2:23 },
  WallRectangle { x1:2 y1:19 x2:4.5 y2:20 },
  WallBlackRectangle { x1:4 y1:19.05 x2:5 y2:20.2 },
  WallRectangle { x1:-1 y1:22 x2:2 y2:23 },

  WallRectangle { x1:24 y1:15 x2:MazeData.GRID_SIZE + 1 y2:17 },
  WallRectangle { x1:24 y1:19 x2:25 y2:23 },
  WallRectangle { x1:24.5 y1:19 x2:27 y2:20 },
  WallBlackRectangle { x1:24 y1:19.05 x2:25 y2:20.2 },
  WallRectangle { x1:27 y1:22 x2:MazeData.GRID_SIZE + 1 y2:23 },

  WallBlackRectangle { x1:-2 y1:8 x2:0 y2:MazeData.GRID_SIZE },
  WallBlackRectangle {
      x1:MazeData.GRID_SIZE
      y1:8
      x2:MazeData.GRID_SIZE + 2
      y2:MazeData.GRID_SIZE
   },

  Rectangle {
     x: MazeData.calcGridX(-0.5)
     y: MazeData.calcGridY(-0.5)
     width: (MazeData.GRID_SIZE + 1) * MazeData.GRID_GAP
     height: (MazeData.GRID_SIZE + 1) * MazeData.GRID_GAP
     strokeWidth: MazeData.GRID_STROKE
     stroke: Color.BLUE
     fill: null
     arcWidth: 12
     arcHeight: 12
   },
  Line {
     startX: MazeData.calcGridX(-0.5)
     endX: MazeData.calcGridX(-0.5)
     startY: MazeData.calcGridY(13)
     endY: MazeData.calcGridY(15)
     stroke: Color.BLACK
     strokeWidth: MazeData.GRID_STROKE + 1
   },
  Line {
     startX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
     endX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
     startY: MazeData.calcGridY(13)
     endY: MazeData.calcGridY(15)
     stroke: Color.BLACK
     strokeWidth: MazeData.GRID_STROKE + 1
   },
  Line {
     startX: MazeData.calcGridX(-0.5)
     endX: MazeData.calcGridX(0)
     startY: MazeData.calcGridY(13)
     endY: MazeData.calcGridY(13)
     stroke: Color.BLUE
     strokeWidth: MazeData.GRID_STROKE
   },
  Line {
     startX: MazeData.calcGridX(-0.5)
     endX: MazeData.calcGridX(0)
     startY: MazeData.calcGridY(15)
     endY: MazeData.calcGridY(15)
     stroke: Color.BLUE
     strokeWidth: MazeData.GRID_STROKE
   },
  Line {
     startX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
     endX: MazeData.calcGridX(MazeData.GRID_SIZE)
     startY: MazeData.calcGridY(13)
     endY: MazeData.calcGridY(13)
     stroke: Color.BLUE
     strokeWidth: MazeData.GRID_STROKE
   },
  Line {
     startX: MazeData.calcGridX(MazeData.GRID_SIZE + 0.5)
     endX: MazeData.calcGridX(MazeData.GRID_SIZE)
     startY: MazeData.calcGridY(15)
     endY: MazeData.calcGridY(15)
     stroke: Color.BLUE
     strokeWidth: MazeData.GRID_STROKE
   },

]
}; // end Group
   
   After these adjustments, we have the Pac-Man maze shown below:
 

Launch 
   Before moving forward to the next step, I would like to initialize the data model as we draw the maze, i.e. to set the points related to a wall to a value of BLOCK. One of the benefits of doing  so is that the data model is always in sync with the GUI. If you want to modify the layout of the  maze later, you can just change the drawing code and the data model is adjusted automatically.  This can be achieved by adding a postinit block into the WallRectangle class:
    
public class WallRectangle extends CustomNode {

. . . . . .

postinit {
 // initialize the data model while drawing the maze
 MazeData.setBlockMazeData(x1, y1, x2, y2);
}

. . . . . .

}
   
   The method MazeData.setBlockMazeData(x1,y1,x2,y2) updates the data model by  setting all of the points of a rectangle to the value BLOCK. The values  x1, y1 and x2, y2 are the coordinates of the rectangle's two corners.
   Drawing the Dots
  Now that the maze is drawn, let's work on the dots. There are two types of dots in the game:  normal dots and magic dots. The magic dots are bigger in size and they continually flash.  If the Pac-Man character gobbles the magic dots, he has the power to eat ghosts for a short  period of time. Our Dot class extends the CustomNode class, a nd adds functionality to achieve the desired behavior. Take a look at the source code in Dot.fx,  shown below: 
    
/*
* Dot.fx
*
* Created on 2008-12-21, 21:59:45
*/

package pacman;

/**
* @author Henry Zhang
*/

import java.lang.Math;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.scene.CustomNode;
import javafx.scene.Node;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;

public class Dot extends CustomNode {

public var dotType: Integer;

// location of the dot
public var x : Number ;
public var y : Number ;

// radius of the dot
public var r: Number =
if ( dotType == MazeData.MAGIC_DOT ) 5 else 1;

// the dot
var circle = Circle{
 centerX: x
 centerY: y
 radius: bind r
 fill: Color.YELLOW
 visible: bind visible   // bind to Dot.visible
 } ;

// variables for magic dot's growing/shrinking animation
public var animationRadius: Number = 3;
public var delta: Number = -1;
var timeline: Timeline;

// create the animation timeline for magic dot
public function createTimeline(): Timeline {
 Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames: [
      KeyFrame {
         time: 250ms
         action: function() {
            doOneTick();
          }
       }
    ]
      }
}

public function playTimeline() {
 if ( timeline == null )
 timeline = createTimeline();

 timeline.play();
}

// do the animation
public function doOneTick () {

 if ( visible == false )
 return;

 animationRadius += delta;
 var x = Math.abs(animationRadius) + 3;

 if ( x > 5 ) {
    delta = -delta;
  }

 r = x;
}

public override function create(): Node {
     return circle;
}
}
   
    The Circle class is used to display the dots. For a magic dot,  we continually change its radius to create the blinking effect. A Timeline instance generates  an animation frame every 250ms. The doOneTick() function is invoked each time  to adjust the value of the radius. Binding, an important feature of JavaFX, is used in  the Circle object to link it with the data model. During an animation  process, there is no need to manually update the GUI object because its radius is bound  to the model. 
   Now that the Dot class is ready, we can put dots into the maze.  To accomplish this, we'll add the three functions shown below to the Maze class:
     
// create a Dot GUI object
public function createDot(  x1: Number,  y1:Number, type:Integer ): Dot {
var d = Dot {
   x: MazeData.calcGridX(x1)
   y: MazeData.calcGridY(y1)
   dotType: type
   visible: true
   }

if ( d.dotType == MazeData.MAGIC_DOT )
  d.playTimeline();

// set the dot type in data model
MazeData.setData( x, y, dotType ) ;

return d;
}

// put dots into the maze as a horizontal line
public function putDotHorizontally(x1: Integer, x2: Integer, y: Number ) {

var dots =
for ( x in [ x1..x2] )
  if ( MazeData.getData(x,y) == MazeData.EMPTY ) {
     var dotType: Integer;

     if ( (x == 28 or x == 1) and (y == 3 or y == 26) )
       dotType = MazeData.MAGIC_DOT
     else
       dotType = MazeData.NORMAL_DOT;

     createDot( x, y, dotType )
   }
  else   [] ;

insert dots into group.content;
}

// put dots into the maze as a vertical line
public function putDotVertically(x: Integer, y1: Integer, y2: Number ) {

var dots =
for ( y in [ y1..y2] )
  if ( MazeData.getData(x,y) == MazeData.EMPTY ) {
     var dotType: Integer;

     if ( (x == 28 or x == 1) and (y == 3 or y == 26) )
       dotType = MazeData.MAGIC_DOT
     else
       dotType = MazeData.NORMAL_DOT;

     createDot( x, y, dotType )
   }
  else  [];

insert dots into group.content;
}
   
     The createDot() function creates a Dot object based on its  coordinates (x,y) and its type (NORMAL_DOT or MAGIC_DOT). Again, while we are creating the dots,  we bind the dot status to our data model with the following statement:
   // set the dot type to data model
MazeData.setData( x, y, dotType ) ;
   The putDotHorizontally() function places a horizontal line of dots into the maze and makes four of them the magic dots. 
  The putDotVertically() function is almost the same as putDotHorizontally() except that it puts dots in a vertical fashion.
  Last thing is to put all the dots into the maze. We add some code to the postinit block of the Maze class:
    
public class Maze extends CustomNode {

. . . . . .

// put dots into the maze 
postinit {
 putDotHorizontally(2,13,1);
 putDotHorizontally(16,27,1);
 putDotHorizontally(2,27,5);
 putDotHorizontally(2,27,28);

 putDotHorizontally(2,13,24);
 putDotHorizontally(16,27,24);

 putDotHorizontally(2,5,8);
 putDotHorizontally(9,13,8);
 putDotHorizontally(16,20,8);
 putDotHorizontally(24,27,8);

 putDotHorizontally(2,5,18);
 putDotHorizontally(9,13,21);
 putDotHorizontally(16,20,21);
 putDotHorizontally(24,27,18);

 putDotHorizontally(2,3,21);
 putDotHorizontally(26,27,21);

 putDotVertically(1,1,8);
 putDotVertically(1,18,21);
 putDotVertically(1,24,28);

 putDotVertically(28,1,8);
 putDotVertically(28,18,21);
 putDotVertically(28,24,28);

 putDotVertically(6,2,27);
 putDotVertically(23,2,27);

 putDotVertically(3,22,23);
 putDotVertically(9,22,23);
 putDotVertically(20,22,23);
 putDotVertically(26,22,23);

 putDotVertically(13,25,27);
 putDotVertically(16,25,27);

 putDotVertically(9,6,7);
 putDotVertically(20,6,7);

 putDotVertically(13,2,4);
 putDotVertically(16,2,4);
}
. . . . .
}
   
   If you'd like to see the result so far, run the program and you'll get a maze populated with dots, four of which are the flashing magic dots: 
 

Launch 
  Building an Index of Dot References
  In preparation for the next phase,we need to do one more thing. During the game, we need a fast way to get the reference of a Dot object at point (x, y). Our current code does not support an efficient reference. So in MazeData.java,  we define a 2D array dotPointers to store the references to these dots.  Two accessor methods are added as well, using the Object type to store the references to JavaFX Dot instances.
    
public class MazeData {

. . . . . .

static Object dotPointers[][] = new Object[GRID_SIZE + 1][GRID_SIZE + 1];

. . . . . .

public static Object getDot(int x, int y) {
 return dotPointers[x][y];
}

public static void setDot(int x, int y, Object dot) {
 dotPointers[x][y] = dot;
}

. . . . . .
}
   
   In Maze.createDot(), we add a line to update the pointer in the data model:
    
public function createDot( x1: Number, y1:Number, type:Integer ): Dot {
var d = Dot {
   x: MazeData.calcGridX(x1)
   y: MazeData.calcGridY(y1)
   dotType: type
   visible: true
   }

if ( d.dotType == MazeData.MAGIC_DOT )
  d.playTimeline();

// set the dot type in data model 
MazeData.setData( x1, y1, type );

// set dot reference 
MazeData.setDot( x1, y1, d );

return d;
} 
   
  Congratulations! You've completed the first phase of the Pac-Man game in which a maze and its dots are drawn. In subsequent articles, we will introduce the Pac-Man character and ghosts.
  Download Source Code

www.insideria.com



Top Ten Tomcat Configuration Tips 2 (Final)
2009-08-02T16:57:00.004+07:00
6. Configuring Single Sign-On

Once you've set up your realm and method of authentication, you'll need to deal with the actual process of logging the user in. More often than not, logging into an application is a nuisance to an end user, and you will need to minimize the number of times they must authenticate. By default, each web application will ask the user to log in the first time the user requests a protected resource. This can seem like a hassle to your users if you run multiple web applications and each application asks the user to authenticate. Users cannot tell how many separate applications make up any single web site, so they won't know when they're making a request that crosses a context boundary, and will wonder why they're being repeatedly asked to log in.

The "single sign-on" feature of Tomcat 4 allows a user to authenticate only once to access all of the web applications loaded under a virtual host. To use this feature, you need only add a SingleSignOn Valve element at the host level. This looks like the following:


<Valve className="org.apache.catalina.authenticator.SingleSignOn"
      debug="0"/>


The Tomcat distribution's default server.xml contains a commented-out single sign-on Valve configuration example that you can uncomment and use. Then, any user who is considered valid in a context within the configured virtual host will be considered valid in all other contexts for that same host.

There are several important restrictions for using the single sign-on valve:

  


The valve must be configured and nested within the same Host element that the web applications (represented by Context elements) are nested within.


The Realm that contains the shared user information must be configured either at the level of the same Host or in an outer nesting.

The Realm cannot be overridden at the Context level.

The web applications that use single sign-on must use one of Tomcat's built-in authenticators (in the <auth-method> element of web.xml), rather than a custom authenticator. The built-in methods are basic, digest, form, and client-cert authentication.


If you're using single sign-on and wish to integrate another third-party web application into your web site, and the new web application uses only its own authentication code that doesn't use container-managed security, you're basically stuck. Your users will have to log in once for all of the web applications that use single sign-on, and then once again if they make a request to the new third-party web application. Of course, if you get the source and you're a developer, you could fix it, but that's probably not so easy to do.

The single sign-on valve requires the use of HTTP cookies.


7. Configuring Customized User Directories

Some sites like to allow individual users to publish a directory of web pages on the server. For example, a university department might want to give each student a public area, or an ISP might make some web space available on one of its servers to customers that don't have a virtually hosted web server. In such cases, it is typical to use the tilde character (~) plus the user's name as the virtual path of that user's web site:

http://www.cs.myuniversity.edu/~username
http://members.mybigisp.com/~username

Tomcat gives you two ways to map this on a per-host basis, using a couple of special Listener elements. The Listener's className attribute should be org.apache.catalina.startup.UserConfig, with the userClass attribute specifying one of several mapping classes. If your system runs Unix, has a standard /etc/passwd file that is readable by the account running Tomcat, and that file specifies users' home directories, use the PasswdUserDatabase mapping class:


<Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html"
userClass="org.apache.catalina.startup.PasswdUserDatabase"/>

Web files would need to be in directories such as /home/users/ian/public_html or /users/jbrittain/public_html. Of course, you can change public_html to be whatever subdirectory into which your users put their personal web pages.

In fact, the directories don't have to be inside of a user's home directory at all. If you don't have a password file but want to map from a user name to a subdirectory of a common parent directory such as /home, use the HomesUserDatabase class:


<Listener className="org.apache.catalina.startup.UserConfig"
directoryName="public_html" homeBase="/home"
userClass="org.apache.catalina.startup.HomesUserDatabase"/>

In this case, web files would be in directories such as  /home/ian/public_html or /home/jasonb/public_html.  This format is more useful on Windows, where you'd likely use a directory such as C:\home.

These Listener elements, if present, must be inside of a Host element, but not inside of a Context element, as they apply to the Host itself.


8. Using CGI Scripts with Tomcat

Tomcat is primarily meant to be a servlet/JSP container, but it has many capabilities rivalling a traditional web server. One of these is support for the Common Gateway Interface (CGI), which provides a means for running an external program in response to a browser request, typically to process a web-based form. CGI is called "common" because it can invoke programs in almost any programming or scripting language: Perl, Python, awk, Unix shell scripting, and even Java are all supported options. However, you probably wouldn't run a Java application as a CGI due to the start-up overhead; elimination of this overhead was what led to the original design of the servlet specification. Servlets are almost always more efficient than CGIs because you're not starting up a new operating-system-level process every time somebody clicks on a link or button.

Tomcat includes an optional CGI servlet that allows you to run legacy CGI scripts; the assumption is that most new back-end processing will be done by user-defined servlets and JSPs.

To enable Tomcat's CGI servlet, you must do the following:


Rename the file servlets-cgi.renametojar (found in CATALINA_HOME/server/lib/) to servlets-cgi.jar, so that the servlet that processes CGI scripts will be on Tomcat's CLASSPATH.


In Tomcat's CATALINA_BASE/conf/web.xml file, uncomment the definition of the servlet named cgi (this is around line 241 in the distribution).

Also in Tomcat's web.xml, uncomment the servlet mapping for the cgi servlet (around line 299 in the distributed file). Remember, this specifies the HTML links to the CGI script.

Either place the CGI scripts under the WEB-INF/cgi directory (remember that WEB-INF is a safe place to hide things that you don't want the user to be able to view, for security reasons), or place them in some other directory within your context and adjust the cgiPathPrefix initialization parameter of the CGIServlet to identify the directory containing the files. This specifies the actual location of the CGI scripts, which typically will not be the same as the URL in the previous step.


Restart Tomcat, and your CGI processing should now be operational.


The default directory for the servlet to locate the actual scripts is WEB-INF/cgi. As has been noted, the WEB-INF directory is protected against casual snooping from browsers, so this is a good place to put CGI scripts, which may contain passwords or other sensitive information. For compatibility with other servers, though, you may prefer to keep the scripts in the traditional directory, /cgi-bin, but be aware that files in this directory may be viewable by the curious web surfer.  Also, on Unix, be sure that the CGI script files are executable by the user under which you are running Tomcat.

9. Changing Tomcat's JSP Compiler

In Tomcat 4.1 (and above, presumably), compilation of JSPs is performed by using the Ant program controller directly from within Tomcat. This sounds a bit strange, but it's part of what Ant was intended for; there is a documented API that lets developers use Ant without starting up a new JVM. This is one advantage of having Ant written in Java. Plus, it means you can now use any compiler supported by the javac task within Ant; these are listed in the javac page of the Apache Ant manual. It is easy to use because you need only an <init-param> with a name of "compiler" and a value of one of the supported compiler names:



<servlet>
   <servlet-name>jsp</servlet-name>
   <servlet-class>
     org.apache.jasper.servlet.JspServlet
   </servlet-class>
   <init-param>

     <param-name>logVerbosityLevel</param-name>
     <param-value>WARNING</param-value>
   </init-param>
   <init-param>
     <param-name>compiler</param-name>

     <param-value>jikes</param-value>
   </init-param>
   <load-on-startup>3</load-on-startup>
</servlet>

Of course, the given compiler must be installed on your system, and the CLASSPATH may need to be set, depending on which compiler you choose.


10. Restricting Access to Specific Hosts

Sometimes you'll only want to restrict access to Tomcat's web app to only specified host names or IP addresses. This way, only clients at those specified sites will be served content. Tomcat comes with two Valves that you can configure and use for this purpose: RemoteHostValve and RemoteAddrValve.

These Valves allow you to filter requests by host name or by IP address, and to allow or deny hosts that match, similar to the per-directory Allow/Deny directives in Apache httpd. If you run the Admin application, you might want to only allow access to it from localhost, as follows:



<Context path="/path/to/secret_files" ...>
 <Valve className="org.apache.catalina.valves.RemoteAddrValve"
        allow="127.0.0.1" deny=""/>
</Context>

If no allow pattern is given, then patterns that match the deny attribute patterns will be rejected, and all others will be allowed. Similarly, if no deny pattern is given, patterns that match the allow attribute will be allowed, and all others will be denied.
O'Reilly Media



Top Ten Tomcat Configuration Tips 1
2009-02-02T15:20:00.004+07:00
Coauthor's note: Now that writing Java web applications has become a common way to create and deploy new web content, people around the globe are finding the Jakarta Tomcat servlet and JSP container useful. It's free, it's multiplatform, it's rich in features, it's rapidly evolving and improving, and it's never been more popular. The only catch seems to be this: how can you configure Tomcat to do what you want it to do? Tomcat is capable, as long as you can configure it to suit your needs. Below is my list of ten Tomcat configuration tips, taken from Tomcat: The Definitive Guide, to help you do just that. -- Jason Brittain
 
 1. Configuring the Admin Web Application
 Most commercial J2EE servers provide a fully functional administrative interface, and many of these are accessible as web applications. The Tomcat Admin application is on its way to becoming a full-blown Tomcat administration tool rivaling these commercial offerings. First included in Tomcat 4.1, Admin already provides control over contexts, data sources, and users and groups. You can also control resources such as initialization parameters, as well as users, groups, and roles in a variety of user databases. The list of capabilities will be expanded upon in future releases, but the present implementation has proven itself to be quite useful.
 The Admin web application is defined in the auto-deployment file CATALINA_BASE/webapps/admin.xml.
 You must edit this file to ensure that the path specified in the docBase attribute of the Context element is absolute; that is,  the absolute path of CATALINA_HOME/server/webapps/admin. Alternatively, you could just remove the auto-deployment file and specify the Admin context manually in your server.xml file. On machines that will not be managed by this application, you should probably disable it altogether by simply removing CATALINA_BASE/webapps/admin.xml.
 If you're using a UserDatabaseRealm (the default), you'll need to add a user and a role to the CATALINA_BASE/conf/tomcat-users.xml file.  For now, just edit this file, and add a role named "admin" to your users database:
 <role name="admin"/>
 You must also have a user who is assigned to the "admin" role. Add a user line like this after the existing user entries (changing the password to something a bit more secure):
 <user name="admin" password="deep_dark_secret" roles="admin"/>
 Once you've performed these steps and restarted Tomcat, visit the URL http://localhost:8080/admin, and you should see a login screen. The Admin application is built using container-managed security and the Jakarta Struts framework. Once you have logged in as a user assigned to the admin role, you will be able to use the Admin application to configure Tomcat.
 2. Configuring the Manager Web Application
 The Manager web application lets you perform simple management tasks on your web applications through a more simplified web user interface than that of the Admin web app.
 The Manager web application is defined in the auto-deployment file CATALINA_BASE/webapps/manager.xml.
 You must edit this file to ensure that the path specified in the docBase attribute of the Context element is absolute; that is,  the absolute path of CATALINA_HOME/server/webapps/manager.
 If you're using the default UserDatabaseRealm, you'll need to add a user and role to the CATALINA_BASE/conf/tomcat-users.xml file. For now, just edit this file, and add a role named "manager" to your users database:
 <role name="manager"/>
 You must also have a user who is assigned the "manager" role. Add a user line like this after the existing user entries (changing the password to something a bit more secure):
 <user name="manager" password="deep_dark_secret" roles="manager"/>
 Then restart Tomcat and visit the URL http://localhost/manager/list to see the plain-text manager interface, or http://localhost/manager/html/list for the simple HTML manager interface. Either way, your Manager application should now be working.
 The Manager application lets you install new web applications on a non-persistent basis, for testing. If we have a web application in /home/user/hello and want to test it by installing it under the URI /hello, we put "/hello" in the first text input field (for Path) and "file:/home/user/hello" in the second text input field (for Config URL).
 The Manager also allows you to stop, reload, remove, or undeploy a web application. Stopping an application makes it unavailable until further notice, but of course it can then be restarted. Users attempting to access a stopped application will receive an error message, such as 503 - This application is not currently available.
 Removing a web application removes it only from the running copy of Tomcat -- if it was started from the configuration files, it will reappear the next time you restart Tomcat (i.e., removal does not remove the web application's content from disk).
 3. Deploying a Web Application
 There are two ways of deploying a web application on the filesystem:
 1. Copy your WAR file or your web application's directory (including all of its content) to the $CATALINA_BASE/webapps directory.
 2. Create an XML fragment file with just the Context element for your web application, and place this XML file in $CATALINA_BASE/webapps. The web application itself can then be stored anywhere on your filesystem.
 If you have a WAR file, you can deploy it by simply copying the WAR file into the directory CATALINA_BASE/webapps. The filename must end with an extension of ".war". Once Tomcat notices the file, it will (by default) unpack it into a subdirectory with the base name of the WAR file. It will then create a context in memory, just as though you had created one by editing Tomcat's server.xml file. However, any necessary defaults will be obtained from the DefaultContext element in Tomcat's server.xml file.
 Another way to deploy a web app is by writing a Context XML fragment file and deploying it into the CATALINA_BASE/webapps directory. A context fragment is not a complete XML document, but just one Context element and any subelements that are appropriate for your web application. These files are like Context elements cut out of the server.xml file, hence the name "context fragment."
 For example, if we wanted to deploy the WAR file MyWebApp.war along with a realm for accessing parts of that web application, we could use this fragment:
 
<!--
Context fragment for deploying MyWebApp.war
-->
<Context path="/demo" docBase="webapps/MyWebApp.war"
     debug="0" privileged="true">
<Realm className="org.apache.catalina.realm.UserDatabaseRealm"
     resourceName="UserDatabase"/>
</Context>
 Put that in a file called "MyWebApp.xml," and copy it into your CATALINA_BASE/webapps directory.
 These context fragments provide a convenient method of deploying web applications; you do not need to edit the server.xml file and, unless you have turned off the default liveDeploy feature, you don't have to restart Tomcat to install a new web application.
 4. Configuring Virtual Hosts
 The Host element normally needs modification only when you are setting up virtual hosts. Virtual hosting is a mechanism whereby one web server process can serve multiple domain names, giving each domain the appearance of having its own server. In fact, the majority of small business web sites are implemented as virtual hosts, due to the expense of connecting a computer directly to the Internet with sufficient bandwidth to provide reasonable response times and the stability of a permanent IP address.
 Name-based virtual hosting is created on any web server by establishing an aliased IP address in the Domain Name Service (DNS) data and telling the web server to map all requests destined for the aliased address to a particular directory of web pages. Since this article is about Tomcat, we don't try to show all of the ways to set up DNS data on various operating systems. If you need help with this, please refer to DNS and Bind, by Paul Albitz and Cricket Liu (O'Reilly). For demonstration purposes, I'll use a static hosts file, since that's the easiest way to set up aliases for testing purposes.
 To use virtual hosts in Tomcat, you just need to set up the DNS or hosts data for the host. For testing, making an IP alias for localhost is sufficient. You then need to add a few lines to the server.xml configuration file:
 
<Server port="8005" shutdown="SHUTDOWN" debug="0">
<Service name="Tomcat-Standalone">
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"/>
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8443" minProcessors="5" maxProcessors="75"
acceptCount="10" debug="0" scheme="https" secure="true"/>
  <Factory className="org.apache.coyote.tomcat4.CoyoteServerSocketFactory"
clientAuth="false" protocol="TLS" />
</Connector>
<Engine name="Standalone" defaultHost="localhost" debug="0">
  <!-- This Host is the default Host -->
  <Host name="localhost" debug="0" appBase="webapps"
    unpackWARs="true" autoDeploy="true">
    <Context path="" docBase="ROOT" debug="0"/>
    <Context path="/orders" docBase="/home/ian/orders" debug="0"
                   reloadable="true" crossContext="true">
    </Context>
  </Host>

  <!-- This Host is the first "Virtual Host": www.example.com -->
  <Host name="www.example.com" appBase="/home/example/webapp">
    <Context path="" docBase="."/>
  </Host>

</Engine>
</Service>
</Server>
 Tomcat's server.xml file, as distributed, contains only one virtual host, but it is easy to add support for additional virtual hosts. The simplified version of the server.xml file in the previous example shows in bold the overall additional structure needed to add one virtual host. Each Host element must have one or more Context elements within it; one of these must be the default Context for this host, which is specified by having its relative path set to the empty string (for example,  path="").
 5. Configuring Basic Authentication
 Container-managed authentication methods control how a user's credentials are verified when a web app's protected resource is accessed.  When a web application uses basic authentication (BASIC in the web.xml file's auth-method element), Tomcat uses HTTP basic authentication to ask the web browser for a username and password whenever the browser requests a resource of that protected web application. With this authentication method, all passwords are sent across the network in base64-encoded text.
 Note: using basic authentication is generally considered insecure because it does not strongly encrypt passwords, unless the site also uses HTTPS or some other form of encryption between the client and the server (for instance, a virtual private network). Without this extra encryption, network monitors can intercept (and misuse) users' passwords.  But, if you're just starting to use Tomcat, or if you just want to test container-managed security with your web app, basic authentication is easy to set up and test.  Just add <security-constraint> and <login-config> elements to your web app's web.xml file, and add the appropriate <role> and <user> elements to your CATALINA_BASE/conf/tomcat-users.xml file, restart Tomcat, and Tomcat takes care of the rest.
 The example below shows a web.xml excerpt from a club membership web site with a members-only subdirectory that is protected using basic authentication. Note that this effectively takes the place of the Apache web server's .htaccess files.
 
<!--
Define the Members-only area, by defining
a "Security Constraint" on this Application, and
mapping it to the subdirectory (URL) that we want
to restrict.
-->
<security-constraint>
<web-resource-collection>
<web-resource-name>
  Entire Application
</web-resource-name>
<url-pattern>/members/*</url-pattern>
</web-resource-collection>
<auth-constraint>
  <role-name>member</role-name>
</auth-constraint>
</security-constraint>
<!-- Define the Login Configuration for this Application -->
<login-config>
<auth-method>BASIC</auth-method>
<realm-name>My Club Members-only Area</realm-name>
</login-config>


O'Reilly Media

Moving Direction	`xDirection`	`yDirection`
Left	-1	0
Right	1	0
Up	0	-1
Down	0	1

Type	Value	Explanation
BLOCK	1	The point is part of a "wall" of the maze
NORMAL_DOT	2	The point contains a normal dot
MAGIC_DOT	3	The point contains a magic dot
EMPTY	0	The point does not have any of the above objects at it