[Aerosol]

I feel like that's been said numerous times already. I believe during the time when people first started suspecting that S2HD was going closed source.

[HeartAttack]

On another note, the debug mode - I'm pretty sure it becomes available after getting a perfect bonus on one or more of the zone acts. Every time I open up the demo now, debug mode is there.

[diplomacydog]

Tyty, on 29 March 2012 - 09:22 PM, said:

Regarding the art, I really just want to ask one question.

Why does the grey part of the eggmobile look like someone spent 5 minutes tracing it from the original sprite in flash?

The gradients on all the metal in this game REALLY bug me because they don't look like metal. :|

If I remember back in the community age of the product (with open suggestions and contributions), everyone was having a lot of trouble with the eggmobile looking like metal without looking out of place with the rest of the art. No one was quite able to fix it.

[Aerosol]

This is where some artistic license might help

[Volpino]

AerosolSP, on 29 March 2012 - 10:53 PM, said:

This is where some artistic license might help

It does look plastic-y, though. One property of metal is its reflective surface; the drill and lower part of the machine could have a green tint for the grass, for example, a blue tine for the sky on the upper parts, if that's possible.

The project IS still taking criticisms from the community, right?

This post has been edited by Volpino: 29 March 2012 - 11:16 PM

[Guess Who]

From the front page: Guest Editorial: In Which I Rain on the Sonic 2 HD Parade, written by yours truly.

This post has been edited by Guess Who: 29 March 2012 - 11:25 PM

[Vinchenz]

Not sure if its been posted yet but EVERYONE should read THIS.

I've known about this problem. More people should. And really, he should be kicked off the team.

However, I feel that whether he's kicked off or not, this project will never come to fruition. He gets kicked off, the engine will probably be pulled away and nobody will want to re-create it. He doesn't get kicked off the team and the team will suffer more headaches as the programmer holds onto the game as ransom for years before they all give up. Personally, I'd have left so I wouldn't have to deal with this bullshit.

Edit: AAaaaand Ninja'd.

This post has been edited by Vinchenz: 29 March 2012 - 11:27 PM

[Super Napalm]

I hope I'm not the only one seeing an Iceberg on the way, 'cos I certainly see it coming unless certain people get their shit together

This post has been edited by Super Napalm: 29 March 2012 - 11:32 PM

[Mercury]

Tanks, on 29 March 2012 - 09:45 PM, said:

But I digress. Comon' man. Throw us a nostalgia bone. It's the fucking title screen for christ sake. You're just going to give up because you can't make sonic not look angry? You've proven yourself a competent artist, now show some damn backbone and give

Wait, what? I thought the fact that Sonic looks the way he does was an homage to the real Sonic 2 Alpha, and that the final S2HD will have the right pose.

If that's not the case, I gave the team too much credit. But I hope that's not right.

[Tanks]

Mercury, on 30 March 2012 - 12:00 AM, said:

Tanks, on 29 March 2012 - 09:45 PM, said:

But I digress. Comon' man. Throw us a nostalgia bone. It's the fucking title screen for christ sake. You're just going to give up because you can't make sonic not look angry? You've proven yourself a competent artist, now show some damn backbone and give

Wait, what? I thought the fact that Sonic looks the way he does was an homage to the real Sonic 2 Alpha, and that the final S2HD will have the right pose.

If that's not the case, I gave the team too much credit. But I hope that's not right.

The excuse given to me by the S2HD staff was because the artist couldn't get it to look right so he settled for the next best thing. This is Sonic 2 Final. You want to throw in the alternate title just for kicks? That's cool. I certainly think the title screen is neat, but utterly inappropriate.

[Metal Man88]

Super Napalm, on 29 March 2012 - 11:31 PM, said:

I hope I'm not the only one seeing an Iceberg on the way, 'cos I certainly see it coming unless certain people get their shit together

This project appears to be on fire from my perspective.

The game loads in slow motion (with no loading screen and no idea if it will ever finish loading) and behaves wonkily if your monitor is not 1080P. Its requirements are absurd; and for all those years, there is only one level/two zones to show for it, and some silly DRM too.

I do not have the art chops to critique the art. However, I can say that I agree with Stealth in that the whole game seems to be like every surface emits light/is made out of ultra-reflective neon plastic. It's just kind of blinding, really.

It is true. People who don't like the game don't have to play it. Though I guess that's out of the question. I have a better question: Will there be a complete game for us to play in less than 20 years from now?

[GerbilSoft]

Hay guiz, I found the license agreement, and some other goodies!

AGREEMENT TO PLAY
IN ORDER TO PLAY THIS GAME ON THIS SYSTEM, ONE MUST AGREE TO THESE STATEMENTS:
THIS IS A NON-PROFIT FAN-BASED GAME AND THAT THIS GAME STATES NO INTENTION OF INFRINGING UPON ANY APPEARING TRADEMARKS.
DO YOU AGREE TO THESE STATEMENTS?

DECLINE OF AGREEMENT
YOU CHOOSED NOT TO AGREE TO THE PREVIOUSLY DISPLAYED STATEMENTS. THE GAME HAS BEEN SAFELY SHUTDOWN, AND YOU CAN NOW CLOSE THE GAME.
IF YOU BY ANY CHANCE REGRET YOUR CHOICE, OR MADE A MISTAKE, YOU CAN REDO IT BY RESTARTING THE GAME!

A RESOURCE READ REQUEST WAS DELAYED WHICH IS NOT ALLOWED. THE GAME HAS BEEN FORCED TO SHUTDOWN TO PREVENT ANY GAME DATA DAMAGE.

HACK DETECTION
ONE OR MORE GAME RESOURCES WERE MANIPULATED BY AN OUTSIDE SOURCE. THIS IS NOT ALLOWED AS SPECIFIED IN THE GAME LICENSE.
YOU MUST REINSTALL THE GAME AND ACCEPT THE GAME LICENSE AGAIN, TO CONTINUE TO PLAY THE GAME.

UPGRADE NEEDED
THE ONLINE SERVER COULDN'T VALIDATE YOU GAMEPLAY. ITS RESULT DIFFERED FROM YOURS.
UPGRADE YOUR SONIC 2 HD GAME TO FIX THE PROBLEM!

DO YOU WANT TO SAVE YOUR PROGRESS TO THE LOCAL GAME PROFILE INSTEAD?

INTERNAL PROTECTION ERROR.
A RESOURCE FILE WAS MISSING WHEN TRYING TO LOAD ONE OF THE GAME DATA RESOURCES. THE GAME NEEDS THE RESOURCE IN ORDER TO CONTINUE NORMAL GAMEPLAY.
PLEASE REINSTALL THE RESOURCE FILES INTO THE GAME DATA FOLDER TO CONTINUE PLAYING THE GAME.
IF YOU CHOOSE TO QUIT THE GAME AT THIS POINT, YOU MIGHT LOSE YOUR GAME PROGRESS!

FAILED TO ACCESS AN EXTERNAL GAME RESOURCE.
IT MIGHT BE OPENED BY ANOTHER PROGRAM.
DO YOU WANT TO TRY AGAIN?

ONE EXTERNAL GAME RESOURCE CONTAINED INVALID DATA.
PLEASE REINSTALL THE RESOURCE FILES INTO THE GAME DATA FOLDER TO CONTINUE PLAYING THE GAME.
IF YOU CHOOSE TO QUIT THE GAME AT THIS POINT, YOU MIGHT LOSE YOUR GAME PROGRESS!

OUT OF MEMORY
WHILE CREATING A GAME RESOURCE, A MEMORY ALLOCATION FAILED.
TRY CHANGING THE SETTINGS TO LOWER QUALITY.

INSUFFICIENT HARDWARE
WHILE CREATING A GAME RESOURCE, A DEVICE RESOURCE COULDN'T TO BE CREATED.
WHILE CREATING A GAME RESOURCE, A DEVICE RESOURCE COULDN'T BE INITIALIZED.

BONUS ROUND

sampler Texture0;                      // Base texture 
sampler Texture1;                      // Perturbed texture A8L8 
float unfDistortionAmount;     // Distortion amount set before primitive rendering 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 TexCoord1 : TEXCOORD1,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 vDistortion = tex2D (Texture1, TexCoord1); 
       float4 vPerturbed = TexCoord0 + vDistortion.r * unfDistortionAmount; 
       return tex2D (Texture0, vPerturbed) * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0); 

sampler Texture0;                      // Base texture 
sampler Texture1;                      // Perturbed texture A8L8 
sampler Texture2;                      // Alpha mask A8L8 
float unfDistortionAmount;     // Distortion amount set before primitive rendering 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 TexCoord1 : TEXCOORD1,  
                         float4 TexCoord2 : TEXCOORD2,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 rgbaOpacityMask = tex2D (Texture2, TexCoord2); 
       float4 vDistortion = tex2D (Texture1, TexCoord1) * rgbaOpacityMask; 
       float4 vPerturbed = TexCoord0 + vDistortion.r * unfDistortionAmount; 
       return tex2D (Texture0, vPerturbed) * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0); 

sampler Texture0;                      // Base texture 
sampler Texture1;                      // Perturbed texture A8L8 
float unfDistortionAmount;     // Distortion amount set before primitive rendering 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 TexCoord1 : TEXCOORD1,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0
       float4 vDistortion = tex2D (Texture1, TexCoord1); 
       float4 vPerturbed = TexCoord0 + vDistortion.r * unfDistortionAmount; 
       vPerturbed.y = TexCoord0.y; 
       return tex2D (Texture0, vPerturbed) * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0); 

varying vec2 TexCoord0, TexCoord1, TexCoord2, TexCoord3; 
uniform sampler2D Texture0;            // Base texture 
uniform sampler2D Texture1;            // Perturbed texture A8L8 
uniform float unfDistortionAmount;     // Distortion amount set before primitive rendering 
void main (void) 
       vec4 vDistortion = texture2D (Texture1, TexCoord1.xy); 
       vec2 vPerturbed = TexCoord0.xy + vDistortion.r * unfDistortionAmount; 
       gl_FragColor = texture2D (Texture0, vPerturbed) * gl_Color + vec4 (gl_SecondaryColor.r, gl_SecondaryColor.g, gl_SecondaryColor.b, 0.0); 

varying vec2 TexCoord0, TexCoord1, TexCoord2, TexCoord3; 
uniform sampler2D Texture0;            // Base texture 
uniform sampler2D Texture1;            // Perturbed texture A8L8 
uniform sampler2D Texture2;            // Alpha mask A8L8 
uniform float unfDistortionAmount;     // Distortion amount set before primitive rendering 
void main (void) 
       vec4 rgbaOpacityMask = texture2D (Texture2, TexCoord2.xy); 
       vec4 vDistortion = texture2D (Texture1, TexCoord1.xy) * rgbaOpacityMask; 
       vec2 vPerturbed = TexCoord0.xy + vDistortion.r * unfDistortionAmount; 
       gl_FragColor = texture2D (Texture0, vPerturbed) * gl_Color + vec4 (gl_SecondaryColor.r, gl_SecondaryColor.g, gl_SecondaryColor.b, 0.0); 

varying vec2 TexCoord0, TexCoord1, TexCoord2, TexCoord3; 
uniform sampler2D Texture0;            // Base texture 
uniform sampler2D Texture1;            // Perturbed texture A8L8 
uniform float unfDistortionAmount;     // Distortion amount set before primitive rendering 
void main (void) 
       vec4 vDistortion = texture2D (Texture1, TexCoord1.xy); 
       vec2 vPerturbed = TexCoord0.xy + vDistortion.r * unfDistortionAmount; 
       vPerturbed.y = TexCoord0.y; 
       gl_FragColor = texture2D (Texture0, vPerturbed) * gl_Color + vec4 (gl_SecondaryColor.r, gl_SecondaryColor.g, gl_SecondaryColor.b, 0.0); 

sampler Texture0;                      // Font mask A8L8 
float unfShadowDirectionX;     // Horizontal direction of shadow (-1/TexWidth) 
float unfShadowDirectionY;     // Vertical direction of shadow (-1/TexHeight) 
float unfShadowColorR;         // Red component of shadow color 
float unfShadowColorG;         // Green component of shadow color 
float unfShadowColorB;         // Blue component of shadow color 
float unfSteps;                        // Number of shadow steps in the shadow direction 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 rgbaFontMask = tex2D (Texture0, TexCoord0); 
       rgbaFontMask = saturate (rgbaFontMask * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0)); 
       float4 rgbaShadow = 0; 
       float2 vDirectionStep = float2 (unfShadowDirectionX, unfShadowDirectionY); 
       float2 vDirection = vDirectionStep; 
       if (unfSteps > 3.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 2.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 1.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 0.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       float4 rgbaShadowResult = float4 (unfShadowColorR, unfShadowColorG, unfShadowColorB, 1) * saturate (rgbaShadow.a); 
       rgbaFontMask = lerp (rgbaShadowResult, float4 (rgbaFontMask.r, rgbaFontMask.g, rgbaFontMask.b, 1), rgbaFontMask.a); 
       return rgbaFontMask; 

sampler Texture0;                      // Font mask A8L8 
sampler Texture1;                      // Font surface 
float unfShadowDirectionX;     // Horizontal direction of shadow (-1/TexWidth) 
float unfShadowDirectionY;     // Vertical direction of shadow (-1/TexHeight) 
float unfShadowColorR;         // Red component of shadow color 
float unfShadowColorG;         // Green component of shadow color 
float unfShadowColorB;         // Blue component of shadow color 
float unfSteps;                        // Number of shadow steps in the shadow direction 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 TexCoord1 : TEXCOORD1,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 rgbaFontMask = tex2D (Texture0, TexCoord0); 
       float4 rgbaFontSurface = tex2D (Texture1, TexCoord1); 
       rgbaFontSurface = saturate (rgbaFontSurface * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0)); 
       rgbaFontMask *= rgbaFontSurface; 
       float4 rgbaShadow = 0; 
       float2 vDirectionStep = float2 (unfShadowDirectionX, unfShadowDirectionY); 
       float2 vDirection = vDirectionStep; 
       if (unfSteps > 3.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 2.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 1.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 0.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       float4 rgbaShadowResult = float4 (unfShadowColorR, unfShadowColorG, unfShadowColorB, 1) * saturate (rgbaShadow.a); 
       rgbaFontMask = lerp (rgbaShadowResult, float4 (rgbaFontMask.r, rgbaFontMask.g, rgbaFontMask.b, 1), rgbaFontMask.a); 
       return rgbaFontMask; 

sampler Texture0;                      // Sprite map and glow A8L8 
float unfInnerColorR;          // Red component of inner color 
float unfInnerColorG;          // Green component of inner color 
float unfInnerColorB;          // Blue component of inner color 
float unfOuterColorR;          // Red component of outer color 
float unfOuterColorG;          // Green component of outer color 
float unfOuterColorB;          // Blue component of outer color 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 rgbaDualGlow = tex2D (Texture0, TexCoord0); 
       float4 rgbaOuterColor = float4 (unfOuterColorR, unfOuterColorG, unfOuterColorB, 1); 
       float4 rgbaInnerColor = float4 (unfInnerColorR, unfInnerColorG, unfInnerColorB, 1) - rgbaOuterColor; 
       float4 rgbaMix = saturate (rgbaDualGlow.r * rgbaInnerColor + rgbaOuterColor); 
       return float4 (rgbaMix.r, rgbaMix.g, rgbaMix.b, rgbaDualGlow.a) * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0); 

varying vec2 TexCoord0, TexCoord1, TexCoord2, TexCoord3; 
uniform sampler2D Texture0;            // Font mask A8L8 
uniform float unfShadowDirectionX;     // Horizontal direction of shadow (-1/TexWidth) 
uniform float unfShadowDirectionY;     // Vertical direction of shadow (-1/TexHeight) 
uniform float unfShadowColorR;         // Red component of shadow color 
uniform float unfShadowColorG;         // Green component of shadow color 
uniform float unfShadowColorB;         // Blue component of shadow color 
uniform float unfSteps;                        // Number of shadow steps in the shadow direction 
void main (void)  
       vec4 rgbaFontMask = texture2D (Texture0, TexCoord0.xy); 
       rgbaFontMask = clamp (rgbaFontMask * gl_Color + vec4 (gl_SecondaryColor.r, gl_SecondaryColor.g, gl_SecondaryColor.b, 0.0), 0.0, 1.0); 
       vec4 rgbaShadow = vec4 (0.0); 
       vec2 vDirectionStep = vec2 (unfShadowDirectionX, unfShadowDirectionY); 
       vec2 vDirection = vDirectionStep; 
       if (unfSteps > 3.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 2.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 1.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 0.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       vec4 rgbaShadowResult = vec4 (unfShadowColorR, unfShadowColorG, unfShadowColorB, 1.0) * clamp (rgbaShadow.a, 0.0, 1.0); 
       rgbaFontMask = mix (rgbaShadowResult, vec4 (rgbaFontMask.r, rgbaFontMask.g, rgbaFontMask.b, 1.0), rgbaFontMask.a); 
       gl_FragColor = rgbaFontMask;

varying vec2 TexCoord0, TexCoord1, TexCoord2, TexCoord3; 
uniform sampler2D Texture0;            // Font mask A8L8 
uniform sampler2D Texture1;            // Font surface 
uniform float unfShadowDirectionX;     // Horizontal direction of shadow (-1/TexWidth) 
uniform float unfShadowDirectionY;     // Vertical direction of shadow (-1/TexHeight) 
uniform float unfShadowColorR;         // Red component of shadow color 
uniform float unfShadowColorG;         // Green component of shadow color 
uniform float unfShadowColorB;         // Blue component of shadow color 
uniform float unfSteps;                        // Number of shadow steps in the shadow direction 
void main (void)  
       vec4 rgbaFontMask = texture2D (Texture0, TexCoord0.xy); 
       vec4 rgbaFontSurface = texture2D (Texture1, TexCoord1.xy); 
       rgbaFontSurface = clamp (rgbaFontSurface * gl_Color + vec4 (gl_SecondaryColor.r, gl_SecondaryColor.g, gl_SecondaryColor.b, 0.0), 0.0, 1.0); 
       rgbaFontMask *= rgbaFontSurface; 
       vec4 rgbaShadow = vec4 (0.0); 
       vec2 vDirectionStep = vec2 (unfShadowDirectionX, unfShadowDirectionY); 
       vec2 vDirection = vDirectionStep; 
       if (unfSteps > 3.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 2.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 1.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 0.0) 
               rgbaShadow += texture2D (Texture0, TexCoord0.xy + vDirectionStep); 
               vDirectionStep += vDirection; 
       vec4 rgbaShadowResult = vec4 (unfShadowColorR, unfShadowColorG, unfShadowColorB, 1.0) * clamp (rgbaShadow.a, 0.0, 1.0); 
       rgbaFontMask = mix (rgbaShadowResult, vec4 (rgbaFontMask.r, rgbaFontMask.g, rgbaFontMask.b, 1.0), rgbaFontMask.a); 
       gl_FragColor = rgbaFontMask; 

varying vec2 TexCoord0; 
uniform sampler2D Texture0;            // Sprite map and glow A8L8 
uniform float unfInnerColorR;          // Red component of inner color 
uniform float unfInnerColorG;          // Green component of inner color 
uniform float unfInnerColorB;          // Blue component of inner color 
uniform float unfOuterColorR;          // Red component of outer color 
uniform float unfOuterColorG;          // Green component of outer color 
uniform float unfOuterColorB;          // Blue component of outer color 
void main (void) 
       vec4 rgbaDualGlow = texture2D (Texture0, TexCoord0.xy); 
       vec4 rgbaOuterColor = vec4 (unfOuterColorR, unfOuterColorG, unfOuterColorB, 1.0); 
       vec4 rgbaInnerColor = vec4 (unfInnerColorR, unfInnerColorG, unfInnerColorB, 1.0) - rgbaOuterColor; 
       vec4 rgbaMix = clamp (rgbaDualGlow.r * rgbaInnerColor + rgbaOuterColor, 0.0, 1.0); 
       gl_FragColor = vec4 (rgbaMix.r, rgbaMix.g, rgbaMix.b, rgbaDualGlow.a) * gl_Color + vec4 (gl_SecondaryColor.r, gl_SecondaryColor.g, gl_SecondaryColor.b, 0.0); 

sampler Texture0;                      // Font mask A8L8 
float unfShadowDirectionX;     // Horizontal direction of shadow (-1/TexWidth) 
float unfShadowDirectionY;     // Vertical direction of shadow (-1/TexHeight) 
float unfShadowColorR;         // Red component of shadow color 
float unfShadowColorG;         // Green component of shadow color 
float unfShadowColorB;         // Blue component of shadow color 
float unfSteps;                        // Number of shadow steps in the shadow direction 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 rgbaFontMask = tex2D (Texture0, TexCoord0); 
       float4 rgbaShadow = 0; 
       float2 vDirectionStep = float2 (unfShadowDirectionX, unfShadowDirectionY); 
       float2 vDirection = vDirectionStep; 
       if (unfSteps > 2.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 1.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 0.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       float4 rgbaShadowResult = float4 (unfShadowColorR, unfShadowColorG, unfShadowColorB, 1) * saturate (rgbaShadow.a); 
       rgbaFontMask = lerp (rgbaShadowResult, float4 (rgbaFontMask.r, rgbaFontMask.g, rgbaFontMask.b, 1), rgbaFontMask.a); 

sampler Texture0;                      // Font mask A8L8 
sampler Texture1;                      // Font surface 
float unfShadowDirectionX;     // Horizontal direction of shadow (-1/TexWidth) 
float unfShadowDirectionY;     // Vertical direction of shadow (-1/TexHeight) 
float unfShadowColorR;         // Red component of shadow color 
float unfShadowColorG;         // Green component of shadow color 
float unfShadowColorB;         // Blue component of shadow color 
float unfSteps;                        // Number of shadow steps in the shadow direction 
float4 main (float4 TexCoord0 : TEXCOORD0,  
                         float4 TexCoord1 : TEXCOORD1,  
                         float4 rgbaDiffuse : COLOR0,  
                         float4 rgbaSpecular : COLOR1) : COLOR0 
       float4 rgbaFontMask = tex2D (Texture0, TexCoord0); 
       float4 rgbaFontSurface = tex2D (Texture1, TexCoord1); 
       rgbaFontMask *= rgbaFontSurface; 
       float4 rgbaShadow = 0; 
       float2 vDirectionStep = float2 (unfShadowDirectionX, unfShadowDirectionY); 
       float2 vDirection = vDirectionStep; 
       if (unfSteps > 2.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 1.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       if (unfSteps > 0.0) 
               rgbaShadow += tex2D (Texture0, TexCoord0 + vDirectionStep); 
               vDirectionStep += vDirection; 
       float4 rgbaShadowResult = float4 (unfShadowColorR, unfShadowColorG, unfShadowColorB, 1) * saturate (rgbaShadow.a); 
       rgbaFontMask = lerp (rgbaShadowResult, float4 (rgbaFontMask.r, rgbaFontMask.g, rgbaFontMask.b, 1), rgbaFontMask.a); 
       return rgbaFontMask * rgbaDiffuse + float4 (rgbaSpecular.r, rgbaSpecular.g, rgbaSpecular.b, 0);

EDIT: So I herd u liek creditz.

a TO 'RETRY' OR o
b TO 'CANCEL': 
a FOR 'YES' OR o
b FOR 'NO': 
a FOR 'YES', o
b FOR 'NO', OR o
c TO 'CANCEL': 
a TO 'ABORT', o
b TO 'RETRY', OR o
c TO 'IGNORE': 
a FOR 'OK' OR o
b TO 'CANCEL': 
PRESS ANY BUTTON TO CONTINUE
GAME EXCEPTION
GAME HALTED.
PERFECT BONUS
RING BONUS
TIME BONUS
THROUGH 
KNUCKLES
ALEXANDRA JANKY
MIKE HILLARD
CHRISTIAN PETERSON
JARED KASL
DAMIAN GROVE
LOSTTETRISTGM
RYAN HATHAWAY
VINCENZO MASTROROSATO
SONIC RETRO
SCARRED SUN
TEE LOPES
MUSICIAN
SPECIAL THANKS
WEB ARTIST
LEAD ANIMATOR
CHARACTER ARTIST
SNICKERSNACK
PROMOTIONAL ARTIST
CORNETTHEORY
BACKGROUND ARTIST
STAGE ARTIST
CERULEAN NIGHTS
GAME ARTIST
SCANLINE99
VISUALS DIRECTOR
TOOLS PROGRAMMER
LEAD PROGRAMMER
CANNED KARMA
PROJECT MANAGER
PROJECT LEADER
INTERACTION
DEATH  EGG
WING  FORTRESS
SKY  CHASE
METROPOLIS
OIL  OCEAN
HIDDEN  PALACE
MYSTIC  CAVE
HILL  TOP
CASINO  NIGHT
AQUATIC  RUIN
CHEMICAL  PLANT
EMERALD  HILL
EDIT MODE
unfOuterColorR
unfOuterColorG
unfOuterColorB
unfInnerColorR
unfInnerColorG
unfInnerColorB

(thx to roxahris for the logo)

This post has been edited by GerbilSoft: 30 March 2012 - 02:02 AM

[Hinchy]

Vinchenz, on 29 March 2012 - 11:26 PM, said:

He gets kicked off, the engine will probably be pulled away and nobody will want to re-create it.

There are other capable programmers and there are other engine projects. ESPECIALLY for a gameplay that, among us, is so well-understood and well-documented, a great engine suited to Sonic 2 HD's needs could be created.

Especially if it's open sourced. Too many programmers around here work completely alone. If a large handful of talented programmers got together with some sort of version control system in place, the best goddamn 2D Sonic fangame engine ever could get to a mostly-complete beta state in a few months.

Also, the HD graphics require almost no increase in programming skill from creating a game at a smaller resolution. If you have the high-resolution assets, you can make your game's resolution whatever the hell it wants to be. (It's not hard to create resolution-independence either, something that S2HD sorely lacks.)

This post has been edited by Hinchy: 30 March 2012 - 01:02 AM

[Gen]

Oh boy, is that some shader code I see?

Whelp, looks like I'm going to have a bit of fun picking this one apart.

[roxahris]

Rendering at 2048x2048 and downscaling using some kinda shitty box filter? Why, why why? Also, stuff that has been stated before.

Art is pretty, but Sonic ain't supposed to be green. Rings look horrible. Too thin - they try to look like shiny metal but end up looking invisible and not like rings at all. Onion rings painted with metallic paint, maybe.
Music is alright, but has too many orchestral hits and lacks or dampens some parts of the original music - and adds or changes others in bad ways. Not my sorta thing. I reckon it'd be better to take advantage from the original versions in the soundtrack CD.