-
Notifications
You must be signed in to change notification settings - Fork 3
/
Player.java
249 lines (210 loc) · 6.73 KB
/
Player.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
package org.gdc.gdcalaga;
import org.newdawn.slick.Color;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.SlickException;
import org.newdawn.slick.geom.Vector2f;
/*
* Upgrades planned for the player:
* Droppable: Health, shields, fire rate, more bullets, damage
* Buyable: Speed
*
* TODO
* Store the upgrades in an easily retrievable, searchable, and identifiable manner
* We want to have levels of upgrades, so this should be considered
* Create a shop at the end of a wave/stage (or something like that)
* for the player to buy upgrades.
* Create functionality for the player to be able to activate shields/invuln mode
* Create functionality for the player to have more guns
*/
public class Player extends Entity
{
private static final int SIZE_WIDTH = 49;
private static final int SIZE_HEIGHT = 29;
private static int totalPoints = 0; //the score is static in case we give players multiple lives in the future
Image ship;
//Upgradable Player attributes
private static float health;
private static float shields;
private static float fireRate; //fireRate in bullets per second
private static int numGuns;
private static float damage;
protected Vector2f velocity;
private static boolean shieldActivated;
//these values are intertwined with fireRate to create a standard fire rate
private static int ticksPerBullet;
private int ticksSinceLastBullet;
private GunPositions gunPositions;
public Player(EntityManager manager, Vector2f position)
{
super(manager);
pos.set(position);
size = new Vector2f(SIZE_WIDTH, SIZE_HEIGHT);
velocity = new Vector2f(220, 220);
damage = 1;
alliance = Alliance.FRIENDLY;
health = 10;
shields = 0;
fireRate = 5; //bullets per second
numGuns = 1;
ticksPerBullet = (int)(1000 / fireRate); //milliseconds in a second / fireRate
//since delta time is in milliseconds
ticksSinceLastBullet = ticksPerBullet; //so we can shoot right off the bat
shieldActivated = false;
shape = new RectShape(pos, size);
gunPositions = new GunPositions(SIZE_WIDTH, SIZE_HEIGHT);
try {
ship= new Image("Pics/Player.png");
} catch (SlickException e) {
e.printStackTrace();
}
}
public void update(float delta)
{
ticksSinceLastBullet += delta;
if (shields <= 0)
{
deactivateShield();
shields = 0;
}
RectShape rect = (RectShape)shape;
rect.pos.set(this.pos);
}
public void draw(Graphics g)
{
int drawX = (int)(pos.x - size.x / 2);
int drawY = (int)(pos.y - size.y / 2);
float scale = size.x / ship.getWidth();
ship.draw(drawX, drawY, scale, Color.white);
}
public void moveUp(float delta)
{
pos.y -= velocity.y * delta / 1000;
pos.y = Math.max(size.y / 2, pos.y);
}
public void moveDown(float delta)
{
pos.y += velocity.y * delta / 1000;
pos.y = Math.min(720 - size.y / 2, pos.y);
}
public void moveLeft(float delta)
{
pos.x -= velocity.x * delta / 1000;
pos.x = Math.max(0 + size.x / 2, pos.x);
}
public void moveRight(float delta)
{
pos.x += velocity.x * delta / 1000;
pos.x = Math.min(1280 - size.x / 2, pos.x);
}
public boolean fire(float delta)
{
//TODO add more firing positions and more bullets depending on the upgrades
if (ticksSinceLastBullet >= ticksPerBullet)
{
int max = numGuns < gunPositions.getSize() ? numGuns : gunPositions.getSize();
for (int i = 0; i < max; i++)
{
Vector2f position = new Vector2f(gunPositions.getPosition(i));
position.add(pos);
Bullet newBullet = new Bullet(entities, position, (int)(damage), alliance);
Vector2f direction = gunPositions.getDirection(i);
newBullet.setSpeed(direction.x * 500, direction.y * 500);
}
ticksSinceLastBullet = 0;
return true;
}
else
{
return false;
}
}
public boolean activateShield(float delta)
{
if (shields > 0)
{
shieldActivated = true;
shields -= delta;
return true;
}
else
{
deactivateShield();
shields = 0;
return false;
}
}
public void deactivateShield()
{
shieldActivated = false;
}
public void Collide(Entity other)
{
if(other instanceof Bullet && ((Bullet)other).getAlliance() != alliance)
{
Hurt(((Bullet)other).getDamage());
}
}
public void Hurt(float dmg)
{
if (shieldActivated)
return;
health -= dmg;
}
public float getHealth()
{
return health;
}
public float getShields()
{
return shields;
}
public Entity.Alliance getAlliance()
{
return alliance;
}
public static int getTotalPoints()
{
return totalPoints;
}
public static void increaseTotalPoints(int pointValue)
{
totalPoints += pointValue;
}
//my idea here is that ship upgrades will cost points to buy, like in most games.
public static void decreaseTotalPoints(int pointValue)
{
if(totalPoints - pointValue >= 0)
totalPoints -= pointValue;
else
System.out.println("Can't spend any more points!"); //TODO Fix error message
}
public static void upgrade(Upgrade.UpgradeType upgrade)
{
//TODO Change the health, hp/armor, fire rate, amount of guns, speed
//according to the upgrade passed in
switch (upgrade)
{
case HEALTH:
health += 5;
break;
case SHIELD:
shields += 3000; //Give 3 seconds worth of shielding
break;
case FIRE_RATE:
fireRate += .5; //Having these two variables separated makes it easier to debug and read
ticksPerBullet = (int)(1000 / fireRate); //A little bit weird that we have to do these two things...
break;
case NUM_GUNS:
numGuns++;
break;
case DAMAGE:
damage++;
break;
case INVALID_UPGRADE:
break;
default:
break;
}
}
}