Fillin' up my coffers with phat loot in Pike'n Shot (game does not run at gif wacky speed).



Also fake CRT POWER!

Yeah, I think it would be worth a try is all. See what you think.

I love the concept for this game btw, I was talking to a buddy of mine about a concept like this not so long ago. I really like the idea of boarding ships to loot them and then having a very organic reaction to your presence.

I think it allows for the player to have a lot of interesting choice that let them mess with the things they encounter in the game in fun ways. Like, do I sneak around and not arouse suspicion, or should I just shoot anything that moves so it can't shoot me and then destroy the core and jump away if they try to call for help.

I think it would be very interesting if lots of crazy stuff could happen. Like the ship you're robbing is a battle ship and suddenly gets attacked by an enemy battle ship. What do you do? Use the attack as a distraction and make away with loot quickly? Maybe the ship is losing the battle too badly and you're afraid the ship will be destroyed with you on it? The main cannon crew got killed by a direct hit on their gun bay, maybe you should go in there and man the cannon yourself, disable the enemy ship enough that you will have time to steal what you want to steal and then get away.

You broke onto a prison ship, recruit characters from their brigs? Make sure you don't let out the Xenophobe alien? etc.

I think there's lots of fun ideas.

The resolution of the sprites and the text in a lot of the game being inconsistent bothers me, visually. I know that text the same res as the sprites would be hard to fit into your currently designed UI, but I don't think it's really optimal or necessary to even be using text where you have it. A little lock icon in stead of "LOCKED", a simple green checkmark instead of "BOUGHT", visual and audio queues to tell me that an alarm is deactivated rather than than literal text "YOU JUST TURNED OFF AN ALARM, GOOD WORK, PLAYER."

It's not a big criticism, but just something I think would improve the overall look of the game.

I almost think this game would be even cooler if it looked like all of the current graphics were being displayed over some sort of holo projection table in a darkened sci-fi bridge room. You could even have people walking by hurriedly or leaning on the table, watching with anticipation and just never show their faces, only the parts of their bodies that are close to the table are lit a little.

What is this for, a kick starter or an early access campaign or something?

Hahaha, nice, the original Police Quest was such a great game. The rest of the series that followed it seems so crappy in comparison. There was an EGA charm and simplicity to the aesthetic of the original and how the game tried to fully simulate and tell this tale of an unbelievable day in the life of one (incredibly quickly promoted to) detective.

The pacing of that game might have made more sense if they had just done time lapse transitions after every time you did something in the game. Like, stop the drunk driver and then "Later that week...", bring the evidence to the court to stop that guy from getting bail or whatever, "Then a month later..." something like that.

The only thing I didn't like about that game was the damn poker game. What was with Sierra and forcing you to save file cheat to win gambling games in order to proceed in their adventure games? What is this, Casino Royale?

The timed life + pickups to refill aspect of this reminds me of the old Adventure Island games on the NES (I think they were called Wonder Boy outside of North America).

The art work in your game is wonderful. I love the overall design of the main character. There is both a beauty and a sort of brutalness to them.

From looking at it and not playing it though, the stiffness and speed of the walking in comparison to how weightless and fast the dash is seems overly disjointed to me. The sort of in-between run speed seemed like a lot more natural default movement but I never saw you moving like that while fighting anything. Also, the only being able to look left and right in what appears to be an iso-metric setting seems a little artificially limiting (Eventhough admittedly, my own game is kind of the same situation, heh). I would suggest you make your levels more horizontal in layout to alleviate this perhaps. I mean, it works for side scrolling beat'em ups and shmups (and pshmups? Well I think so >_>).

Oh sweet, do you mind if I try it out?

Those wall things look very strange... like units could just squeeze between them or something. Doesn't look very logical... ludonarratively weak I guess I would say. I don't fully understand why you think making all the joining wall tiles would be that much work.. I mean you made all the shoreline tiles for regular ground, right?

Could I suggest maybe just making something that looked like it was generating some sort of electrical wall? Like, the individual wall tiles would just be these little floating generator/relay things that daisy chained a sort of lightning/laser looking wall around. I think that would look a lot better, I dunno, just my opinion. You could even have the little "wall pods" cutely conform to the tile they were placed on. Like, if they have ground below them they sprout a little tripod like stand, if they are over water, then they sprout a buoy type bottom, if they are over a city they are an antenna type thing on top of the building, etc.

I want more clothes that are the colours of your game.

CRT EFFECTS BI***

Still plugging away at the operations manual.
Added Terrain and Structure profiles to the guide as well as some other random gameplay mechanics.

You wrote "factory" again in the Airport description.

I found a neat "CRT screen" effect shader on the web, but I've never used shaders before and I can't seem to get it working properly. If I do the second sprite batch in my code here normally without the effect of the shader, it renders fine. However, with the shader and the parameters I have provided, it just renders a few pixels up in the top left corner, where the faked "bezel" should be and sometimes the fake "screen" flashes one colour or an other.

Is there something wrong with the parameters I'm providing? I'm really stumped.

       

Code:

protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            viewport = GraphicsDevice.Viewport;
            soldierFont = Content.Load<SpriteFont>("SpriteFont1");

            ShaderRenderTarget = new RenderTarget2D(spriteBatch.GraphicsDevice, spriteBatch.GraphicsDevice.PresentationParameters.BackBufferWidth, spriteBatch.GraphicsDevice.PresentationParameters.BackBufferHeight, false, SurfaceFormat.Color, DepthFormat.None);
            WorkingTexture = new Texture2D(GraphicsDevice, SCREENWIDTH, SCREENHEIGHT);
            WorkingTexture1 = new Texture2D(GraphicsDevice, SCREENWIDTH, SCREENHEIGHT);

            effect = Content.Load<Effect>(@"cgwg-xna");
            projection = Matrix.CreateOrthographicOffCenter(0, viewport.Width, viewport.Height, 0, 0, 1);
            halfPixelOffset = Matrix.CreateTranslation(-0.5f, -0.5f, 0);
            effect.Parameters["World"].SetValue(Matrix.Identity);
            effect.Parameters["View"].SetValue(Matrix.Identity);
            effect.Parameters["Projection"].SetValue(halfPixelOffset * projection);
            effect.Parameters["Worldview"].SetValue(Matrix.Identity * Matrix.Identity);
            effect.Parameters["ViewProjection"].SetValue((Matrix.Identity * (halfPixelOffset * projection)));
            effect.Parameters["WorldViewProjection"].SetValue((Matrix.Identity * (halfPixelOffset * projection)));
            effect.Parameters["WorkingTexture"].SetValue(WorkingTexture);
            effect.Parameters["WorkingTexture1"].SetValue(WorkingTexture1);

and then

       

Code:

protected override void Draw(GameTime gameTime)
        {

            GraphicsDevice.SetRenderTarget(ShaderRenderTarget);
            GraphicsDevice.Viewport = viewport;
            GraphicsDevice.Clear(Color.Black);

            //get rid of blurry sprites
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);

            if (_currScreen != null)
            {
                _currScreen.draw(gameTime, spriteBatch);
            }
            base.Draw(gameTime);

            spriteBatch.End();

            GraphicsDevice.SetRenderTarget(null);
            effect.Parameters["SourceTexture"].SetValue(ShaderRenderTarget);
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, SamplerState.LinearWrap, DepthStencilState.None, RasterizerState.CullNone, effect);
            spriteBatch.Draw(ShaderRenderTarget, Vector2.Zero, Color.White);
            spriteBatch.End();
        }

the shader is pretty crazy and is as follows:
      
      

Code:

// Matrix Definitions for Scaler Effects
//

matrix World : WORLD;
matrix View : VIEW;
matrix Projection : PROJECTION;
matrix Worldview : WORLDVIEW; // world * view
matrix ViewProjection : VIEWPROJECTION; // view * projection
matrix WorldViewProjection : WORLDVIEWPROJECTION; // world * view * projection

//
// Source Texture Definition for Scaler Effects
//

// Image Dimentions
float2 SourceDims : SOURCEDIMS = {1024.0F, 768.0F};

// Size of one Texel
float2 TexelSize  : TEXELSIZE = 1.0F/768.0F;

//
// Source Texture
//
texture SourceTexture : SOURCETEXTURE;

sampler SourceSampler = sampler_state {
Texture   = (SourceTexture);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Clamp;
AddressV  = Clamp;
SRGBTEXTURE = FALSE;
};

sampler BilinearSourceSampler = sampler_state {
Texture   = (SourceTexture);
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = NONE;
AddressU  = Clamp;
AddressV  = Clamp;
SRGBTEXTURE = FALSE;
};

sampler SRGBSourceSampler = sampler_state {
Texture   = (SourceTexture);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Clamp;
AddressV  = Clamp;
SRGBTEXTURE = TRUE;
};

sampler SRGBBilinearSourceSampler = sampler_state {
Texture   = (SourceTexture);
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = NONE;
AddressU  = Clamp;
AddressV  = Clamp;
SRGBTEXTURE = TRUE;
};

//
// Working Texture and Working RenderTarget
// Same Dims as Source Texture
//
texture WorkingTexture : WORKINGTEXTURE;

sampler WorkingSampler = sampler_state {
Texture   = (WorkingTexture);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Clamp;
AddressV  = Clamp;
SRGBTEXTURE = FALSE;
};

texture WorkingTexture1 : WORKINGTEXTURE1;

sampler WorkingSampler1 = sampler_state {
Texture   = (WorkingTexture1);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Clamp;
AddressV  = Clamp;
SRGBTEXTURE = FALSE;
};

//
// procedural textures that selects which pixel to generate
//
texture OutputSelectTexture
<
string function = "GenerateOutputSelect"; // Function to generate from
int width = 2;
int height = 2;
>;

// TextureShader for the OutputSelectTexture
float4 GenerateOutputSelect(float3 Pos : POSITION) : COLOR
{
float4 ret = (float4)1;
if (Pos.x < 0.5 && Pos.y < 0.5) ret[0] = 0;
else if (Pos.y < 0.5) ret[1] = 0;
else if (Pos.x < 0.5) ret[2] = 0;
else ret[3] = 0;
return ret;
}

// Sampler for the OutputSelectTexture
sampler OutputSelectSampler = sampler_state
{
Texture   = (OutputSelectTexture);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Wrap;
AddressV  = Wrap;
SRGBTEXTURE = FALSE;
};

//
// A Simple Texture that can do a modulo (or frac) by a lookup, rather than by
// using a arithmetic instruction. Not entirely accurate
//
texture ModuloTexture
<
string function = "GenerateModulo"; // Function to generate from
int width = 16;
int height = 16;
>;

// TextureShader for the ModuloTexture
float4 GenerateModulo(float3 Pos : POSITION) : COLOR
{
return float4(Pos.x, Pos.y, 0, 0);
}

// Sampler for the ModuloTexture
sampler ModuloSampler = sampler_state
{
Texture   = (ModuloTexture);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Wrap;
AddressV  = Wrap;
SRGBTEXTURE = FALSE;
};

// The name of this effect
string name : NAME = "CRTFX";
float scaling : SCALING = 1.0;

// Comment the next line to disable interpolation in linear gamma (and gain speed).
#define LINEAR_PROCESSING

// Compensate for 16-235 level range as per Rec. 601.
#define REF_LEVELS

// Enable screen curvature.
#define CURVATURE

// Controls the intensity of the barrel distortion used to emulate the
// curvature of a CRT. 0.0 is perfectly flat, 1.0 is annoyingly
// distorted, higher values are increasingly ridiculous.
#define distortion 0.05

// Simulate a CRT gamma of 2.4.
#define inputGamma  2.4

// Compensate for the standard sRGB gamma of 2.2.
#define outputGamma 2.2

// Macros.
#define FIX(c) max(abs(c), 1e-5);
#define PI 3.141592653589

#ifdef REF_LEVELS
#       define LEVELS(c) max((c - 16.0 / 255.0) * 255.0 / (235.0 - 16.0), 0.0)
#else
#       define LEVELS(c) c
#endif

#ifdef LINEAR_PROCESSING
#       define TEX2D(c) pow(LEVELS(tex2D(SourceBorderSampler, (c))), inputGamma)
#else
#       define TEX2D(c) LEVELS(tex2D(SourceBorderSampler, (c)))
#endif

//
// Techniques
//

// combineTechnique: Final combine steps. Outputs to destination frame buffer
string combineTechique : COMBINETECHNIQUE = "CRTFX";

// preprocessTechnique: PreProcessing steps. Outputs to WorkingTexture
//string preprocessTechique : PREPROCESSTECHNIQUE = "";

struct VS_OUTPUT_PRODUCT
{
float4 Position : POSITION;
float2 pixel0 : TEXCOORD0;
float2 pixel1 : TEXCOORD1;
float2 abspos : TEXCOORD2;
};

sampler SourceBorderSampler = sampler_state {
Texture   = (SourceTexture);
MinFilter = POINT;
MagFilter = POINT;
MipFilter = NONE;
AddressU  = Clamp; //AddressU  = Border;
AddressV  = Clamp; //AddressV  = Border;
//SRGBTEXTURE = FALSE;
};

// vertex shader
VS_OUTPUT_PRODUCT VS_Product(
float3 Position : POSITION,
float2 TexCoord : TEXCOORD0)
{
VS_OUTPUT_PRODUCT Out = (VS_OUTPUT_PRODUCT)0;

// Do the standard vertex processing.
Out.Position = mul(half4(Position, 1), WorldViewProjection);

// Precalculate a bunch of useful values we'll need in the fragment
// shader.

// Texture coords.
Out.pixel0 = TexCoord;

// The size of one texel, in texture-coordinates.
Out.pixel1 = TexelSize;

// Resulting X pixel-coordinate of the pixel we're drawing.
// Assumes (-0.5, 0.5) quad and output size in World matrix
// as currently done in DOSBox D3D patch
Out.abspos = float2((Position.x + 0.5) * World._11, (Position.y - 0.5) * (-World._22));

return Out;
}

// Apply radial distortion to the given coordinate.
float2 radialDistortion(float2 coord, float2 pos)
{
pos /= float2(World._11, World._22);
float2 cc = pos - 0.5;
float dist = dot(cc, cc) * distortion;
return coord * (pos + cc * (1.0 + dist) * dist) / pos;
}

// Calculate the influence of a scanline on the current pixel.
//
// 'distance' is the distance in texture coordinates from the current
// pixel to the scanline in question.
// 'color' is the colour of the scanline at the horizontal location of
// the current pixel.
float4 scanlineWeights(float distance, float4 color)
{
// The "width" of the scanline beam is set as 2*(1 + x^4) for
// each RGB channel.
float4 wid = 2.0 + 2.0 * pow(color, 4.0);

// The "weights" lines basically specify the formula that gives
// you the profile of the beam, i.e. the intensity as
// a function of distance from the vertical center of the
// scanline. In this case, it is gaussian if width=2, and
// becomes nongaussian for larger widths. Ideally this should
// be normalized so that the integral across the beam is
// independent of its width. That is, for a narrower beam
// "weights" should have a higher peak at the center of the
// scanline than for a wider beam.
float4 weights = distance / 0.3;
return 1.4 * exp(-pow(weights * rsqrt(0.5 * wid), wid)) / (0.6 + 0.2 * wid);
}

half4 PS_Product ( in VS_OUTPUT_PRODUCT input ) : COLOR
{
// Here's a helpful diagram to keep in mind while trying to
// understand the code:
//
//  |      |      |      |      |
// -------------------------------
//  |      |      |      |      |
//  |  01  |  11  |  21  |  31  | <-- current scanline
//  |      | @    |      |      |
// -------------------------------
//  |      |      |      |      |
//  |  02  |  12  |  22  |  32  | <-- next scanline
//  |      |      |      |      |
// -------------------------------
//  |      |      |      |      |
//
// Each character-cell represents a pixel on the output
// surface, "@" represents the current pixel (always somewhere
// in the bottom half of the current scan-line, or the top-half
// of the next scanline). The grid of lines represents the
// edges of the texels of the underlying texture.

// Texture coordinates of the texel containing the active pixel.
#ifdef CURVATURE
float2 xy = radialDistortion(input.pixel0, input.abspos);
#else
float2 xy = input.pixel0;
#endif

// Of all the pixels that are mapped onto the texel we are
// currently rendering, which pixel are we currently rendering?
float2 ratio_scale = xy * SourceDims - 0.5;
float2 uv_ratio = frac(ratio_scale);

// Snap to the center of the underlying texel.
xy = (floor(ratio_scale) + 0.5) / SourceDims;

// Calculate Lanczos scaling coefficients describing the effect
// of various neighbour texels in a scanline on the current
// pixel.
float4 coeffs = PI * float4(1.0 + uv_ratio.x, uv_ratio.x, 1.0 - uv_ratio.x, 2.0 - uv_ratio.x);

// Prevent division by zero.
coeffs = FIX(coeffs);

// Lanczos2 kernel.
coeffs = 2.0 * sin(coeffs) * sin(coeffs / 2.0) / (coeffs * coeffs);

// Normalize.
coeffs /= dot(coeffs, 1.0);

// Calculate the effective colour of the current and next
// scanlines at the horizontal location of the current pixel,
// using the Lanczos coefficients above.
float4 col  = clamp(
mul(coeffs, float4x4(
TEX2D(xy + float2(-input.pixel1.r, 0.0)),
TEX2D(xy),
TEX2D(xy + float2(input.pixel1.x, 0.0)),
TEX2D(xy + float2(2.0 * input.pixel1.x, 0.0))
)), 0.0, 1.0);
float4 col2 = clamp(
mul(coeffs, float4x4(
TEX2D(xy + float2(-input.pixel1.x, input.pixel1.y)),
TEX2D(xy + float2(0.0, input.pixel1.y)),
TEX2D(xy + input.pixel1),
TEX2D(xy + float2(2.0 * input.pixel1.x, input.pixel1.y))
)), 0.0, 1.0);

#ifndef LINEAR_PROCESSING
col  = pow(col , inputGamma);
col2 = pow(col2, inputGamma);
#endif

// Calculate the influence of the current and next scanlines on
// the current pixel.
float4 weights  = scanlineWeights(uv_ratio.y, col);
float4 weights2 = scanlineWeights(1.0 - uv_ratio.y, col2);
float3 mul_res  = (col * weights + col2 * weights2).rgb;

// dot-mask emulation:
// Output pixels are alternately tinted green and magenta.
float3 dotMaskWeights = lerp(
float3(1.0, 0.7, 1.0),
float3(0.7, 1.0, 0.7),
floor(input.abspos.x % 2.0)
);

mul_res *= dotMaskWeights;

// Convert the image gamma for display on our output device.
mul_res = pow(abs(mul_res), 1.0 / outputGamma);

// Color the texel.
return half4(mul_res, 1.0);
}

technique CRTFX
{
pass P0
{
// shaders
VertexShader = compile vs_3_0 VS_Product();
PixelShader  = compile ps_3_0 PS_Product();
AlphaBlendEnable = FALSE;
ColorWriteEnable = RED|GREEN|BLUE|ALPHA;
//SRGBWRITEENABLE = FALSE;
}
}

The shader was originally made for emulators like DOSbox and was made by cgwg, Themaister, DOLLS and gulikoza

2. I don't like the way your character looks. 

I think he looks awesome.

Thinking about your screen size and camera/view style: Have you given any thought to having the view gradually push in the direction you are moving to give you a better view of things "off screen". A lot of modern platformers do something like this and it helps make things feel a lot less claustrophobic, having a sort of leaning camera that will sometimes settle back to centering the character when you are inactive.

Heh, I love that the main character is a little moth.

Yeah, I've been playing with the idea of aping on the sort of terrible perspective and depiction of relative scale that you see in a lot of late medieval art. You know, stuff like castle defenders barely fitting into tiny towers and that sort of thing. It sort of rhymes with the art of old sprite-based games in a lot of ways. If I can't realize it in the levels themselves, then at least in the map screen or maybe in level dialogs, sort of like what they did in later Dimahoo games with the little boss preview scrolls.

I love the perseverance you have on that project. When I first met you (6 years ago?) you were already working on this!
And it's getting awesomener every time I see it.

Hahaha, Well, perseverance would be good. I'd have finished the game 3 years ago if I had that. What I do have though, I would term "stubbornness". One day, if my perseverance can match that we may see a good game come out of this. Everyone always likes the WIP when they play it.

;_;

I'm working on it right now at least. I submitted it to MAGfest to try and get a fire under my ass after a bout of loss of motivation due to multiple factors recently.

I gotta get this finished, even after all this time I still love the concept. Also I have a lot of other games I have to make. At least this one fishing one...

@Panurge: Hehehe, thanks man. But I'm curious, will the Ro'gue show up again in Gladitorius? I love that guy.

Whaaat, a new babo? That's awesome to hear, David.

Also,

"Angry Birds in... Babo: Revolutions"

Ehh ehh? *shoudler nudging*

Is this going to work for Android as well as iOS?