Have a Sager NP9150 or NP9170 with a steelseries keyboard?
This script lets you use the Fn functions on the keyboard by using Ctrl instead of Fn.
For example, to lower volume, you’d press CTRL+Left.
Have a Sager NP9150 or NP9170 with a steelseries keyboard?
This script lets you use the Fn functions on the keyboard by using Ctrl instead of Fn.
For example, to lower volume, you’d press CTRL+Left.
I have renamed BloxWar to “War of the Voxels”.
Also, I’ve uploaded a video of an approximately week-old build on YouTube, and I’ve created a website!
Video: http://www.youtube.com/watch?v=2G24R6uOrzU
Website: http://www.warofthevoxels.com/
Just thought I’d start a development log.
So, in the past few weeks, here’s what’s been added:
So what’s up next?
Hoping to get a public alpha release out by the beginning of August, and a beta release by winter break.
One big problem in session-tracking for websites (such as storing login details as cookies, remembering what was in someone’s shopping cart, etc.) is that the cookies can easily be stolen and used to imitate someon
Before we continue, let’s define some terms:
Cookie – A small text file stored on a computer that contains site data. A cookie has an expiration date and can easily be opened.
Session - Something that allows a server and a unique client to transfer information; i.e. a log-in session or a shopping session on an online store.
XSS Injection - Cross Site Scripting, or injecting unwanted scripts on a page. For example, adding some javascript that redirects the user when an image is clicked.
For example, if I were to login in to a site and use their “remember me” function, the site would probably store a cookie on my computer with some sort of authentication key to link my computer with a session. Now, what happens if someone takes the content of that cookie, places it on their machine, and goes to the website? The website will receive the cookie, authenticate it, and the person now has your account.
Now you may be asking, “how will he get the cookies?”
Wondering if your password was one of the 6.5 million that were leaked?
You’ll need a webserver that runs PHP to be able to use this script.
Download the leaked password list here:
https://anonfiles.com/file/a64e422331cc71df0e0963be24dddf4a (plain, uncompressed 259MB TXT)
http://cramit.in/z3jo9t5scyxl (compressed 118 MB ZIP)
Download my script
Copy & Paste: http://stuff.thewebsiteabout.me/linkedin_passwordcheck.php
OR
Download the code: http://stuff.thewebsiteabout.me/linkedin_passwordcheck.code
Place the PHP code in the same directory as the combo_not.txt, then run the script!
Good luck!
When I first installed Windows Server 2008 R2 on my desktop, everything went well…until I checked device manager and realized that a lot of my drivers were generic, and my system could be running faster.
Unfortunately, I had to go through several hours (ok, more like minutes, but that’s not the point) of trying to figure out how to bypass the annoying installers which would spew out “Your system does not meet the minimum requirements” because I was running a server installation, and not a desktop installation.
I would like to stress that this guide does not only apply to drivers, but to any program with an installer that checks for compatibility
Let’s get started!
1. First, you need to actually run the installer. If it doesn’t check (or is ok with a server installation), everything’s all good! You don’t have to read the rest of this guide.
Otherwise, you’ll need to do a bit of trickery in installing the driver.
If your driver software is in the form of an exe, read the following step. Otherwise, skip the next step (go to step 3).
2. First, you’ll need some archive extraction software, capable of opening CAB files. My favorite is WinRAR, but you can use something else, like 7zip. Basically, you just want to extract the actual EXE installer, as most are just self extracting archives, to a folder. If you are unable to extract the driver software from the installer, you’ll need to do some manual work and look for where the EXE extracts its driver files to (or you can cheat and use a hard drive file monitoring program
). After doing that, proceed to the next step…
2.5 At this point, if you are trying to install a program and not a driver, simply go to the folder and look for the installer file. If the file also tells you that the program isn’t compatible, try looking for an MSI file. (if this works, then you’re done, and you shouldn’t read the rest of the guide, which is for drivers only)
3. Now, go to device manager, and find the device that you want to install the driver for. Right click the device, and then click “Properties”, then click the “Driver” tab, and then click “Update Driver”. When it asks if you want to search automatically for driver software (which never works…) or browse for driver software, click the “browse for driver software” option, and select the folder where you extracted the driver software to. Make sure “Include subfolders” is checked. Finally, press the “Next” button, and Windows will start installing the driver.
4. After that, your driver software should be installed!
Bloom!
I exaggerated the bloom power a bit so that you could see it; I think I just might turn it down a bit in the future
I think I’ll work on the particle system now (aka rip it from my previous project
)
Bloom code:
So there are three parts in a bloom shader, but I only really have two stages.
1. Threshold out bright pixels
2. Apply Gaussian Blur Horizontally (of the thresholded image)
3. Apply Gaussian Blur Vertically (of the thresholded/blurred image)
4. (I guess this is technically a step?) Add the two pixel colors (blurred and original)
My bloom set-up is a two-pass shader, or, it creates the bloom with two passes (who would’ve guessed?).
My first shader, “ThresholdPostProcess.fx”, contains the following:
sampler TextureSampler : register(s0);
float ColorThreshold = 0.25f;
struct VertexShaderOutput
{
float2 uv : TEXCOORD0;
};
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
float4 pixColor = tex2D(TextureSampler, input.uv);
// clamp to [0, 1] and scale based on 1 - threshold
return saturate((pixColor - ColorThreshold) / (1.0f - ColorThreshold));
}
technique Technique1
{
pass Pass1
{
PixelShader = compile ps_2_0 PixelShaderFunction();
}
}
This is pretty simple stuff; you take the color of the current pixel, and you use saturate (which clamps values to the interval of [0, 1] on color – threshold (a value less than the threshold will be thrown out because it will yield a negative number, clamping it to 0) divided by 1.0f – threshold. This allows us to scale the extracted color.
In my second pass, I blur the thresholded image and combine the newly blurred image and raw frame.
sampler BloomSampler : register(s0);
sampler TextureSampler : register(s1);
float BlurPower;
float BaseIntensity, BaseSaturation;
float BloomIntensity, BloomSaturation;
const float2 SAMPLE_OFFSETS[12] = {
-0.326212, -0.405805,
-0.840144, -0.073580,
-0.695914, 0.457137,
-0.203345, 0.620716,
0.962340, -0.194983,
0.473434, -0.480026,
0.519456, 0.767022,
0.185461, -0.893124,
0.507431, 0.064425,
0.896420, 0.412458,
-0.321940, -0.932615,
-0.791559, -0.597705,
};
struct VertexShaderOutput
{
float2 uv : TEXCOORD0;
};
float4 AdjustSaturation(float4 color, float saturation)
{
float gray = dot(color, float3(0.3, 0.59, 0.11));
return lerp(gray, color, saturation);
}
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
float4 pixColor = tex2D(TextureSampler, input.uv);
// gaussian blur
float4 g_sum = tex2D(BloomSampler, input.uv);
for(int i = 0; i < 12; i++)
{
g_sum += tex2D(BloomSampler, input.uv + (BlurPower * SAMPLE_OFFSETS[i]));
}
// average
g_sum = g_sum / 13;
pixColor = AdjustSaturation(pixColor, BaseSaturation) * BaseIntensity;
g_sum = AdjustSaturation(g_sum, BloomSaturation) * BloomIntensity;
pixColor *= (1 - saturate(g_sum));
return pixColor + g_sum;
}
technique Technique1
{
pass Pass1
{
PixelShader = compile ps_2_0 PixelShaderFunction();
}
}
This is also pretty self-explanatory; we simply take the average of the 13 pixels (one which is the actual pixel, and 12 pixels that are around it), we adjust the saturation, and then we damp the original color a bit to avoid really really bright pixels. After that, we just add the original color and the averaged color together, and voila! You have bloom.
Using this is quite easy; you just render the scene you want bloom in to a render target, apply the threshold to the first rendertarget and save it to a second rendertarget, and then you take the second rendertarget, feed it into the last shader (remember to set GraphicsDevice.Textures[1] to your actual scene rendertarget), and out comes the bloom!
Pseudo code:
rendertarget rawframe = new rendertarget();
rendertarget threshold = new rendertarget();
GraphicsDevice.SetRenderTarget(rawframe);
DrawScene();
GraphicsDevice.SetRenderTarget(threshold);
sb.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, null, null, null, ThresholdEffect);
sb.Draw(rawFrame, Vector2.Zero, Color.White);
sb.End();
GraphicsDevice.SetRenderTarget(null); // reset to our back buffer
sb.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, null, null, null, BloomEffect);
SetBloomParameters();
GraphicsDevice.Textures[1] = rawframe;
sb.Draw(threshold, Vector2.Zero, Color.White);
sb.End();
// done!
The time has come to announce the name of my current project…
BloxWar!
As the name suggests, it has to do with blocks and war.
You might say, Well gee, isn’t this just another clone of Ace of Spades, or GunCraft????????
Well, sure, it shares the same gameplay concept, but I intend to make this different by…
- Giving a free to play experience
- Randomly generated, pre-built, or user-built maps
- Allowing private hosters to easily host their own servers
- Of course, destructible terrain!
- (Almost) hack-proof (read up here to see what measures I’ve taken to make the game as hack-proof as possible)
- Latency compensation
- a LOT of game-modes (will be revealed at a later date…
)
- Minecraft map compatibility (tool will be released to select chunks to be used)
Technical Details:
- Runs on .NET 4.0 with XNA 4.0 (mono support for other platforms is under development)
- Uses the Lidgren gen 3 Networking Library for fast reliable UDP networking
- 60 FPS framelock (should be smooth on intel cards as well; tested on my nVidia GT525M and a friend’s intel card)
- Uses simplex noise to generate terrain
- Can use any size map, although only a 10×10 chunk configuration has been tested (for performance)
- Low memory footprint (server: ~100,000 kb, client: ~300,000 kb) values are reported as of now
- Portable (server: 171KB on disk, client: 217KB on disk) values are reported as of now
Here’s a screenshot of the 0.0.1a private build (textures will be added soon!):
A more public, but still closed, test build (if that makes sense…) will be announced soon!
Looking for a way to wrap words by pixels/width? Look no further.
/// <summary>
/// Wordwraps a string by the given width
/// </summary>
/// <param name="sf">The spritefont (for measuring the string)</param>
/// <param name="_in">The input string to wrap</param>
/// <param name="width">The maximum width of the string, in pixels</param>
/// <returns>The same string, but wrapped on the width.</returns>
public static string Wordwrap(SpriteFont sf, string _in, float width)
{
float running_width = 0.0f;
string _out = "";
foreach (char c in _in)
{
float c_width = sf.MeasureString(c.ToString()).X;
if (running_width + c_width > width)
{
_out += "\r\n";
running_width = 0f;
}
_out += c;
running_width += c_width;
}
return _out;
}