user6947: This may well be too broad of a question.  I'm currently in the process of programming a chess engine, but this is difficult for me as I'm not actually that good of a chess player.  I'm having trouble coming up with 'rules' that can analyze a board and give a positive/negative score.  Currently I have the following:

penalty for knights on edge
bonus for further developed pieces
bonus for farther advanced pawns (closer to promotions)
different score for kings in the endgame
bonus if the player has the bishop pair
bonus if castled
assess layout as per these tables (some scrolling required)

I have access to all the information about a game; and functioning move validation.  The part I'm getting stuck on is coming up with more of these 'rules' that make the analysis engine better.  

user3594: I think the best way to get yourself acquainted with chess evaluation schemes, is just by looking up the documentations of some of open source (or GNU) chess engines out there, after all such questions have been asked/tackled for many years now, and there are many good answers out there that you need to explore before coming up with your own (hence all the variety of good engines today). 
Of course as things stand today, most of chess engines rely on evaluation systems that are (for the most part) heuristics-based. What is important before getting into some of the possibilities is to note that, there's no one single evaluation function that would solve chess, so what we really need (all we can hope for really) is a well weighted combination of many different evaluations, some of the main (usually mentioned) ones:

Pawn structure: if your engine is capable of noticing connected pawns, doubled pawns, blocked pawns, isolated pawns etc, then you're already doing pretty good.
Material: Probably the easiest part to implement, just get a total piece count for both sides and compare. Then compare by piece-type (how many bishops vs. how many knights etc)
King safety: Again pretty easy to implement evaluators such as: open lines/diagonals heading towards the king, likelihood of checks (within next 2-3 moves for simplicity), rights to castle, and so on. 
Individual piece evaluation: For each piece type, you should have a different evaluator, that measures its activity, e.g. by counting different possible moves the piece can make (total of 8 for the most active knight as example), openness of diagonals for bishops (also whether own-piece is blocking it or opponent piece, should be weighted differently), available squares for queen etc.
Mobility: A simpler version of the above if you will, i.e. just count the number possible moves each piece can make, and try to maximize it, i.e. the evaluator should add positively to the total evaluation function if from one move to next one (or more) of your pieces is gaining additional move possibilities.
Piece exposure: Just count how many of your pieces can be captured within a well defined ply (within next 2 moves e.g.). Such evaluators bring dynamics into your whole evaluation scheme, as based on them, you will then re-prioritize each of the previously mentioned evaluators (by re-distributing the weights initially assigned), you see it's a lot of fun implementing a chess engine ;)
Central control: Can be simple or very complex, the simple approach would be: defining a set squares that define what you call "center", then count how many pieces can potentially jump to those squares within next 1-2 moves, such approach should give you an estimate for central control.
More advanced features would be: Tempo considerations, to define such concepts in your engine, you need to have already covered all the basic evaluators. Connectivity or coordination of pieces come next, and so on.

Hope the few mentioned elements give you some rope already, of course there's a long way to go, but it's really important to first find out what's already been done and tried before you stumble on your own ideas. There's a must-check website for programming chess engines, have a look, you'll find tons of ideas and implementation suggestions: chessprogramming on wikispaces. If you need further clarifications, don't hesitate! Have fun implementing!

6947: <p>This may well be too broad of a question.  I'm currently in the process of programming a chess engine, but this is difficult for me as I'm not actually that good of a chess player.  I'm having trouble coming up with 'rules' that can analyze a board and give a positive/negative score.  Currently I have the following:</p>

<ul>
<li>penalty for knights on edge</li>
<li>bonus for further developed pieces</li>
<li>bonus for farther advanced pawns (closer to promotions)</li>
<li>different score for kings in the endgame</li>
<li>bonus if the player has the bishop pair</li>
<li>bonus if castled</li>
<li>assess layout as per <a href="http://chessprogramming.wikispaces.com/Simplified+evaluation+function">these tables</a> (some scrolling required)</li>
</ul>

<p>I have access to all the information about a game; and functioning move validation.  The part I'm getting stuck on is coming up with more of these 'rules' that make the analysis engine better.  </p>
 3594: <p>I think the best way to get yourself acquainted with chess evaluation schemes, is just by looking up the documentations of some of open source (or GNU) chess engines out there, after all such questions have been asked/tackled for many years now, and there are many good answers out there that you need to explore before coming up with your own (hence all the variety of good engines today). </p>

<p>Of course as things stand today, most of chess engines rely on evaluation systems that are (for the most part) heuristics-based. What is important before getting into some of the possibilities is to note that, there's no <em>one single evaluation function</em> that would solve chess, so what we really need (all we can hope for really) is a well weighted combination of many different evaluations, some of the main (usually mentioned) ones:</p>

<ul>
<li><p>Pawn structure: if your engine is capable of noticing connected pawns, doubled pawns, blocked pawns, isolated pawns etc, then you're already doing pretty good.</p></li>
<li><p>Material: Probably the easiest part to implement, just get a total piece count for both sides and compare. Then compare by piece-type (how many bishops vs. how many knights etc)</p></li>
<li><p>King safety: Again pretty easy to implement evaluators such as: open lines/diagonals heading towards the king, likelihood of checks (within next 2-3 moves for simplicity), rights to castle, and so on. </p></li>
<li><p>Individual piece evaluation: For each piece type, you should have a different evaluator, that measures its activity, e.g. by counting different possible moves the piece can make (total of 8 for the most active knight as example), openness of diagonals for bishops (also whether own-piece is blocking it or opponent piece, should be weighted differently), available squares for queen etc.</p></li>
<li><p>Mobility: A simpler version of the above if you will, i.e. just count the number possible moves each piece can make, and try to maximize it, i.e. the evaluator should add positively to the total evaluation function if from one move to next one (or more) of your pieces is gaining additional move possibilities.</p></li>
<li><p>Piece exposure: Just count how many of your pieces can be captured within a well defined ply (within next 2 moves e.g.). Such evaluators bring dynamics into your whole evaluation scheme, as based on them, you will then re-prioritize each of the previously mentioned evaluators (by re-distributing the weights initially assigned), you see it's a lot of fun implementing a chess engine ;)</p></li>
<li><p>Central control: Can be simple or very complex, the simple approach would be: defining a set squares that define what you call "center", then count how many pieces can potentially jump to those squares within next 1-2 moves, such approach should give you an estimate for central control.</p></li>
<li><p>More advanced features would be: Tempo considerations, to define such concepts in your engine, you need to have already covered all the basic evaluators. Connectivity or coordination of pieces come next, and so on.</p></li>
</ul>

<p>Hope the few mentioned elements give you some rope already, of course there's a long way to go, but it's really important to first <em>find out what's already been done and tried</em> before you stumble on your own ideas. There's a must-check website for programming chess engines, have a look, you'll find tons of ideas and implementation suggestions: <a href="https://chessprogramming.wikispaces.com/Evaluation" rel="nofollow">chessprogramming on wikispaces</a>. If you need further clarifications, don't hesitate! Have fun implementing!</p>
