Cut-win
Cut-win is a new URL shortener website.It is paying at the time and you can trust it.You just have to sign up for an account and then you can shorten your URL and put that URL anywhere.You can paste it into your site, blog or even social media networking sites.It pays high CPM rate.
You can earn $10 for 1000 views.You can earn 22% commission through the referral system.The most important thing is that you can withdraw your amount when it reaches $1.- The payout for 1000 views-$10
- Minimum payout-$1
- Referral commission-22%
- Payment methods-PayPal, Payza, Bitcoin, Skrill, Western Union and Moneygram etc.
- Payment time-daily
Bc.vc
Bc.vc is another great URL Shortener Site. It provides you an opportunity to earn $4 to $10 per 1000 visits on your Shortened URL. The minimum withdrawal is $10, and the payment method used PayPal or Payoneer.
Payments are made automatically on every seven days for earnings higher than $10.00. It also runs a referral system wherein the rate of referral earning is 10%.- The payout for 1000 views-$10
- Minimum payout -$10
- Referral commission-10%
- Payment method -Paypal
- Payment time-daily
Ouo.io
Ouo.io is one of the fastest growing URL Shortener Service. Its pretty domain name is helpful in generating more clicks than other URL Shortener Services, and so you get a good opportunity for earning more money out of your shortened link. Ouo.io comes with several advanced features as well as customization options.
With Ouo.io you can earn up to $8 per 1000 views. It also counts multiple views from same IP or person. With Ouo.io is becomes easy to earn money using its URL Shortener Service. The minimum payout is $5. Your earnings are automatically credited to your PayPal or Payoneer account on 1st or 15th of the month.- Payout for every 1000 views-$5
- Minimum payout-$5
- Referral commission-20%
- Payout time-1st and 15th date of the month
- Payout options-PayPal and Payza
Al.ly
Al.ly is another very popular URL Shortening Service for earning money on short links without investing any single $. Al.ly will pay from $1 to $10 per 1000 views depending upon the different regions. Minimum withdrawal is only $1, and it pays through PayPal, Payoneer, or Payza. So, you have to earn only $1.00 to become eligible to get paid using Al.ly URL Shortening Service.
Besides the short links, Al.ly also runs a referral program wherein you can earn 20% commission on referrals for a lifetime. The referral program is one of the best ways to earn even more money with your short links. Al.ly offers three different account subscriptions, including free option as well as premium options with advanced features.Fas.li
Although Fas.li is relatively new URL Shortener Service, it has made its name and is regarded as one of the most trusted URL Shortener Company. It provides a wonderful opportunity for earning money online without spending even a single $. You can expect to earn up to $15 per 1000 views through Fas.li.
You can start by registering a free account on Fas.li, shrink your important URLs, and share it with your fans and friends in blogs, forums, social media, etc. The minimum payout is $5, and the payment is made through PayPal or Payza on 1st or 15th of each month.
Fas.li also run a referral program wherein you can earn a flat commission of 20% by referring for a lifetime. Moreover, Fas.li is not banned in anywhere so you can earn from those places where other URL Shortening Services are banned.LINK.TL
LINK.TL is one of the best and highest URL shortener website.It pays up to $16 for every 1000 views.You just have to sign up for free.You can earn by shortening your long URL into short and you can paste that URL into your website, blogs or social media networking sites, like facebook, twitter, and google plus etc.
One of the best thing about this site is its referral system.They offer 10% referral commission.You can withdraw your amount when it reaches $5.- Payout for 1000 views-$16
- Minimum payout-$5
- Referral commission-10%
- Payout methods-Paypal, Payza, and Skrill
- Payment time-daily basis
Clk.sh
Clk.sh is a newly launched trusted link shortener network, it is a sister site of shrinkearn.com. I like ClkSh because it accepts multiple views from same visitors. If any one searching for Top and best url shortener service then i recommend this url shortener to our users. Clk.sh accepts advertisers and publishers from all over the world. It offers an opportunity to all its publishers to earn money and advertisers will get their targeted audience for cheapest rate. While writing ClkSh was offering up to $8 per 1000 visits and its minimum cpm rate is $1.4. Like Shrinkearn, Shorte.st url shorteners Clk.sh also offers some best features to all its users, including Good customer support, multiple views counting, decent cpm rates, good referral rate, multiple tools, quick payments etc. ClkSh offers 30% referral commission to its publishers. It uses 6 payment methods to all its users.- Payout for 1000 Views: Upto $8
- Minimum Withdrawal: $5
- Referral Commission: 30%
- Payment Methods: PayPal, Payza, Skrill etc.
- Payment Time: Daily
Wi.cr
Wi.cr is also one of the 30 highest paying URL sites.You can earn through shortening links.When someone will click on your link.You will be paid.They offer $7 for 1000 views.Minimum payout is $5.
You can earn through its referral program.When someone will open the account through your link you will get 10% commission.Payment option is PayPal.- Payout for 1000 views-$7
- Minimum payout-$5
- Referral commission-10%
- Payout method-Paypal
- Payout time-daily
Short.pe
Short.pe is one of the most trusted sites from our top 30 highest paying URL shorteners.It pays on time.intrusting thing is that same visitor can click on your shorten link multiple times.You can earn by sign up and shorten your long URL.You just have to paste that URL to somewhere.
You can paste it into your website, blog, or social media networking sites.They offer $5 for every 1000 views.You can also earn 20% referral commission from this site.Their minimum payout amount is only $1.You can withdraw from Paypal, Payza, and Payoneer.- The payout for 1000 views-$5
- Minimum payout-$1
- Referral commission-20% for lifetime
- Payment methods-Paypal, Payza, and Payoneer
- Payment time-on daily basis
BIT-URL
It is a new URL shortener website.Its CPM rate is good.You can sign up for free and shorten your URL and that shortener URL can be paste on your websites, blogs or social media networking sites.bit-url.com pays $8.10 for 1000 views.
You can withdraw your amount when it reaches $3.bit-url.com offers 20% commission for your referral link.Payment methods are PayPal, Payza, Payeer, and Flexy etc.- The payout for 1000 views-$8.10
- Minimum payout-$3
- Referral commission-20%
- Payment methods- Paypal, Payza, and Payeer
- Payment time-daily
Linkrex.net
Linkrex.net is one of the new URL shortener sites.You can trust it.It is paying and is a legit site.It offers high CPM rate.You can earn money by sing up to linkrex and shorten your URL link and paste it anywhere.You can paste it in your website or blog.You can paste it into social media networking sites like facebook, twitter or google plus etc.
You will be paid whenever anyone will click on that shorten a link.You can earn more than $15 for 1000 views.You can withdraw your amount when it reaches $5.Another way of earning from this site is to refer other people.You can earn 25% as a referral commission.- The payout for 1000 views-$14
- Minimum payout-$5
- Referral commission-25%
- Payment Options-Paypal,Bitcoin,Skrill and Paytm,etc
- Payment time-daily
Adf.ly
Adf.ly is the oldest and one of the most trusted URL Shortener Service for making money by shrinking your links. Adf.ly provides you an opportunity to earn up to $5 per 1000 views. However, the earnings depend upon the demographics of users who go on to click the shortened link by Adf.ly.
It offers a very comprehensive reporting system for tracking the performance of your each shortened URL. The minimum payout is kept low, and it is $5. It pays on 10th of every month. You can receive your earnings via PayPal, Payza, or AlertPay. Adf.ly also runs a referral program wherein you can earn a flat 20% commission for each referral for a lifetime.Oke.io
Oke.io provides you an opportunity to earn money online by shortening URLs. Oke.io is a very friendly URL Shortener Service as it enables you to earn money by shortening and sharing URLs easily.
Oke.io can pay you anywhere from $5 to $10 for your US, UK, and Canada visitors, whereas for the rest of the world the CPM will not be less than $2. You can sign up by using your email. The minimum payout is $5, and the payment is made via PayPal.- The payout for 1000 views-$7
- Minimum payout-$5
- Referral commission-20%
- Payout options-PayPal, Payza, Bitcoin and Skrill
- Payment time-daily
Short.am
Short.am provides a big opportunity for earning money by shortening links. It is a rapidly growing URL Shortening Service. You simply need to sign up and start shrinking links. You can share the shortened links across the web, on your webpage, Twitter, Facebook, and more. Short.am provides detailed statistics and easy-to-use API.
It even provides add-ons and plugins so that you can monetize your WordPress site. The minimum payout is $5 before you will be paid. It pays users via PayPal or Payoneer. It has the best market payout rates, offering unparalleled revenue. Short.am also run a referral program wherein you can earn 20% extra commission for life.CPMlink
CPMlink is one of the most legit URL shortener sites.You can sign up for free.It works like other shortener sites.You just have to shorten your link and paste that link into the internet.When someone will click on your link.
You will get some amount of that click.It pays around $5 for every 1000 views.They offer 10% commission as the referral program.You can withdraw your amount when it reaches $5.The payment is then sent to your PayPal, Payza or Skrill account daily after requesting it.- The payout for 1000 views-$5
- Minimum payout-$5
- Referral commission-10%
- Payment methods-Paypal, Payza, and Skrill
- Payment time-daily
Linkbucks
Linkbucks is another best and one of the most popular sites for shortening URLs and earning money. It boasts of high Google Page Rank as well as very high Alexa rankings. Linkbucks is paying $0.5 to $7 per 1000 views, and it depends on country to country.
The minimum payout is $10, and payment method is PayPal. It also provides the opportunity of referral earnings wherein you can earn 20% commission for a lifetime. Linkbucks runs advertising programs as well.- The payout for 1000 views-$3-9
- Minimum payout-$10
- Referral commission-20%
- Payment options-PayPal,Payza,and Payoneer
- Payment-on the daily basis
Shrinkearn.com
Shrinkearn.com is one of the best and most trusted sites from our 30 highest paying URL shortener list.It is also one of the old URL shortener sites.You just have to sign up in the shrinkearn.com website. Then you can shorten your URL and can put that URL to your website, blog or any other social networking sites.
Whenever any visitor will click your shortener URL link you will get some amount for that click.The payout rates from Shrinkearn.com is very high.You can earn $20 for 1000 views.Visitor has to stay only for 5 seconds on the publisher site and then can click on skip button to go to the requesting site.- The payout for 1000 views- up to $20
- Minimum payout-$1
- Referral commission-25%
- Payment methods-PayPal
- Payment date-10th day of every month
Friday, March 29, 2019
Top 17 Highest Paying URL Shortener 2019: Best URL Shortener to Earn Money
Resident Evil 2 Remake | Review
Resident Evil 2 Remake - Review
The best remake of mine is playing the 2002 remake of the first Resident Evil on GameCube with its perfectly refreshed visuals, totally new areas to explore, and unnerving new monsters. Now, in 2019, Capcom has given me another experience I'll recollect for quite a while: this ground-up remake of Resident Evil 2 is an extremely fun, exceptionally frightening experience because of its totally new and modern graphics, controls, and some brilliant quality-of-life upgrades. The two playable characters' stories aren't as different as I've expected, yet I enjoyed every gory moment of my return to Leon Kennedy and Claire Redfield's shoes.
Reliving familiar frights can often make for a less than exciting horror experience. But, with the remake of Resident Evil 2, Capcom shows respect for the original while additionally putting forth an admirable attempt to give the macabre atmosphere and tense gameplay a recognizable upgrade. In doing as such, this revamp of the classic survival horror game shows that the series can still offer an terrifying experience like no other.
Resident Evil 2 takes place in the zombie-infected Raccoon City. The story follows rookie cop Leon Kennedy and college student Claire Redfield, who is searching for her brother, Resident Evil protagonist Chris Redfield. Leon is drawn into the path of a mysterious femme fatale. Claire takes responsibility and tries to protect a kid. Their stories intersects - players experience one story, then play the other character's perspective—making an tapestry of one night's event in Raccoon City.
Resident Evil 2 is terrifying, and in an effective way that few other games manage to accomplish. The game is astonishing in the manner in which it fills players with fear, building anxiety with splendid sound design, cunningly placed jump scares, and overwhelming darkness. Players spend vast majority of the game fumbling through the dark, often running low on supplies and constantly having to deal with variety of undead horrors like zombies, lickers, and that's only the tip of the iceberg. Even standard zombies are a threat this time around, making each experience tense and meaningful.
Out of all the freaky monsters in Resident Evil 2, the scariest is by far the Mr. X Tyrant. Mr. X's appearance in the first Resident Evil 2 earned him a frightful reputation, but in the remake, he's a true force to be reckoned with. Whenever he shows up, Mr. X relentlessly stalks players, following them room to room like a slasher movie villain. Hearing his relentless footsteps getting louder and louder, knowing there is nothing you can do to stop him, fills you with a true sense of dread. With Mr. X breathing down their neck, Resident Evil 2 players will understand the horror movie trope of people tripping or committing mistakes when running from the villain isn't as outlandish as it appears. Players will fumble with their inventory as they attempt to rapidly solve puzzles before Mr. X arrives, or they may make a wrong turn and end to up at a dead-end, leaving them no choice but to confront the hulking monstrosity head-on.
Both Claire and Leon have two different versions of the campaign, and subsequent to completing the first run for the one, you'll be incited to begin a follow-up with the other. Called Second Scenarios, they allow you to see the larger story from a different perspective. Both scenarios are completely isolated from another, and decisions in that won't affect the other, however what makes these second runs a bit worthwhile are some experiences and sub-plots that don't happen in the first. It's an exceptionally fascinating approach to encounter the story, and with four versions of the campaign between the two leads - with the initial two averaging 11-14 hours - you always uncover new details and events that were absent in the previous playthroughs.
Resident Evil 2's more serious tone is additionally improved by the upgraded, fantastically atmospheric presentation, which gives familiar details from the classic game to a greater extent an articulated look and feel. Moving away from the static camera angles of the original, everything has been redesigned in light of over-the-shoulder gameplay, giving to a greater extent an unmistakable and obtrusive feeling of fear while exploring, This is increased significantly more by the flawless audio and visual design of the game, giving a creepy, isolating vibe all throughout the game. In number of cases, you'll just have the light of your flashlight as you walk the dark hallways of the bloody and ruined police headquarters, with the ambient rain and distant monsters sounds ramping up the tension. You feel safe in RE2, even when you really are.
Now, talking about the zombies, I must say these are the most terrifying and at the same time most perfect zombies I've ever seen in a game. And rather than pixelated characters running from pre-rendered background to pre-rendered background, Resident Evil 2 is a completely 3D, over-the-shoulder affair with atmospheric lightning effect, noteworthy facial animations, and the most terrifying looking zombies I've ever seen in a game. They're juicier than ever and I love the way in which they lurch around and respond when you blow off very specific chunks of their heads and hands cordiality of the satisfyingly detailed dismemberment system.
As always, inventory and ammunation management is still a key part of Resident Evil 2's gameplay. This is a real survival horror, where it generally appears as though you're barely scratching by with enough ammunition and medification. You can't carry all that you find with you, so what you should store and what you should carry is a fight continuously being waged in your mind.
The Verdict
Capcom did a fabulous job of resurrecting all the best parts of the classic Resident Evil 2 and making them look, sound, and play like a 2019 game. It's simply a strong horror game that delivers anxiety-inducing and grotesque situations, toping some of the series' best entries. But above all, the remake is an impressive game for the fact that it bets everything on the pure survival horror experience, unquestionably grasping its frightening tone and rarely letting up until the story's conclusion. The only disappointment you will find is the two characters stories' which aren't different enough to
Spider Man Web Of Shadows Free Download
How To Install Lego Marvel Super Heroes 2 without Errors and Problems
πΆπ΄πΆπΆπ΄πΆ DOWNLOAD HERE πΆπ΄πΆπΆπ΄πΆ
πΉ Please use IDM (Internet Download Manager) to download the files without any error.
π To Download Latest Movies In 720P & 1080P Visit My Other Site :- https://worldfree4utechno.blogspot.com/
1- Spiderman Web Of Shadows Part 1 (550 MB):-
Download
---------------------------------------
2- Spiderman Web Of Shadows Part 2 (550 MB):-
Download
πΉ Please use IDM (Internet Download Manager) to download the files without any error.
π Download Winrar :-
πΉ (64bit PC)
π Visual C++ Redistributable 2012 :-
If your PC has no net framework then, you can
π net framework 4.6
π IMPORTANT π:-
π IMPORTANT π:-
πΉ ALWAYS DISABLE YOUR ANTIVIRUS BEFORE EXTRACTING THE FILES.
πΉ Make sure your PC is free of Virus, otherwise they can currupt the files after downloading.
πΉ Please use IDM (Internet Download Manager) to download the files without any error.
Please Subscribe To My Channel ..... 1 Like And 1 Subscribe Will Motivate Me..
Thank You For Watching My Video.....
If You Think That Our Video Was Help Full Then Plzz Like Our Video ..
And Don't Forget To Subscribe To My Channel...
And Keep Visiting Our Channel, Keep Supporting Our Channel, And Keep Loving Our Channel ...
Once Again Thank You Sooooooo Much................
Review - GARAGE: BAD TRIP - Rat-burping Cannibal Corpses!
Directed like a 80s zombie movie shot through a surveillance camera, and all tinted with vibrant and glitchy colors seen on your old beloved VCR, Garage: Bad Trip lets you explore the dark corners of an underground parking, in which you'll find yourself constantly attacked with zombies and other various mutated monstrosities.
What the hell happened in here?
Grab your fire axe, I get my shotgun, and let's go bring freedom to these zombies!
Thursday, March 28, 2019
Warmaster Ancients - Gallic Counter Set
Printing the CountersI hope some of you find these counter sets useful.You can print these at office printing places, like Staples, using heavy card stock paper printed at actual size. You can also print on regular paper and then glue the counters to wooden bases. (Check the older posts on how I did this with my Empire army.) Currently, I'm printing the counter sets at Staples using regular paper, spray gluing the back of each sheet with Super77, attaching each sheet to an old comic book backing board, and then cutting out the counters using a sharp Xacto knife with steel ruler. Using the backing boards makes for cheap, sturdy counters.
Behind The Scenes: Video Game Pianist, Dr. Martin Leung, U-M Residency
Dr. Leung's visit was a major event in my year of research about this kind of music. I was really glad to see how much enthusiasm some of the piano majors had regarding this material. Even the faculty seemed pretty supportive of it as well. Most of all, I was just glad to make an School that in many ways is slow to update repertoire outside of the traditional canons and acknowledge career paths beyond the traditional "super star performer" face up to someone who has had success in another way. Although it definitely made a difference in the present culture, I think and hope it has the ability to make a difference down the road— that students and scholars who come after will be able to look back and say: "hey, this guy X years ago had a piano studio that played all video game music, so why can't I do Y?"
I'm sure some of my colleagues think I don't belong in this space, doing this research or teaching, and/or that the repertoire is not worthy of attention and focus. But I'm really learning this year just how much of a community this music creates. One of my favorite take away's from the week was when one of my students greeted Martin at the start of his lesson by explaining that finding Martin's YouTube channel over a decade ago also led him to a community of music lovers who were passionate about video games and video game music. One of the things I've learned in all my years of work in game audio is that gamers have a "coming out" process— many people play games, but they don't talk about it often. However, because of my work, people DO talk to me about their interest in gaming and what they're playing. I'm always glad when anyone can express him/here self more, and it was an emotional experience to see one of my students explain that he'd found inspiration from Martin and his playing video game music for years. Wow!
Lastly, I'll leave with a comment about the recital Martin played. (If you're interested in any of his arrangements, you can find them for free for a limited time on the sheet music portion of his website.) As you can see from the above picture, the recital was well attended by all sorts of students and even guests who had driven a long way to get to Ann Arbor to hear him. I really enjoyed the event and was delighted to play some duets with Martin at the end of the program. Turns out these are the first video game music duets that he's ever performed! I put these duets up on my videogamemusicnerd YouTube channel, but I'll share my favorite of these duets here. I absolutely loved playing Super Mario Galaxy, and also the reference to Super Mario Bros 3, in the middle of this duet. Despite the fact that we probably had only about 45 minutes to rehearse, these duets really came together. In fact, one of my students wrote a reaction to the recital, commenting: "The duets were incredible— really in sync— you seem to play off each other well." I think that playing piano duets is one of the hardest things to really have exactly together because of the percussive nature of the instrument, but we did it!
I think that Martin will eventually post the whole recital and I'll link to it here once he does. For now, you can see the other two on my channel if you like. Including some antics jumping around during Mario Kart Double Dash: Baby Park. About this duet, one of my students wrote: "BLUE SHELL! DUCK AND COVER!— that sort of thing is something you simply can't get at a normal concert/recital. Part of why I love video games so much; in the end, it's about fun."
Overall, a tremendously busy week, but also an important one in my research that I'm still digesting. Have you heard Martin play video game music? Did he inspire you and help you find a sense of community? I'd love to hear about it, if so.
Ekam: Works On Linux And OSX, And Looks Pretty

Above is what Ekam looks like when it is compiling some code. The fuchsia lines are currently running, while blue lines are completed. Errors, if there were any, would be red, and passing tests would be green (although Ekam does not yet run tests).
This weekend I:
- Implemented the fancy output above.
- Got Ekam working on Linux and OSX.
- Did a ton of refactoring to make components more reusable. This means that visible progress ought to come much quicker when I next work on it.
Some critical features are still missing:
- Ekam starts fresh every time it runs; it does not detect what tasks can be skipped.
- Ekam can only really be used to build itself, as it assumes that any symbol that doesn't contain the word "ekam" (i.e. is not in the "ekam" namespace) is satisfied by libc. To fix this I will need to make Ekam actually index libc to determine what symbols can be ignored.
- The only way to add new rule types (e.g. to support a new language) is to edit the Ekam source code.
- Ekam does not run tests.
As always, source code is at: http://ekam.googlecode.com/
Defining new rules
I've been thinking about this, and I think the interface Ekam will provide for defining new rules will be at the process level. So, you must write a program that implements your rule. You can write your rule implementation in any language, but the easiest approach will probably be to do it as a shell script.
For example, a simplistic version of the rule to compile a C++ source file might look like:
#! /bin/sh set -e if $# == 0; then # Ekam is querying the script. # Tell it that we like .cpp files. echo triggerOnFilePattern '*.cpp' exit 0 fi INPUT=$1 BASENAME=`basename $INPUT .cpp` # Ask Ekam where to put the output file. echo newOutput ${BASENAME}.o read OUTPUT # Compile, making sure all logs go to stderr. c++ $CXXFLAGS -c $INPUT -o $OUTPUT >&2 # Tell Ekam about the symbols provided by the output file. nm $OUTPUT | grep '[^ ]* *[ABCDGRSTV] ' | sed -e 's/^[^ ]* *. \(.*\)$/provide c++symbol:\1/g' # Tell Ekam we succeeded. echo success You would then give this script a name like c++compile.ekamrule. When Ekam sees .ekamrule files during its normal exploration of the source tree, it would automatically query them and then start using them.
Of course, shell scripts are not the most efficient beasts. You might later decide that this script really needs to be replaced by something written in a lower-level language. Of course, Ekam doesn't care what language the program is written in -- you could easily use Python instead, or even C++. (Of course, to write the rule for compiling C++ in C++ would necessitate some bootstrapping.)
Resolving conflicts
Several people have asked what happens in cases where, say, two different libraries define the same symbol (e.g. various malloc() implementations). I've been thinking about this, and I think I'm settling on a solution involving preferences. Essentially, somewhere you would declare "This package prefers tcmalloc over libc.". The declaration would probably go in a file called ekamhints and would apply to the directory in which in resides and all its subdirectories. With this hint in place, if tcmalloc is available (either installed, or encountered in the source tree), Ekam will notice that both it and libc provide the symbol "malloc" which, of course, lots of other things depend on. It will then consult the preference declaration, see that tcmalloc is preferred, and use that.
When no preferences are declared, Ekam could infer preferences based on the distance between the dependency and the dependent. For example, a symbol declared in the same package is likely to be preferred over one declared elsewhere, and Ekam can use that preference automatically. Also, symbols defined in the source code tree are likely preferred over those defined in installed libraries. Additionally, preferences could be configured by the user, e.g. to force code to use tcmalloc even if the developer provided no hint to do so.
Note that this preferences system allows for an interesting alternative to the feature tests traditionally done by configure scripts: Write multiple implementations of your functionality using different features, placing each in a different file. Declare preferences stating which implementation to prefer. Then, let Ekam try to build them all. The ones that fail to compile will be discarded, and the most-prefered implementation from those remaining will be used. Obviously, this approach won't work everywhere, but it does cover a fairly wide variety of use cases.
Build ordering
There is still a tricky issue here, though: Ekam doesn't actually know what code will provide what symbols until it compiles said code. So, for example, say that you plop tcmalloc into your code tree in the hopes that Ekam will automagically link it in to your code. You run Ekam, and it happens to compile your code first, before ever looking into the tcmalloc directory. When it links your binaries, it doesn't know about tcmalloc's "malloc" implementation, so it just uses libc's. Only later on does it discover tcmalloc.
This is a hard problem. The easy solution would be to provide a way to tell Ekam "Please compile the tcmalloc package first." or "The symbol 'malloc' will be provided by the tcmalloc directory; do not link any binaries depending on it until that directory is ready.". But, these feel too much like writing an old-fashion build file to me. I'd like things to be more automatic.
Another option, then, is to simply let Ekam do the wrong thing initially -- let it link those binaries without tcmalloc -- and then have it re-do those steps later when it realizes it has better options. This may sound like a lot of redundant work, but is it? It's only the link steps that would have to be repeated, and only the ones which happened to occur before tcmalloc became available. But perhaps one of the binaries is a code generator: will we have to regenerate and re-compile all of its output? Regenerate, yes, but not recompile -- assuming the output is identical to before, Ekam can figure out not to repeat any actions that depend on it. Finally, and most importantly, note that Ekam can remember what happened the last time it built the code. Once it has seen tcmalloc once, it can remember that in the future it should avoid linking anything that uses malloc until tcmalloc has been built.
Given these heuristics, I think this approach could work out quite nicely, and requires minimal user intervention.
Wednesday, March 27, 2019
Explore Simple Game Algorithms With Color Walk: Part 10
Dijkstra and an Assist
We saw in the last post that we couldn't use Dijkstra's algorithm in its purest form because that would still require searching the entire move graph to find the true shortest path from the source vertex (the start-of-game) to the sink vertex (the end-of-game). In fact, Dijkstra's algorithm, when run to completion, will find the shortest path from the source vertex to every other vertex in the graph. Since the move graph is actually a tree, we don't care what the shortest path is to most of the vertices, save one, the end-of-game vertex. Because of that restriction, we restricted the algorithm to only search until the end-of-game vertex was found, and then try to balance the search heuristic so that we reached that vertex on as short of a path as possible.
This tactic of using a heuristic search and stopping once a goal is reached is actually a variant of Dijkstra's algorithm by another name, called A* search. This algorithm is a popular way to do path finding in games where computer-controlled characters are moving around in a 2D or 3D space. The natural heuristic in that application is the straight-line distance from the current position of the character to the target position, and A* search is pretty effective at this task.
In using a heuristic for the Color Walk move graph search, we have given up the guarantee of finding the true shortest path because the heuristic is not perfect, but we gain a huge benefit in efficiency and tractability. Without the heuristic, the search would go on forever (or at least until it ran out of memory) in such a large graph. Even with the current performance of the algorithm, we want to try to tighten up the heuristic to find a shorter path, but to do that, we want to do something to shrink the size of the graph that it needs to search. To do that, we can add in our old friend GLA to make fast headway into the move graph before switching to Dijkstra's algorithm.
Adding this hybrid GLA-Dijkstra's algorithm is straightforward. We start with the normal task of adding the algorithm to the list of choices in the algorithm pull-down list and to the switch statement that lives behind the list:
function Solver() {
// ...
this.init = function() {
// ...
$('#solver_type').change(function () {
switch (this.value) {
// ...
case 'greedy-dijkstra':
that.solverType = that.dijkstraWithGla;
that.metric = areaCount;
break;
default:
that.solverType = that.roundRobin;
break;
}
// ...
});
// ...
};
}The implementation of the hybrid algorithm is about as simple as the other hybrid algorithms: this.dijkstraWithGla = function() {
if (moves < 15) this.greedyLookAhead();
else this.dijkstra();
}It seemed like running GLA for 15 moves was reasonable, considering most boards are not solved in less than 30 moves, and then Dijkstra's algorithm is run to the end-of-game condition. Now we have a problem, though. We have two knobs to turn—one for the maximum number of moves to look ahead in GLA and one for the scale factor used in Dijkstra's algorithm, but only one text box in the UI. (Another knob would be the number of moves to run GLA for, but we'll just keep that at 15 to reduce the number of combinations to look at.) We'll want to separate those two knobs out by adding another text box for the scale factor to the UI. Let's call it solver_scale_factor and add it as another parameter in the code: function Solver() {
var that = this;
var iterations = 0;
var max_moves = 2;
var scale_factor = 25;
var time = 0;
var start_time = 0;
this.index = 0;
this.metric = nullMetric;
this.init = function() {
this.solver = $('<div>', {
id: 'solver',
class: 'control btn',
style: 'background-color:' + colors[this.index]
}).on('click', function (e) {
max_moves = $('#solver_max_moves').val();
scale_factor = $('#solver_scale_factor').val();
that.runAlgorithm();
}).appendTo('#solver_container');
// ...
$('#solver_play').on('click', function (e) {
_block_inspect_counter = 0;
_block_filter_counter = 0;
iterations = $('#solver_iterations').val();
max_moves = $('#solver_max_moves').val();
scale_factor = $('#solver_scale_factor').val();
start_time = performance.now();
time = start_time;
that.run();
});
};
// ...
function addVertices(vertices, depth, prev_control, prev_cleared) {
var stop = false;
_.each(controls, function (control) {
if (control !== prev_control && !stop) {
var removed_blocks = control.checkGameBoard(depth, markedBlockCount);
if (endOfGame()) {
doMarkedMoves();
vertices.clear();
stop = true;
} else if (removed_blocks - prev_cleared > 0) {
var markers_dup = markers.slice();
var cost = scale_factor*depth - removed_blocks;
if (removed_blocks > 590 ||
removed_blocks > 560 && vertices.length > 200000) {
cost -= (scale_factor - 5)*depth;
}
vertices.queue({markers: markers_dup,
depth: depth,
control: control,
cost: cost,
cleared: removed_blocks});
}
}
});
return vertices;
}Inside addVertices() we simply replace max_moves with the new parameter scale_factor. Now we can independently control both parameters and more easily explore variations on this hybrid algorithm. After much experimentation with the max moves in the range of 4-7 and the scale factor in the range of 25-30 using ten iterations, I found that a max moves of 7 and a scale factor of 28 performed well. Then, running for 100 iterations produced the following results.This is quite good performance, meeting or exceeding the best algorithms in every metric except for the standard deviation as compared to Dijkstra's algorithm alone. But Dijkstra's algorithm didn't do as well on the min, mean, or max statistics, so in absolute terms the hybrid algorithm found better move sequences for nearly every board.
Before looking at the table of algorithm performance, let's add in another quick algorithm by reversing GLA and Dijkstra's algorithm to create the Dijkstra-GLA hybrid algorithm. We can add it to the algorithm list:
function Solver() {
// ...
this.init = function() {
// ...
$('#solver_type').change(function () {
switch (this.value) {
// ...
case 'dijkstra-greedy':
that.solverType = that.glaWithDijkstra;
that.metric = areaCount;
break;
default:
that.solverType = that.roundRobin;
break;
}
// ...
});
// ...
};
}And add another simple algorithm function that calls both of the base algorithms in the hybrid algorithm: this.glaWithDijkstra = function() {
if (moves < 5) this.dijkstra(300);
else this.greedyLookAhead();
}Notice that the call to Dijkstra's algorithm now includes an argument of 300. This argument is the number of blocks that should be cleared before Dijkstra's algorithm stops. It's pretty easy to limit the algorithm by adding a condition to the if statement where the algorithm is stopped before it runs out of memory: this.dijkstra = function(blocks_to_clear = 600) {
var vertices = new PriorityQueue({ comparator: function(a, b) { return a.cost - b.cost } });
vertices = addVertices(vertices, 1, null, blocks[0].cluster.blocks.length);
this.max_depth = 0;
while (vertices.length > 0) {
var vertex = vertices.dequeue();
markers = null;
markers = vertex.markers;
if (vertices.length > 250000 ||
vertex.cleared >= blocks_to_clear) {
doMarkedMoves();
vertices.clear();
} else {
vertices = addVertices(vertices, vertex.depth + 1, vertex.control, vertex.cleared);
}
vertex.markers = null;
}
this.index = null;
}By the default parameter, all blocks are cleared when the algorithm is run so the other two calls to dijkstra() still work like they did before. For this run the max moves was still set at 7, but the scale factor had to be rolled back to 25, like it was for Dijkstra's algorithm alone because otherwise it would stall on some boards. The performance of this hybrid algorithm comes out surprisingly worse:I didn't expect that just swapping the order of the two algorithms would have such a marked difference in performance. The slightly smaller scale factor doesn't account for the difference, either, because if it's set to 28, as it was in the GLA-Dijkstra algorithm, the performance is even worse. Let's look at how these two hybrid algorithms stack up to the rest of the algorithms we've looked at so far:
| Algorithm | Min | Mean | Max | Stdev |
|---|---|---|---|---|
| RR with Skipping | 37 | 46.9 | 59 | 4.1 |
| Random with Skipping | 43 | 53.1 | 64 | 4.5 |
| Greedy | 31 | 39.8 | 48 | 3.5 |
| Greedy Look-Ahead-2 | 28 | 37.0 | 45 | 3.1 |
| Greedy Look-Ahead-5 | 25 | 33.1 | 41 | 2.8 |
| Max Perimeter | 29 | 37.4 | 44 | 3.2 |
| Max Perimeter Look-Ahead-2 | 27 | 35.0 | 44 | 2.8 |
| Perimeter-Area Hybrid | 31 | 39.0 | 49 | 3.8 |
| Deep-Path | 51 | 74.8 | 104 | 9.4 |
| Path-Area Hybrid | 35 | 44.2 | 54 | 3.5 |
| Path-Area Hybrid Look-Ahead-4 | 32 | 38.7 | 45 | 2.7 |
| BFS with Greedy Look-Ahead-5 | 26 | 32.7 | 40 | 2.8 |
| DFS with Greedy Look-Ahead-5 | 25 | 34.8 | 43 | 3.9 |
| Dijkstra's Algorithm | 29 | 33.1 | 40 | 1.9 |
| GLA-Dijkstra Hybrid | 25 | 31.8 | 37 | 2.2 |
| Dijkstra-GLA Hybrid | 28 | 36.3 | 44 | 3.1 |
While the GLA-Dijkstra hybrid performs better than any other algorithm we've seen so far, and seems to combine all of the best characteristics of its constituent algorithms, Dijkstra-GLA doesn't even perform as well as Dijkstra's algorithm alone. It's more on the level of the max perimeter heuristic, which is decidedly middle-of-the-road as far as these algorithms go. Looking at the boards from a high level, this disparity makes some sense. It looks like at the beginning of a game it's more important to figure out how to remove as many blocks as possible on each move. As the game progresses and gets closer to the end, where the graph search algorithms can "see" more easily to the end of the game, their ability to find the shortest path becomes more effective, and that benefit is especially true for Dijkstra's algorithm because it's more efficient than the other graph search algorithms. Swapping Dijkstra's algorithm and GLA ends up crippling both of them.
Self-Assist
A curious idea comes out of these hybrid algorithms by thinking about the difference between Dijkstra's algorithm and GLA. GLA operates on a per move basis, meaning for each move under consideration, the algorithm looks some number of moves ahead and then commits to a move before going on to consider the next move. If we string one GLA algorithm together with another GLA, it wouldn't look any different than running GLA all the way through in one pass.
In contrast, Dijkstra's algorithm looks as far forward as it's allowed to try to find the shortest path to the end-of-game condition, and once a path is found, it does all of the moves in that path at once. If we string Dijkstra's algorithm together with another Dijkstra's algorithm, running the first one to the halfway point, it looks different than running Dijkstra's algorithm once for the entire board. The combination of the first run to the halfway point and the second run to the end may find quite a different path than a single run does. It should also run faster because the paths it needs to search are shorter by half. Let's give this idea a try by running Dijkstra's algorithm with itself. First, we add the new hybrid algorithm to the list of choices again:
function Solver() {
// ...
this.init = function() {
// ...
$('#solver_type').change(function () {
switch (this.value) {
// ...
case 'dijkstra-dijkstra':
that.solverType = that.dijkstraDijkstra;
that.metric = areaCount;
break;
default:
that.solverType = that.roundRobin;
break;
}
// ...
});
// ...
};
}And then we can simply call Dijkstra's algorithm twice for the implementation of dijkstraDijkstra() (it's so fun to say, isn't it?): this.dijkstraDijkstra = function() {
if (moves < 5) this.dijkstra(300);
else {
scale_factor = 28;
this.dijkstra();
}
}The first call to dijkstra() specifies the number of blocks to remove to get to the halfway point. The second call changes the scale_factor to the optimal value for when Dijkstra's algorithm is run for the later moves, as we found in the GLA-Dijkstra algorithm. The scale_factor for the first run can be set through the UI, so we can experiment a little. We could add another UI element so that two scale factors could be specified, but this should demonstrate the idea without adding that complication. With this simple addition to the algorithms, we can see how it performs:This version of the hybrid Dijkstra's algorithm performs better than Dijkstra-GLA, but worse than GLA-Dijkstra, adding more evidence to the idea that Dijkstra's algorithm does better in the second half of the game than the first half. The first run of Dijkstra's algorithm to remove 300 blocks probably does not do as well as GLA, but the second run does do better than GLA, giving this hybrid a performance result that lands it squarely in between the other two hybrid approaches.
An Assist from the Perimeter
One more option to explore for amping up Dijkstra's algorithm is using other heuristics with the GLA part of the hybrid algorithm. We've continued to use the heuristic of maximizing blocks removed with areaCount(), but we did look at a number of other options for heuristics. Even though they didn't improve over the super-strong area-maximizing heuristic, the other heuristics are potentially interesting for use in paring down the move graph before running Dijkstra's algorithm. They're quite easy to add to our list of algorithms, so let's look at one of them, the perimeterCount() heuristic for maximizing the cleared perimeter:
function Solver() {
// ...
this.init = function() {
// ...
$('#solver_type').change(function () {
switch (this.value) {
// ...
case 'max-perimeter-dijkstra':
that.solverType = that.dijkstraWithGla;
that.metric = perimeterCount;
break;
default:
that.solverType = that.roundRobin;
break;
}
// ...
});
// ...
};
}It's so simple that all we had to do was add another choice to the algorithm list and add another case to the switch statement that uses the dijkstraWithGla() algorithm and the perimeterCount() heuristic. Everything else is already available and ready to go. So how does it perform?It looks like another decent algorithm—slightly better than Dijkstra's algorithm alone, but not quite as good as GLA-Dijkstra. Here's the updated table of all the algorithms tried so far:
| Algorithm | Min | Mean | Max | Stdev |
|---|---|---|---|---|
| RR with Skipping | 37 | 46.9 | 59 | 4.1 |
| Random with Skipping | 43 | 53.1 | 64 | 4.5 |
| Greedy | 31 | 39.8 | 48 | 3.5 |
| Greedy Look-Ahead-2 | 28 | 37.0 | 45 | 3.1 |
| Greedy Look-Ahead-5 | 25 | 33.1 | 41 | 2.8 |
| Max Perimeter | 29 | 37.4 | 44 | 3.2 |
| Max Perimeter Look-Ahead-2 | 27 | 35.0 | 44 | 2.8 |
| Perimeter-Area Hybrid | 31 | 39.0 | 49 | 3.8 |
| Deep-Path | 51 | 74.8 | 104 | 9.4 |
| Path-Area Hybrid | 35 | 44.2 | 54 | 3.5 |
| Path-Area Hybrid Look-Ahead-4 | 32 | 38.7 | 45 | 2.7 |
| BFS with Greedy Look-Ahead-5 | 26 | 32.7 | 40 | 2.8 |
| DFS with Greedy Look-Ahead-5 | 25 | 34.8 | 43 | 3.9 |
| Dijkstra's Algorithm | 29 | 33.1 | 40 | 1.9 |
| GLA-Dijkstra Hybrid | 25 | 31.8 | 37 | 2.2 |
| Dijkstra-GLA Hybrid | 28 | 36.3 | 44 | 3.1 |
| Max-Perimeter-Dijkstra Hybrid | 27 | 32.8 | 38 | 2.3 |
We have built up quite a list of algorithms, with some of the best performing ones at the very end finally overcoming the surprisingly solid performance of one of the earlier algorithms, GLA-5. If we're looking only at average performance, the GLA-Dijkstra hybrid is the clear winner, with BFS+GLA-5 and Max-Perimeter-Dijkstra hybrid coming in second and third with an average of one extra move per game. However, that higher performance in number of moves comes at a cost. Those algorithms take significantly longer to search for their results than GLA-5 does. If we ordered these top four algorithms based on search speed, the order would be reversed to GLA-5, Max-Perimeter-Dijkstra hybrid, BFS+GLA-5, and GLA-Dijkstra hybrid. At the top of the leaderboard there is a clear trade-off between average performance and search time.
While we've looked at graph algorithms in general and Dijkstra's algorithm in particular fairly extensively now, one thing that was somewhat glossed over was the workings of the priority queue that is the key to making Dijkstra's algorithm work so well. Next time we'll take a closer look at this essential data structure and see how it enables Dijkstra's algorithm to quickly choose each vertex to look at next.
Article Index
Part 1: Introduction & Setup
Part 2: Tooling & Round-Robin
Part 3: Random & Skipping
Part 4: The Greedy Algorithm
Part 5: Greedy Look Ahead
Part 6: Heuristics & Hybrids
Part 7: Breadth-First Search
Part 8: Depth-First Search
Part 9: Dijkstra's Algorithm
Part 10: Dijkstra's Hybrids
Part 11: Priority Queues
Part 12: Summary
Tuesday, March 26, 2019
Boktai Review: Fools And Stupids See The Light
Since last November when I started the Critical-Gaming blog, I've critiqued other reviews, developed a body of language to communicate the intricate inter workings video games, and written a few reviews to demonstrate.
Now that the foundation has been set, I can exercise a bit more creative writing liberty. After all, creative writing is my specialty. Using this new style, each review will be focused in a way that communicates the various elements of design along with my personal experience/thoughts of the game. Here's the catch. The style and themes that I choose to structure the review will also reflect the mechanics, functions, ideas, and/or themes of the game in some way. Sound intense? Don't worry. Just sit back and read carefully and lightly. If you're lost, by the end I'm sure you'll come out of the darkness.

STORY
It wasn't until about the end of the game when I realized what was going on. Boktai is a game that's shrouded in twisted mystery. I remember beginning my adventure on Earth, yet for the past few hours, I've been in running around aboard a mauve space station silently orbiting my home. I recalled how quickly and unknowingly I made the jump from my simple, home grown, earthly ambitions to lifelessly floating out in space just going through the motions fighting any manner of man, beast, or undead that I can shove into a coffin, pile up, and drive to victory. The funny part of it all isn't how my evil twin brother who descends from a source that's not exactly my mother has been stringing me along "using" me to defeat his enemies so he can free him self from the Moon Queen's control only to later join my side in defeating her. The funny part is, I saw it all coming.

Kojima isn't much of a story teller. By ignoring one of the most effective tenets of written story telling "show don't tell" and relying on unnatural dialog to communicate the overly complex, muddled mush of a story line to the player, Kojima has casted yet another opportunity for a true spark of ingenuity into the forever depths of obscurity and the forgotten.
PUZZLES
In the grand scheme of Boktai puzzles, there are only a handful that cleverly utilize the manipulation of light and shade as the pivotal element. There may be even less that use the real time clock creatively. When playing such puzzles, I held a glimmer of hope for the rest of the game. If half the puzzles in Boktai used light and time instead of just the few, I would have more glowing remarks to give. Unfortunately, most of the puzzles are rustic push block/switch puzzles. As annoying as these puzzles are, there are a few that have nothing to do with the world of Boktai at all.
Like a nightmare, imagine stepping into a room only to have the door slam shut behind you. Though not a word is uttered, you can't help but think that you're in a "trap." In front of you is a math problem the likes of which you haven't seen in many years. Numbers, different operators, and equal signs are strewn about set up in such a way that beckons your assistance. All of a sudden, you're in school again trying to finishing a math test. Your heart sinks. You were just enjoying recess and now you're stuck with a math problem you can't solve. When you go up to the teacher for assistnace she subtly hints that you're looking at the problem wrong. And after a few more tries fiddling with it, you ask again. This time, you're told you're "stupid." This is what some of the puzzles in Boktai are like right down to being called stupid.
Perhaps what's worse of all about the puzzle design is, unlike Zelda/Mario/Metroid/Pokemon and just about any game that takes its design seriously, you can easily trap yourself trying to solve a puzzle in Boktai. Not to worry. Since the beginning of the game, players are supplied with a "Fool's card" that resets any room that a player may be stuck in. This deconstructive little card not only breaks the organic flow of the game, but the function of the card doubles as a "get out of jail (danger) free card." Instead of designing a tighter game, Konami took the easy way out.
THE MENU
It wouldn't be a Kojima game if there wasn't a heavy use of the game menu that borders on abuse. The menu in Boktai is used to customize the solar gun, examine the map, or use an item. With every use of the menu, the game is paused putting abrupt breaks in the flow of the gameplay. If you're about to die, just hit pause and gobble down as much life/solar energy restoring fruit as you want. With so many healing items and such an effective healing method, the gameplay can easily deconstruct into repeated reckless attacks and menu based healing. Such a strategy is functionally analogous to the attack-attack-heal strategy in many RPGs. Needless to say, by attack-attack-healing, the gameplay doesn't become more engaging. In fact, the menu system in Boktai is reductive and seeks to deconstruct the core design. The silver lining with all of this menu abuse is it's all optional.ACTION COMBAT
MOVE. SHOOT. FLATTEN. TAP. Boktai contains all the mechanics of an stealth/shooting game. Fortunately, it does a few things correctly. Not being able to move and shoot focuses the action so that it can exist in a smaller space, which is ideal for the GBA screen size. Also, players can only fire in 8 directions, which requires more careful aim when hitting far away targets. The long range shots are the least effective at killing while the close range spread deals the most damage. Having to move in close to enemies to effectively kill them in a shooting game increases the tension of combat. When all of these design elements come together, the combat reminded me of fighting in a top down Zelda game like A Link to the Past.

Botkai was hatched from Kojima's mind and brought to life under his heated gaze. In true Metal Gear fashion, players don't have to kill any of the enemies. From the game's outset, I was cautioned against "unnecessary killing." By TAPing to creating distractions, FLATTENing to silence my footsteps and to squeeze around enemies, and by SHOOTing my foes in the back I had all the abilities I needed to stun and stealth my way through the game without taking a life. The problem is, this isn't Metal Gear, and I'm not pitted against other humans. I'm fighting the undead, which puts the whole "killing" concept in a dimly lit gray area. It also doesn't help that most of the enemies in the game are "immortals" that regenerate after being "killed."
I realized at some point, that stealthing around isn't engaging enough to hold my attention for the duration of the game. When trying to play "Kojima's way," I have to do a lot of searching the area using the LOOK mechanic, a lot of waiting for enemies to turn their backs, a lot of wall TAPing to create distractions, and a lot of avoiding engagement. Doing this opens of the game to redundancy and static space. It would be different using such stealth tactics was the best way avoid taking damage, to conserve solar energy, or even to access special areas. But, the way Boktai is designed, conserving recourses isn't vital because there's no problem a few items can't fix, and there are no areas that require stealth to access. In the end, using stealth is simply the slow way to play Boktai.
LEVEL DESIGN
The overworld in Boktai must be some kind of joke or failed attempt at a Zelda like overworld. Not only is there nothing to do of consequence on the overworld except walk in an almost straight line to the next dungeon or mini dungeon, but the different areas are abruptly patched together like a quilt instead of organically blending form one to another. One moment, I'm standing in a graveyard. The next step, I'm in a forest.
What's worse is the whole game is designed as if it has been cut out of a mold using a large isometric chisel. Though the blocky look and feel works for some of the buildings, the style all becomes stale in how it limits how the player's possible paths through the level and how forced and inorganic it feels. Without strong organic themes and ideas to govern the construction of each level, every room feels artificial and disconnected from each other. Even in the fire dungeon where the player manipulates switches to raise and lower the magma level much in the same way link does in the various Zelda water temples/dungeons, it is not apparent how the magma changes with each adjustment. Instead of trying thinking about each room as a part of a whole, I stuck to a simple strategy. Just keep going forward and don't get distracted. The game is linear even when it doesn't look like it.
There is only one aspect of Boktai's level design that is worthy of accolades: The folded and refolded level design. In each of the game's main dungeons, players delve deeper into each location overcoming obstacles, enemies, and traps to reach the boss. Players then Battle the boss (the crease). While dragging the boss inside his/her coffin back through the level, the player is mindful of the factors: the coffin randomly shaking itself free from your grip, slower character movement, the ability to use the coffin as a weight for switches, and how enemies will notice the coffin and help it escape. Once players take the coffin back to the beginning of the level another battle with the boss takes place in a special ritual. The sequence up to this point completes the folded design.
As an interesting addition, if during the course of the ritual the boss breaks free and escapes, it'll make its way back through the dungeon forcing players to scramble back through the level to recapture it and continue the process. This feature creates the possible refolds.
Over all, the folded design in Boktai is very unique and well executed. There are just a few things that I did not like about it. Unfortunately, as the coffins inch their way to freedom, once they slip through a door way, their position becomes difficult to track. Even if you pursue a runaway coffin right as it moves through a door, on the other side, the coffin is no where to be found. In fact, the coffin somehow manages to move through several rooms in the blink of an eye. It's too bad that the game couldn't design this feature more organically using the game's established rules and mechanics.
ENEMY DESIGN
The enemies in Boktai are creative each filling a specific and unique design space. Crows fly around and swoop in to pester the player. Spiders bunch up, spin sticky web traps, and spit. Gouls patrol around and launch attacks on the player. Golems are powerful stone creatures that roll after the player at high speeds. And the list goes on. What I found to be the most interesting part of the enemy design in Boktai, is the interplay that exists between the player and the enemies. By manipulating the environment, the player can turn enemy attacks against themselves. The fast rolling Golem in pursuit of the player will smash and kill any Goul in its path. The Kraken can be tricked into using its tentacle to snatched up another enemy instead. Mummies, when set on fire, can set other mummies on fire as they run around frantically. It's this kind of attention to detail that I feel is too obscure in Kojima's other games, but perfectly tuned in Boktai.THE GIMMICK
So what is this game? From the look of things, Boktai is a game with a poor, convoluted story, lack luster puzzles, and undynamic mechanics with a level design that is composed of parts that are either hit or miss. If this accurately described the game I would have put it away long ago never to have finished. Fortunately, the best part of Boktai, the part the goes beyond the folded level design and the Classically correct enemy design, is the game's primary function: the sun that is in my hand.
I saved the best for last because it's important to understand how much influence a unique and well integrated primary mechanic is to a game as a whole. If you don't know already, Boktai is a GBA game that has a solar sensor built into the cartridge. Artificial light won't do the trick. In order to get the full Boktai experience, sunlight is required.
Because Boktai is a GBA game, the entire gaming experience is automatically portable. Play it inside, outside, and everywhere in between. Do whatever it takes so that the sun can power up the game. To use the sunlight players have to adjust the angle of the handheld so that the suns light hits the sensor directly. When battling the forces of darkness every photon of light counts. In my experience with the game, because I frequently moved from location to location, manipulating the angle of my DS to catch the sunlight turned my handheld into a 3D gaming controller that respond to real world conditions in 3D space. Using the handheld in this way is something that I've seen in few places.
To power the Gun De Sol, the main defensive and offesive weapon, players can absorb the light of day. Though the game provides many ways to obtain this solar energy in the absense of real sunlight, this section is focused on how the primary mechanic USE SUNLIGHT is used throughout the game. When the player is in an outdoor environement in the game world, the game world transmits the sunlight hitting the sensor so players are free to absorb and use the light infinitly. As we all know, vampires and the undead detest sunlgiht. So in Boktai, all of the bosses and enemies dwell in buildings or areas where the sunlight is blocked. Players must charge their solar batteries outside of these locations and conserse it once inside.Depending on whether sunlight is shining on the solar sensor, invisible paths become visible, light shines through windows, solar winds increase, and specific areas will be illuminated. The environmental conditions also change depending on the time of day according to the game's internal clock. At sun down when real sunlight isn't available, hidden crystal like "solar bamboo shoots" twinkle in the moon light.
Even this core sunlight driven mechanic isn't without balance. To appreciate light, one must experience darkness or, in this case, shade. Playing out in the sunlight for too long will cause the Gun De Sol to begin to overheat. To remedy the situation, players must find some shade to play in. If the gun fully overheats, it won't be availablefor use until the next sun rise (also according to the internal clock). This feature tops the dynamic decay system of Boktai's solar gameplay.
In the outdoor environments in the game world, players are free to use their solar energy and refill their supplies infinitely as long as they're playing in sunlight. Generally, to progress through the game players must encounter the undead enemies in covered/indoor areas. Once out of the sunlight in the game world, players must conserve their energy as every shot drains their supply. This completes the first organic cycle between sunlight, the environment, and ammunition. And the player moves through different game environments, the solar ammo will decay with use and be refilled according to the location.
Regardless of what's happening in the game world, if the game is exposed to the sun for too long the gun will overheat. This decay cycle is partially independent of the first cycle. And when the sun sets in real life, both decay cycles are replaced with another organic decay cycle that resets with the dawn of the next day. In the end, no matter how you play Boktai, you're always a part of some kind of organic decay cycle that revolves around the sun. This means even when you're not playing you're still playing in a way.
Several reviewers criticized Boktai's dependence on real sunlight despite all the solar energy alternatives provided in the game. Complacent in how they play videogames, such reviewers thought it was inappropriate that they couldn't play Boktai any way they wanted and at any time. This is precisely why I enjoyed Boktai as much as I did. From gradually losing daylight and offensive power, to coordinating my attacks with cloud cover, to rainy day steak outs, I had to seize the day whenever I got the chance. Similar to how WiiFit raises awareness of one's physical body, playing Boktai made me more aware of the day and sunlight. In the age we live in, artificial light is everywhere. Having to work around less predictable and convenient light source made me tune into nature or at least it reminded me of how dependant and powerless life is without the sun.
And on top of all this, playing in real sunlight or in the shade is an organic way for players to control their own difficulty. During the day, I could harness the limitless power of the sun. By nightfall I had a choice to make. I could either turn the game off and wait until tomorrow to play, or I could tough it out with an ever draining supply of energy in my battery reserves.
CONCLUSION
If you don't fully embrace the light, then there's no point in playing Boktai. It's all about the solar sensor. When nearly every other element of the game is average or below average, the interaction with the sun highlights the game's more positive design elements well. Though the majority of the game leaves much to be desired, at least the sun is there with you the whole way. It's too bad some reviewers couldn't see the truth. It's also too bad that Konami didn't either. All the items, most of the puzzles, many of the dungeons, and most of the story could be completely thrown away to leave a purer, better designed product. It's a little pretentious of the developers to call me "stupid" for not wanting to solve yet another one of their dull push block puzzles, or calling me a "fool" for trapping myself inside of one of their poorly designed puzzles. If only Kojima knew what potential he had in his hands, he might have made a cleaner game.

In the end, all I wanted to do was hold the "sun in my hand," and I got a chance to with this extremely unique game. It's too bad I had to wade through some redundant mediocrity to get there. At least thinking back on the whole experience, my memories are bright.













