Hard to tell without running code, and you don't even tell what is wrong...
Your long line has no spaces, making it hard to read, and is truncated (you can edit your message to add spaces allowing to wrap).

One thing strikes me: you seem to have an inverted logic.
Note for PointInViewAngle: verbs are preferred for functions, like enemyCanSeePlayer, and it makes more natural calls:
if (enemyCanSeePlayer(...)) // no need for == true, redundant
Currently, your method name doesn't tell what it returns.
You have a variable:
boolean seeMe = false;  //this is returned if the enemy can see the player
The comment contradicts the name of the variable!
Indeed, it is true when the enemy cannot see the player. But you test the reverse in the call...

2. That's not the point, we see your code in the browser where it doesn't look fine (although today I see an horizontal scrollbar not here the first time I saw it), and long lines without spaces are hard to read.
3. Ah, then perhaps isPointInViewAngle() might be easier to understand. Of course, this is only a suggestion, naming tastes vary a lot across programmers.
4. What I mean is that you seeMe to true when the point is outside of the angle, and false otherwise, which contradict both the name of the variable and the purpose of the function.

OK, looking more closely at the logic, it seems that I was reading too fast, I was confused by the max being on the left of the min. So the test is OK finally. Sorry for that.

Again, I can't run your code, so I can only look at the part you give, which roughly seems OK.
The only strange thing is the x*+16 part in the line calls.
And I don't see how these lines correspond to the coordinates of PointInViewAngle. I would expect the starting point of the lines to be the coordinates of the enemy.

General advice: when you fail to see what is wrong, put lot of println() with the values of the parameters, of the intermediary variables, and so on. Sometime, they don't have a value you expected, and you can add some other println() to see the reason, etc.

That's why I complain not to be able to run your code (not without time I don't really have).

Alternatively, you can try the shiny new debugger mode for Processing 2.0b (additional tool).

OK, I had some time this evening, so I made the simple wrapper I asked you in vain...
With some traces, I could find some logical errors (minAngle > maxAngle? using || in the test?) and an issue with angle sign, among other issues.
Here is a working version of your code:

1. int tileSize = 16;
2. int x, y;
3. int offsetX, offsetY;
4. PVector player1 = new PVector(250, 550);
5. float angle = PI / 2;
6. float coneAngle = PI / 4;
7.  
8. void setup()
9. {
10.   size(800, 800);
11.   frameRate(10);
12.  
13.   smooth();
14.   x = width / 2;
15.   y = height / 2;
16. }
17.  
18. void draw()
19. {
20.   background(255);
21.   playerDraw();
22.   enemiesDraw();
23. }
24.  
25. void keyPressed()
26. {
27.   if (key == CODED)
28.   {
29.     if (keyCode == LEFT) angle -= PI / 60;
30.     if (keyCode == RIGHT) angle += PI / 60;
31.   }
32. }
33.  
34. boolean PointInViewAngle(float objX, float objY, float coneX, float coneY, float coneDir) {
35.   boolean seeMe = false;  //this WILL BE returned as TRUE at the END of the funciton if the enemy can see the player
36.   float minAngle = coneDir - coneAngle / 2;  //the minimum angle of the code (ie 1 of the red lines)
37.   float maxAngle = coneDir + coneAngle / 2; //the max angle of the code (ie 1 the other red line)
38.  
39.   float thisAngle = -atan2(objY - coneY, objX - coneX);  // objX,objY = player, coneY = of the enemy)
40. //  println(minAngle + " " + thisAngle + " " + maxAngle);
41. //  println(degrees(minAngle) + " " + degrees(thisAngle) + " " + degrees(maxAngle));
42.   //Test if the angle is inside the 'cone' (between the min angle and max angle)
43.   if (minAngle < maxAngle) {
44.     if (thisAngle >= minAngle && thisAngle <= maxAngle) {
45.       seeMe = true;
46.     }
47.   }
48.   return seeMe;
49. }
50.  
51. void enemiesDraw() {
52.   noStroke();
53.   fill(255, 255, 128);
54.   ellipse(x, y, 20, 20);
55.  
56.   //Draw a visual representation of the cone of sight (+16 to center it on the enemy image)
57.   stroke(255, 0, 0);
58.   line(x, y, x + (cos(angle+coneAngle / 2)*400)*tileSize, y + (sin(angle+coneAngle / 2)*400*tileSize));
59.   line(x, y, x + (cos(angle-coneAngle / 2)*400)*tileSize, y + (sin(angle-coneAngle / 2)*400*tileSize));
60.  
61.   //if the enemy can see the player, print a message.
62.   if (PointInViewAngle(
63.       player1.x+offsetX, player1.y+offsetY,
64.       x*tileSize+offsetX, y*tileSize+offsetY,
65.       angle)) {
66.     println("I can see you");
67.   }
68. }
69.  
70. void playerDraw()
71. {
72.   noStroke();
73.   fill(0, 255, 128);
74.   ellipse(player1.x, player1.y, 10, 10);
75. }

OK, I made it more robust and more tested. I removed the tileSize multiplier, not knowing what it does in your code.
Hit the R key to move the player to a random place.

1. int tileSize = 16;
2. int x, y;
3. int offsetX, offsetY;
4. PVector player1 = new PVector(250, 550);
5. float angle = PI / 2;
6. float coneAngle = PI / 4;
7.  
8. void setup()
9. {
10.   size(800, 800);
11.   frameRate(10);
12.  
13.   smooth();
14.   x = width / 2;
15.   y = height / 2;
16. }
17.  
18. void draw()
19. {
20.   background(255);
21.   playerDraw();
22.   enemiesDraw();
23. }
24.  
25. void keyPressed()
26. {
27.   if (key == CODED)
28.   {
29.     if (keyCode == LEFT) angle -= PI / 60;
30.     if (keyCode == RIGHT) angle += PI / 60;
31.   }
32.   if (angle > TWO_PI) angle -= TWO_PI;
33.   if (angle < 0) angle += TWO_PI;
34.  
35.   if (key == 'r') // Random
36.   {
37.     player1 = new PVector(random(20, width - 20), random(20, height - 20));
38.   }
39. }
40.  
41. boolean PointInViewAngle(float objX, float objY, float coneX, float coneY, float coneDir) {
42.   boolean seeMe = false;  //this WILL BE returned as TRUE at the END of the funciton if the enemy can see the player
43.   float minAngle = coneDir - coneAngle / 2;  //the minimum angle of the code (ie 1 of the red lines)
44.   float maxAngle = coneDir + coneAngle / 2; //the max angle of the code (ie 1 the other red line)
45.  
46.   float thisAngle = atan2(objY - coneY, objX - coneX);  // objX,objY = player, coneY = of the enemy)
47.   if (thisAngle < 0)
48.     thisAngle += TWO_PI;
49. //  println(minAngle + " " + thisAngle + " " + maxAngle);
50. //  println(degrees(minAngle) + " " + degrees(thisAngle) + " " + degrees(maxAngle));
51.   //Test if the angle is inside the 'cone' (between the min angle and max angle)
52.   if (minAngle < maxAngle) {
53.     if (thisAngle >= minAngle && thisAngle <= maxAngle) {
54.       seeMe = true;
55.     }
56.   } else println(minAngle + " " + thisAngle + " " + maxAngle);
57.   return seeMe;
58. }
59.  
60. void enemiesDraw() {
61.   noStroke();
62.   fill(255, 255, 128);
63.   ellipse(x, y, 20, 20);
64.  
65.   //if the enemy can see the player, print a message.
66.   if (PointInViewAngle(
67.       player1.x + offsetX, player1.y + offsetY,
68.       x + offsetX, y + offsetY, // Removed the *tileSize, not knowing what it does
69.       angle)) {
70.     stroke(255, 0, 0);
71. //    println("I can see you");
72.   }
73.   else
74.   {
75.     stroke(255, 128, 0);
76.   }
77.   //Draw a visual representation of the cone of sight (+16 to center it on the enemy image)
78.   line(x, y, x + (cos(angle+coneAngle / 2)*400)*tileSize, y + (sin(angle+coneAngle / 2)*400*tileSize));
79.   line(x, y, x + (cos(angle-coneAngle / 2)*400)*tileSize, y + (sin(angle-coneAngle / 2)*400*tileSize));
80. }
81.  
82. void playerDraw()
83. {
84.   noStroke();
85.   fill(0, 255, 128);
86.   ellipse(player1.x, player1.y, 10, 10);
87. }