Use your powerful army to conquer the world in Land Grabbers, a fun Strategy game set in the Middle Ages! In a time of castles, knights, and crusades, you are a brilliant military leader who has decided to take on the world! Take your army to the woods, the desert, and even a snowy winter wonderland in this challenging Strategy game!
LandGrabbers
Use your powerful army to conquer the world in Land Grabbers, a fun Strategy game set in the Middle Ages! In a time of castles, knights, and crusades, you are a brilliant military leader who has decided to take on the world! Take your army to the woods, the desert, and even a snowy winter wonderland in this challenging Strategy game!
Shecantbeserious steps in it, jumps up and down
"Today [May 19th, 2011], The Department of Health and Human Services (HHS) issued a final regulation to ensure that large health insurance premium increases will be thoroughly reviewed... In 2011, this will mean rate increases of 10-percent or more must be reviewed by state or federal officials."
A few months ago, Mike averred that this would, in fact, be good news:
"HHS has once again underestimated the intelligence of the American public ... The increase to premiums year over year, and over many years, tracks exactly with the increase in the cost of medical benefits paid."
That is, he offers proof of our oft-repeated claim that the increasing cost of health care drives the increasing cost of health insurance.
I think he's right, but I think there's another point here that's gone unremarked. Some of us are old enough to remember the early 70's, when gasoline became subject to price controls. The result was, at first, longer lines at the pump, and eventually rationing (ie you could fill up only every other day). Health insurance companies can't ration health care, of course, but they certainly can ration health insurance. I've already noticed a significant tightening in underwriting, and much higher than "normal" rate increases (particularly in small group).
To illustrate this point, imagine that Washington imposes strict new safety and efficiency requirements on automobile manufacturers, and then limits how much they can charge for new cars. Does this make any sense?
But that's exactly what's happening with health insurance: new mandated benefits, and a cap on how much more insurers can charge for providing them.
There are two points to be made here. First, as regards McCarran-Ferguson, why aren't state DOI's asserting their jurisdiction over rate increases? Why have they ceded that function to HHS and the minions of Secretary Shecantbeserious?
Second, it's apparently not just legacy media types who don't "get" simple, basic economic principles. The one in operation here is supply and demand: when you add "freebies" to insurance policies (routine exams, mammograms and colonoscopies, to name a few), people will go get them. Problem is, there are only so many providers, which means that there will be waiting lines and higher costs.
Of course, Ms Shecantbeserious (as well as Barry, Harry and Nancy) would probably view those as features, not bugs.
Is It Working Yet?
The folks at Consumer Reports fielded this question and fumbled miserably.
Rather than actually reporting, they took the short route and repeated political rhetoric and theories from the talking heads in the lame stream media.
CR cited these as reasons for hope and change in health insurance pricing.
Unchecked increases in premiums, record insurance company profits, price transparency through imposed medical loss ratio's.
Horse feathers!
Profits Are Good, Not Bad
Insurers are raising premiums on an as needed basis in order to remain profitable. Profit margins on health insurance average about 4% on gross premiums. That means that every $100 in premiums paid yields about $4 in profit. If carriers had no profit there would not be a noticeable drop in premiums.
Looked at another way, if carriers are not profitable they may lack the ability to pay claims which would be much more disastrous than making a nominal profit.
Medical Loss Ratio's Are Meaningless
The mandated medical loss ratio is a mixed bag. While some carriers may have had more margin than others on certain lines, the only thing that really mattered in a competitive market is how does their premium rates compare with others offering a similar plan?
As someone who has worked in the health insurance industry for over 35 years I can tell you consumers are not stupid. They automatically gravitate toward the plan that appears to offer the best value. They could care less about loss ratio's, profit margins or CEO pay. As long as they get a "good deal" the rest is superfluous.
Rate Hikes Are Necessary
All this talk about price transparency is mostly political grandstanding and saber rattling. If the carrier is experiencing a loss, or anticipates a loss on a line of business they must either raise rates to a sustainable level or withdraw from the market. Blue Shield of California has already announced their intention to pull out of the under age 65 major medical market. This decision comes on the heels of other small carriers who have likewise folded and stopped writing new business.
Over-regulation and micro-managing for the sake of winning votes means the consumer loses. When carriers stop offering product and the number of competitors in a market shrinks, prices rise and consumers lose.
Obamacrap does nothing to make health care, or health insurance more affordable in spite of what politicians and misinformed reporters may say.
Frozen Kingdom
Screenshots: #1 , #2 , #3
Dark Dimensions - City of Fog Collectors Edition
Recommended for free users: Use Jdownloader to increase download speed!
Youda Farmer 3 Seasons
Screenshots:
Recommended for free users: Use Jdownloader to increase download speed!
Mystery Trackers - Raincliff Collectors Edition
Game Size 945 MB
Screenshots: #1 , #2 , #3
Youda Farmer 3 Seasons
Face cold winters, bug ridden springs, hot summers and stormy falls!
In Youda Farmer 3: Seasons, the Bigboss is long gone and your farm is finally faring well. During a stormy winter night however, disaster strikes, reducing most of your farm to rubble. Once again you face the difficult task of rebuilding the village and your farm. Facing cold winters, bug ridden springs, hot summers and stormy falls, this new installment will put your farming skills to the test more than ever.
Dream Inn: Driftwood
Restore the Driftwood Inn! Formerly Seaside's premiere resort, this old gem has fallen into disrepair. But with the help of your boisterous inn manager, Emma Gray, and her darling cat, Pris, you can bring back the Inn’s Victorian era brilliance. Take a stroll in the garden and customize the Inn’s exterior with upgrades to create curb appeal. Explore luxurious guest suites, collect hidden items, and transform each room into a charming retreat in this fun Hidden Object game!
Tech feature: Scripting upgrade
For a couple of months now I have, on and off, worked on some basic tech aspects for the engine. Everytime I was done with one of these I thought it was among the hardest things I would do for the new engine, yet the next feature as always proved more challenging. Terrain geometry was harder to implement than sun shadows, terrain texturing harder than geometry, and so on.
Implementing the script system is no different. It is easily the hardest thing I have done so far for our new engine - HPL 3. It has had this "perfect"sort of challenge: Difficult problems to solve, much basic knowledge to wrap your head around and awfully boring and monotonous parts. I really hope this marks the end of this trend of increasing difficulty, as another proportionally large step might make my brain to melt and my fingers to crack. At least it can wait for a lil while...
Enough complaining. Now that the scripting is pretty much implemented (some engine stuff still needs to be added and some more problems remain to be solved, but it is really minor), I am extremely happy with it. I think it will help us build better games, and to finish them faster. Now let's move on to how a boring scripting system accomplishes this.
Background
Before moving on the the actual scripting I need to explain what brought on the creation of the current system. It all started with our first commercial games, The Penumbra series.
When creating the Penumbra games our tools were primitive to say the least. All maps were made in a 3D modeling program, Maya, and then exported to Collada. The game engine loaded the Collada file and built the map from it. As a 3D modeling program is meant to create 3D models, it is not really meant to make levels in. With no ways of placing entities we had to use special naming conventions to tell the game where any non-static objects in the game were located. To be able to do this properly we had to make special "instance" versions of each model meant for the game, since without this you would not be able to see how an object was placed before the game started.
Lighting was equally annoying since Maya has no support for radius on lights. This mean that you could not visually see how far a light reached, but simply entered a numerical value and hoped for the best. As this was not enough, you also needed to place portals and group meshes in order for the engine to provide occlusion culling. This could be quite tricky at times, and often you could sit a day or two simply tweaking portal setup. Added to this was also the problem that Maya often failed to show any textures, and most editing was done on grayish levels. For more info, you can just check the wiki.
The problems do not stop here though. Everytime you meant a change to the game, you had to do a complete reload. So setting up lighting in the game could be quite the effort: change light position for two seconds, load map for 2 minutes, notice it is not good, repeat. As you might figure, we got quite good at batches tasks and the phrase "it will have to do" was uttered more often than not.
For scripting it was just a grueling. Every change in the script required a full restart of the game, creating the same sort of frustration present when modeling maps. And to make scripting even more frustrating, there was no syntax checking until the entire map was loaded! This meant you could wait two minutes of loading only to find out you had forgotten a semicolon or something else trivial.
As I write this, I actually have a hard time understanding how we could have gotten anything done at all. And unsurprisingly, even though we released mod tools and documentation, not a single user map for Penumbra was ever released.
For Amnesia we knew we wanted to fix this somehow. The first step we took was to simply make our own editor where all the maps are built. Since it rendered with the same engine as the game, it made is much easier and faster to tweak entity and light placement. We instantly saw that productivity rise with this change. For scripting it was pretty much the same, but we added the extremely simple fix of compiling the script before loading the game. This removed some of the time previously spent on, in vain, looking at loading screen.
Although we had new tools all was not good. You still had to reload all level data every time you made a change to the map or script. We did not think much of this though as we were so used to doing it this way, and happy that we had all the other improvements. However, a year and a half into the development we discussed if we really needed to reload the level. I cannot recall what sparked this idea, but anyhow we figured that we did not and I added a menu with a Quick Reload button. This cached all textures, models, etc and reloaded map very quickly (usually taking but a few seconds). This increased productivity and creativity tremendously and was one of the better decisions we made during the development of Amnesia. Another sign of how much these changes improved work flow are the over a hundred of user maps created as of today.
What is so strange about the reload-feature is that is something that we could have added during the development of the first Penumbra, but for some reason we did not. It is quite frightening how often you convinces yourself that there is no better way of doing a task, and never try to improve it. We did not want to make this mistake again and started thinking of what more we could do.
Taking script to the next level
In Amnesia and Penumbra, scripting is only used to control logic flow in the levels. How enemies spawn, how puzzles work and so on. All other gameplay is hard-coded into the exe file and written in C++. Normally when I write this kind of code, rendering for instance, I can do large chunks at a time and then simply see if it works as intended. This often in small projects that are fast to reload. However, when writing gameplay and UI code this is almost never the case. Instead you constantly need to fine tune algorithms and variables until you get the expected behavior and work in large projects. Not only does this mean a level restart (with full resource reload), but the exe itself also needs to be built from code, a process that can easily take half a minute, even if the changes are minor. This means that coding gameplay can be quite a hassle at times, on par with how map building was in the Penumbra days. With the lessons learned from Amnesia fresh in mind, this felt like the obvious area of improvement.
In order to make this happen we had to move as much gameplay code as possible into the scripting. What this meant was that we needed to do some large upgrades to our current script implementations. For example, right now we only supported the most basic types (bool, int and float) together with strings in script. This already caused some issues when exposing game/engine functions and when writing scripts, for example instead having a single argument for color, you had to have four floats (one for each color and one of alpha), making code ugly and writing it more cumbersome. So just this upgrade was worth doing.
We also needed expose all engine classes, so that the script could be used pretty much as if it was normal C++ code, and achieve pretty much the same things. I was not sure exactly how much to expose but knew that the more the better.
Finally, the most important feature was to be able to reload script at any point, so it would be easy to just change a line, click a reload button and then a few seconds (or less) later see the change in-game. To get this working was the by far the most important goal with the entire upgrade. This would not be as easy as the level script was in Amnesia though, since the script system would not only take care of the code, but of part of the data as well. This meant I needed to save the state somehow, a feat I was not sure yet how to accomplish.
Implementing Classes
Before tackling the problem of script reload, I first had to make sure to add engine types to the engine. And even before doing that I needed to be sure our current scripting middleware was up to the task.
The scripting system that we were using, and have been for a long time, is a library called Angel Script. It is actually the middleware that we have used the longest, ever since end of 2004 and the Energetic project. Even though we have used it for such a long time we never really used to anywhere near its full extent and now was finally the time to make up for that. I took a day to look through the documentation and found that AngelScript could support everything that we needed, and what was even better was that it was not that difficult to add.
AngelScript is a bit different from other popular script languages (like Lua) in that it is strongly typed and very closely connected to the underlying C++ code. For one thing this makes the script quite fast (although not faster, see end of post for more info). It also meant that AngelScript could link to the classes almost directly and I only had to declare the class and link to its different parts (whatever member variables and methods that I wanted to be exposed). It also supports pointers quite easily, but makes them more secure with a script specific handle type. This requires you to keep track of some memory management for the data, but you do not need to do it, and I could very easily and quickly add support for a vast number of engine resources (textures, meshes, lights, etc).
The only thing that was a little bit trickier was supporting inheritance (when a class can build upon another class). Basically you have to redeclare methods every time you add new class that inherits from something. You also need to specify to what other classes this class can be cast to. This might sound a bit of a hassle, but the result is that you can control so the script always has a very close mapping to the code it exposes, something that I was extremely thankful for when implementing the state saving (more on that below). Also, through some use of macros, adding the implemented classes become quite easy.
Basic script layout
The next thing to figure out was the basic structure of the script code. In Penumbra and Amnesia we simply added the functions directly in a script file and then allowed that script file to represent an object. I first thought that this would be a valid design this time again, until I started thinking about how to store the data (meaning any data that should be kept between executions of the script).
In Amnesia and Penumbra the only data that is saved is simple variables like an integer for the number of times the player had stepped on button or similar. This is done through using special functions for all these variables, for example:
SetLocalVarInt("ButtonPushNum", 1);
This function saves the data to the game, and when the script is reloaded (meaning destroyed and recreated) the script can easily reference the data again by doing:
int lX = GetLocalVarInt("ButtonPushNum");
However, this time the game had to save a lot more complex data, like pointers to resources, matrices and whatnot. At first I actually considered using system with functions like this, but I figured that it would just mean a lot of extra work, and just make things more difficult. Again I thought about the lessons from Amnesia's reload feature, and thought it was worth trying to find a better solution. What I ended up doing was to force each object to be contained in class, and then let all data to be members of that class. This allowed AngelScript to make copies (needed for enemies and whatever there will be more than one instance of) and also made it was easy to keep track of the members (you simply create an object in the C++ code and can then iterate all its data).
A problem that I realized now was that I needed to have C++ functions that only worked in certain types of classes and only on data for a certain copy. For instance, an enemy class might want a function like IsInLineOfSight(...) to see if it has visual contact with something. However, there were not any functionality in AngelScript for doing this. I could give the script class a template class that forces it to implement certain functions, but I could not let the C++ code act as a base and expose specific functions from it. To solve this I had do some hacking. I ended up using global functions, and to keep track of the currently active object. (Again with macros to the rescue.) The resulting solution was not perfect though, as the global function can be used in any class and not just the one it was meant for. I am still looking into some fix for this.
Saving the state
It was now time to save the state of the script. To start this off I took the naive approach and simply saved the script data directly by copying it. This works very well for stuff like vectors, matrices, etc where it is just a matter to make a copy of the data. But it does not work that well with resources like meshes, texture or even objects like physics bodies, billboards and lights. There is way too much data in those to copy. And if I simply save the pointer I need to make sure that no data has changed when the state is loaded again, or else the saved state will not work.
At the time I was only building the system to work with a script reload only, so these issues did not pose a problem. But a major obstacle popped up when I wanted to save classes defined in scripts code. These where not possible to simply save by copying, because when you rewrite a script they can change entirely. For instance, if the class when saved consisted of two integers, and when reloaded has one string and a matrix instead the data you saved is invalid. It gets even worse if a script class has another script class as member and even more so if script classes are saved in arrays.
I figured I needed to do some kind of drastic change if this was to work. I was sketching on a few systems that could save variables in a separate structure, when it hit me. The system I was working on could not only be used to save the state, but if I implemented it correctly I could also use it for saving. For Amnesia and Penumbra I use a special serialize system that can save classes to file if initialized correctly. It is quite cumbersome, but way better than writing load / save for every single variable. However, as I was to do most gameplay code through script (the code that pretty much contain everything that needs saving), I could actually get rid of rewriting the save code for every single gameplay update. Another huge benefit of using scripting: automatic saving. This is bound to save tons of work. (It did mean a lot more work though...)
Up to that point I had looked at the scripting as separate part of in the engine. A module that all other modules could work without if removed, exactly like how most other modules work. Thinking like this had colored a lot of the design decisions I had made. Now, I instead decided that since scripting will be basically what controls the engine, I started of thinking as something that was part of all other modules. This led me to do a major rewrite of the state saving.
There is quite a lot to say about this system (and serializing in general), but I do not really have the space right now, so I will just do a quick overview. First of all, the system defines a few basic types that all other structures are built up from. These are bool, int, float, vector, matrix, color, etc and I implement very specific create/save/load methods for each of these. In AngelScript all of these are also implemented as primitives (built-in types) or data objects (which is a type where AngelScript handle all memory management). When saved the actual binary data is saved.
All other classes are implemented as references, meaning AngelScript only manages their pointers. When saving the state of these classes, each class must implement a a special method that adds all of the member variables (either basic types or other reference classes) to a list. (Basically the explicit method described here). This list is then used when transferring data to a special save buffer that contains the data of all the basic types and/or sub buffers containing data for other classes.
For certain classes, its pointer is backed up in the C++ code. So when the save data for it is loaded, the pointer to the class is first searched for and if found it is updated with the saved member data. This makes it possible to reload the script code without having to recreate all the data.
Of course, all sorts of complications arise during this, and again it would take too long to go through them all. But as I hinted before one thing that saved me is that script objects are so closely connected to the engine data. When writing code that deals with serialization one of the biggest annoyances is that that class pointers with multiple inheritance can change their address when cast. Because the script language only returns void pointers (memory address with no type specified), you must be sure of the type it returns, something AngelScript allowed me to be.
Another fun thing with serialization are all the strange macros that you have to make. For example, this one was pretty fun:
#define ClassMemberClassOffset(aClass,aMember)
( size_t(static_cast
This one is used to make sure that class member offset address points correctly. It is one of the many things that make sure multiple inheritance problems, as explained above, does not screw things up. I got an entire header file just filled with fun stuff like this!
Closing notes
Once I had the system working it was quite an effort to add all the classes. There are countless classes that all need to be set up in specific way and everything to be saved needs to be initialized. Sitting several days in a row just coding stuff like this can really tear on the psyche. Fortunately, almost everything is added now, so the worst part should be over.
Another nice addition to the new script system is that it can auto generate the API function file for NotePad++. This allows NP++ to autocomplete any text that you write and you no longer need to keep function names or arguments list in your head (and skip the manual look-ups). What is annoying though is that it only works with global functions and NP++ cannot recognice what class a certain variable is in and show all its members (like visual assist can for C++). Does anybody know an editor that can manage this?
One thing that I was really eager to get working was threading. In Amnesia we use tons of special timer callbacks to set up events, and it would have been so nice to do something like this instead:
...
PlaySound("x");
Sleep(10)
PlaySound("y");
WaitUntilTriggered("a")
...
AngelScript does support this sort of thing, but there is currently no way of saving the state. So if the player where to save during a sleep, the game would be different when loaded. This is unfortunate, but I am looking into some other solutions instead. If anyone has ideas on this please share!
Right now I have only tried this system in some tests, but it still feels really good and works exactly as I want. It is just so great to be able to reload any code changes in a fraction of second. It allows for rapid iteration, makes one more productive and generally just makes it so much more enjoyable to code. It is also so gratifying to have an idea and then successfully implement it to the sort of quality you hoped for.
Addendum:
I earlier wrote that AngelScript was faster than Lua, which is not the case when it comes to code solely executed in the script (see here). So obviously my initial statement was not correct. However, I still think AngelScript must be faster in calling implemented c++ functions/types as there is pretty much no overlay involved. I do not have any data to back this up though, so do not take my word for it :)
Found this irresistibly interesting? We are hiring!
Risk Management and PGI
One risk that business owners face is the loss of their personal assets. Say you own Acme Widgets, a small C-Corporation that's looking to expand. One financial option open to you is a line of credit, but the bank wants you to sign for it with your personal signature, not just as the President of Acme Widgets. On the one hand, you really need the money; on the other, now your own personal assets are on the line.
What to do?
Well, Asterisk Insurance may have the answer: Personal Guarantee Insurance (PGI).
What PGI does is to "cover a substantial portion of all guarantors’ net liability to a lender if the underlying business should be unable to repay its bank loan."
You can actually cover up to 70% of that risk (which makes sense: any more and you run into moral hazard). It's pretty simple: if you have this coverage, and your business fails, the carrier will cover up to 70% of any shortfall, potentially saving a substantial amount of personal assets.
The rate's determined by the amount of the loan and nature of the business, so it could be expensive. But for additional peace of mind, and the opportunity to save or expand one's business, it's a pretty cool new tool.
[Hat Tip: FoIB Bill M]
Cavalcade of Risk #132: Call for submissions
NB: We're now using this submission tool: The BC WorkAround
Once there, you'll be asked to provide:
■ Your post's url and title
■ Your blog's url and name
■ Your name and email
■ A (brief) summary of the post ("Remarks")
At the bottom of the form, you'll see a drop-down menu; simply select "Cavalcade of Risk" then press "Submit" and you're good to go.
And PLEASE remember: ONLY posts that relate to risk (not personal finance tips and the like).
MVNHS©: Water, water, everywhere
Well, in Merry Ol' England, they're skipping the actual aspirin part, and prescribing Dihydrogen Monoxide:
"Doctors are prescribing drinking water for neglected elderly patients to stop them dying of thirst in hospital."
Apparently, some 800 (perhaps more) seniors die of dehydration in British hospitals every year. Another 300
It's almost as if a nationalized system of health care uses some kind of "death panel" to help keep costs down. Good thing they weren't smokers.
Midnight Mysteries 3: Devil on the Mississippi CE
Mark Twain’s ghost has come to you seeking help. When Twain’s passion for literary history reignites a controversial debate about the true identity of Shakespeare, the age-old question resurrects one of the most evil interested parties. After waking the evil spirit, Twain sets about to rid his time of the darkness, but the plot only thickens. With Twain’s help, you have to unravel the connections to try to set history straight in Midnight Mysteries: Devil on the Mississippi!
RIP, Chuck
Sometimes, though, real life has a way of delivering a wake-up call that even the most staid of professions can be dangerous:
"A KYW Newsradio traffic reporter has died — murdered, police say, in a random attack over the weekend ... The 52-year-old from Waterford, Camden County was doing another of his jobs — selling insurance and checking on clients." According to his obituary, Charles Fricker was apparently quite the entrepreneur: DJ, radio traffic guru, and agent for the Continental Insurance Company.
A full life, cut short way too soon.
Godspeed, Charles.
Memorial Day Health Wonk Review
Enjoy!
Can Medicare Be Saved?
The short answer is, "yes, yes it can be," but don't take just my word for it:
Supermarket Management 2
Recommended for free users: Use Jdownloader to increase download speed!
Tulula Legend of a Volcano
Screenshots: #1 , #2 , #3
Villa Banana
Screenshots: #1 , #2 , #3
Luxor HD
Wielding your mystical winged-shooter, you must fire colored orbs into the chain to make matches of three or more, and eliminate the spheres from the chain. Clear out the entire chain, and you’ll work your way up to the next level.
Screenshots:
Recommended for free users: Use Jdownloader to increase download speed!
MVNHS©: No Smoking, Christianity
Long-time readers may recall that Britain's Much Vaunted National Health System© appears quite willing to appease those who practice Islam (including forbidding "health care workers from eating at their desks during Ramadan"). Christians, on the other hand, are offered no such accommodation:
"A Christian doctor in England has been threatened with an official warning from his professional body for discussing Jesus with a patient ... Richard Scott, a doctor for 28 years, is under investigation ... and faces disciplinary action after he suggested to a 24-year-old man that he might find solace in Christianity."
Oh, the humanity!
Heaven forfend that a believer in some other Abrahamic faith should share harmless advice (and one wonders what Ezra Klein would counsel in that circumstance).
The MVNHS© authorities have "written to Scott suggesting he accept an official warning." but the good doctor is having none of that. In fact, he's fighting back against what "he believes is a politically correct trend in Britain to persecute Christians for expressing their faith in the workplace."
We wish him Godspeed in his efforts.
One hopes that Dr Scott refrained from "lighting one up" or sharing a snack while dispensing spiritual advice. As FoIB Bob D alerts us, the MVNHS© is now looking to curb care for smokers and weight-enhanced individuals:
"[MVNHS©] North Yorkshire and York are preventing certain operations for the obese and smokers because they say unhealthy lifestyles lower their chance of success ... Now the government is saying that although you've paid into the system throughout your life, unfortunately you will not be receiving treatment ... you are a second-class citizen because you smoke, drink or are obese."
Now, one may argue that there are, or should be, consequences for one's lifestyle choices. But this is the very embodiment of Death Panels. Good luck with that "stiff upper lip" thing.
Hidden Object Studios: I'll Believe You Special Edition
The film is done but the props are still on location! No props, no premiere! Watch “I’ll Believe You” in the screening room, pay attention to the props used in each scene, and then find them on location! Make it to the premier just in time to watch the exciting ending! Oh! And don’t forget your tuxedo. Starring David Alan Basche, Patrick Warburton, Chris Elliot, Ed Helms, Mo Rocca, Fred Willard, and Thomas Gibson.