/minild29

« back to all changes in this revision

Viewing changes to Dark.cpp

• browse files at revision 16
• compare with another revision
• download diff
• download tarball
• view history from revision 16

• reverse the comparison (16 to 32)
• stop comparing with revision 32

Show diffs side-by-side

added

removed

Dark.cpp

58

58

    bool xcol = false;

59

59

    bool ycol = false;

60

60

 

61

 

    Collider *collider = NULL;

62

 

 

63

61

    position.x += velocity.x * Monocle::deltaTime;

64

 

    while (Collide("Solid") || (collider = Collide("creature")))

 

62

    while (Collide("Solid"))

65

63

      {

66

 

        // Don't colide with hunters.  We should just die.

67

 

        if (collider) {

68

 

          Creature *c = (Creature *) collider->GetEntity();

69

 

          if (c->state == "hunt") { break; }

70

 

        }

71

 

 

72

64

        xcol = true;

73

65

        if (velocity.x == 0) { break; }

74

66

        //printf("collision1\n");

76

68

      }

77

69

    if (xcol) {velocity.x = 0;}

78

70

 

79

 

    collider = NULL;

80

71

    position.y += velocity.y * Monocle::deltaTime;

81

 

    while (Collide("Solid") || (collider = Collide("creature")))

 

72

    while (Collide("Solid"))

82

73

      {

83

 

        // Don't colide with hunters.  We should just die.

84

 

        if (collider) {

85

 

          Creature *c = (Creature *) collider->GetEntity();

86

 

          if (c->state == "hunt") { break; }

87

 

        }

88

 

 

89

74

        ycol = true;

90

75

        if (velocity.y == 0) { break; }

91

76

        //printf("collision2\n");

99

84

 

100

85

    // How far away can they hear your footsteps?

101

86

    // The circle is diameter 300 at MAXSPEED, 32 (2x your size) at 0 speed

102

 

    noisiness = ((magnitude / MAXSPEED *(400-64)) + 64) /2;

 

87

    noisiness = ((magnitude / MAXSPEED *(300-32)) + 32) /2;

103

88

 

104

89

    dark->position = position;

105

90

 

108

93

 

109

94

  Creature::Creature() : Entity(),

110

95

                         FRICTION(800),

111

 

                         ACCELERATION(1200),

112

 

                         DEFAULT_MAXSPEED(80.0f),

113

 

                         STALKSPEED(20.0f)

 

96

                         MAXSPEED(80.0f),

 

97

                         ACCELERATION(1200)                      

114

98

  {

115

99

    sprite = new SpriteAnimation("creature.png", FILTER_NONE, 64, 64);

116

100

    sprite->Add("idle", 0, 0, 0.35f);

117

101

    sprite->Add("move", 1, 2, 4.0f);

118

 

    sprite->Add("slowmove", 1, 2, 2.0f);

119

102

    sprite->Play("idle");

120

103

    SetGraphic(sprite);

121

104

    scale = Vector2(0.25, 0.25);

123

106

    AddTag("creature");

124

107

    SetCollider(new RectangleCollider(16, 16));

125

108

 

126

 

    alert = Assets::RequestAudio("alert.ogg");

127

 

    freakout = Assets::RequestAudio("freakout.ogg");

128

 

    chomp = Assets::RequestAudio("chomp.ogg");

129

109

    skitter1 = Audio::NewDeck(Assets::RequestAudio("skitter1.ogg"));

130

110

    skitter1->SetLoops(0); //loop indefinitely

131

 

    sniff = Audio::NewDeck(Assets::RequestAudio("sniff.ogg"));

132

 

    sniff->SetLoops(0);

133

111

 

134

 

    maxspeed = DEFAULT_MAXSPEED;

 

112

    velocity = Vector2::Random() * MAXSPEED;

135

113

 

136

114

    //set aiTime to random so creatures tick at different times

137

115

    aiTime= (float(rand()) / float(RAND_MAX)) * 1.0f;

138

 

 

139

 

    state = "idle";

140

116

  }

141

117

 

142

118

  void Creature::Update()

171

147

        if ( (player->position - position).GetSquaredMagnitude() < 

172

148

             pow(player->noisiness, 2) )

173

149

          {

174

 

            //printf("alert\n");

175

150

            state = "alert";

176

 

            alert->Play();

 

151

            // TODO: Play startled noise

177

152

            direction = Vector2::zero;

178

 

            Ping::NewPing(position, 8.0f, 32.0f, 0.15f); // ping diameter 16-64 over .5s

 

153

            // TODO: Play pulse animation (yellow?)

179

154

            aiTime = 0.0f; // diff variable?  stateTime?

180

155

          }

181

156

      } // if idle or wander

185

160

        

186

161

        // if we've been listening past the grace period and hear

187

162

        // something, switch state again

188

 

        // We hear the player at DOUBLE noisiness distance, cuz WE'RE LISNING!

189

 

        Player *player = ((DarkScene *)scene)->player;

190

 

        if ( aiTime > 1.0f && 

191

 

             (player->position - position).GetSquaredMagnitude() < 

192

 

             pow(player->noisiness * 2, 2) )

193

 

          {

194

 

            state = "stalk";

195

 

            Ping::NewPing(position, 8.0f, 32.0f, 0.15f);

196

 

            direction = (player->position - position).GetNormalized();

197

 

            maxspeed = STALKSPEED;

198

 

            aiTime = 0.0f;

199

 

          }

200

163

 

201

164

        // if we've been listening a long time, switch back to idle

202

 

        if (aiTime > 5.0f) {

203

 

          //printf("end alert\n");

204

 

          state = "idle";

205

 

          aiTime = 0.0f;

206

 

        }

207

 

      }

208

 

    else if (state == "stalk")

209

 

      {

210

 

        aiTime += Monocle::deltaTime;

211

 

 

212

 

        // Go to HUNT if:

213

 

        // * it's been >1s & we hear the player

214

 

        // * we collide with the player

215

 

        Player *player = ((DarkScene *)scene)->player;

216

 

        if ((aiTime > 1.0f &&  

217

 

             (player->position - position).GetSquaredMagnitude() < 

218

 

             pow(player->noisiness, 2) )

219

 

            || Collide("player")

220

 

            )

221

 

          {

222

 

            state = "hunt";

223

 

            direction = (player->position - position).GetNormalized();

224

 

            maxspeed = 0; // give them a running start

225

 

            sniff->Stop();

226

 

            freakout->Play();

227

 

            Ping::NewPing(position, 8.0f, 64.0f, 0.15f); 

228

 

            aiTime = 0.0f;

229

 

            noiseTime = 0.0f;

230

 

          }

231

 

 

232

 

        // Go back to IDLE if:

233

 

        // * we hit a wall

234

 

        // * we stalk for more than 10-15s

235

 

        if ((aiTime > 15.0f) || Collide("wall") || Collide("creaturewall"))

236

 

          {

237

 

            // play frustrated noise?

238

 

            state = "idle";

239

 

            aiTime = 0.0f;

240

 

            sniff->Stop();

241

 

            maxspeed = DEFAULT_MAXSPEED;

242

 

            direction = Vector2::zero;

243

 

          }

244

 

      }

245

 

    else if (state == "hunt")

246

 

      {

247

 

        aiTime += Monocle::deltaTime;

248

 

        noiseTime += Monocle::deltaTime;

249

 

        graceTime += Monocle::deltaTime;

250

 

 

251

 

        if ((graceTime > 1.0f) && (maxspeed != DEFAULT_MAXSPEED))

252

 

          maxspeed = DEFAULT_MAXSPEED;

253

 

 

254

 

        // if we hear the player (

255

 

        Player *player = ((DarkScene *)scene)->player;

256

 

        if ( (player->position - position).GetSquaredMagnitude() < 

257

 

             pow(player->noisiness, 2) )

258

 

          {

259

 

            direction = (player->position - position).GetNormalized();

260

 

            aiTime = 0.0f;

261

 

            if (noiseTime > 2.0f) {

262

 

              freakout->Play();

263

 

              Ping::NewPing(position, 8.0f, 64.0f, 0.15f);

264

 

              noiseTime = 0.0f;

265

 

            }

266

 

          }

267

 

 

268

 

        // I guess chill out if it's been a while

269

 

        if (aiTime > 15.0f) {

270

 

            state = "alert";

271

 

            //alert->Play();

272

 

            direction = Vector2::zero;

273

 

            aiTime = 0.0f;

274

 

            noiseTime = 0.0f;

275

 

            graceTime = 0.0f;

276

 

        }

277

 

 

278

 

        // if we collide with you, move you back to the starting point

279

 

        if (Collide("player")) {

280

 

          // TODO: first wait a second or 3?

281

 

          chomp->Play();

282

 

          DarkScene *scene = (DarkScene *) GetScene();

283

 

          Entity* playersp = scene->GetFirstEntityWithTag("playerspawner");

284

 

          scene->player->position = playersp->position;

285

 

        }

286

165

      }

287

166

 

288

167

    velocity += direction * ACCELERATION * Monocle::deltaTime;

290

169

    velocity.x = APPROACH(velocity.x, 0, FRICTION * Monocle::deltaTime);

291

170

    velocity.y = APPROACH(velocity.y, 0, FRICTION * Monocle::deltaTime);

292

171

 

293

 

    if (velocity.GetSquaredMagnitude() > pow(maxspeed, 2))

294

 

      velocity = velocity.GetNormalized() * maxspeed;

 

172

    if (velocity.GetSquaredMagnitude() > pow(MAXSPEED, 2))

 

173

      velocity = velocity.GetNormalized() * MAXSPEED;

295

174

 

296

175

    bool xcol = false;

297

176

    bool ycol = false;

298

177

 

299

178

    position.x += velocity.x * Monocle::deltaTime;

300

 

    while (Collide("Solid") || Collide("creaturewall"))

 

179

    while (Collide("Solid"))

301

180

      {

302

181

        xcol = true;

303

182

        if (velocity.x == 0) { break; }

307

186

    if (xcol) {velocity.x = 0;}

308

187

 

309

188

    position.y += velocity.y * Monocle::deltaTime;

310

 

    while (Collide("Solid") || Collide("creaturewall"))

 

189

    while (Collide("Solid"))

311

190

      {

312

191

        ycol = true;

313

192

        if (velocity.y == 0) { break; }

316

195

      }

317

196

    if (ycol) {velocity.y = 0;}

318

197

 

319

 

    Vector2 distance = ((DarkScene *)scene)->player->position - position;

320

 

    if (state == "stalk")

321

 

      {

322

 

        float vol = (distance.GetMagnitude() / -250.0f) + 1.0f;

323

 

        sniff->SetVolume(vol);

324

 

        sniff->Play();

325

 

        sprite->Play("slowmove");

326

 

      }

327

 

    else if (velocity.GetSquaredMagnitude() > 20)

328

 

      {

 

198

    if (velocity.GetSquaredMagnitude() > 20)

 

199

      {

 

200

        Vector2 distance = ((DarkScene *)scene)->player->position - position;

329

201

        // at distance 0, vol should be 1.0.  at 800, it should be 0.

330

 

        float vol = (distance.GetMagnitude() / -600.0f) + 1.0f;

 

202

        float vol = (distance.GetMagnitude() / -800.0f) + 1.0f;

331

203

        skitter1->SetVolume(vol);

332

204

        skitter1->Play();

333

205

        sprite->Play("move");

339

211

      }

340

212

  }

341

213

 

342

 

  Ping::Ping() : Entity(),

343

 

                 d1(0.0f), d2(0.0f), t(0.0f), t2(0.0f)

344

 

  {

345

 

    sprite = new Sprite("yellow.png", FILTER_LINEAR, 64, 64);

346

 

    SetGraphic(sprite);

347

 

    scale = Vector2::zero;

348

 

  }

349

 

 

350

 

  Ping *Ping::NewPing(Vector2 pos, float d1, float d2, float t2)

351

 

  {

352

 

    Ping *ping = new Ping();

353

 

    ping->d1 = d1;

354

 

    ping->d2 = d2;

355

 

    ping->t2 = t2;

356

 

    ping->position = pos;

357

 

 

358

 

    Game::GetScene()->Add(ping);

359

 

    return ping;

360

 

  }

361

 

 

362

 

  void Ping::Update()

363

 

  {

364

 

    Entity::Update();

365

 

 

366

 

    // once we're done LERPing, get gone

367

 

    if (t > t2)

368

 

      RemoveSelf();

369

 

 

370

 

    t += Monocle::deltaTime;

371

 

    float scaleFactor = LERP(d1/64, d2/64, t/t2);

372

 

    scale = Vector2(scaleFactor, scaleFactor);

373

 

  }

374

 

 

375

214

  // Scene

376

215

 

377

216

  DarkScene::DarkScene() : Scene()

406

245

    Level::LoadProject("project.xml");

407

246

    Level::Load("level.xml", this);

408

247

 

409

 

    HideSpawners();

410

 

    Spawn();

411

 

 

412

248

    std::list<Entity*> *walls = GetAllTag("wall");

413

249

    for (std::list<Entity*>::iterator i = walls->begin(); i != walls->end(); ++i)

414

250

      {

416

252

        Vector2 s = e->scale;

417

253

        e->SetCollider(new RectangleCollider(s.x * 64, s.y * 64));

418

254

      }

419

 

 

420

 

    std::list<Entity*> *creaturewalls = GetAllTag("creaturewall");

421

 

    for (std::list<Entity*>::iterator i = creaturewalls->begin(); i != creaturewalls->end(); ++i)

422

 

      {

423

 

        Entity *e = (*i);

424

 

        Vector2 s = e->scale;

425

 

        e->SetCollider(new RectangleCollider(s.x * 64, s.y * 64));

426

 

      }

427

255

   

428

 

    Graphics::SetBackgroundColor(Color::green * 0.2f);

429

 

 

430

 

  }

431

 

 

432

 

  void DarkScene::HideSpawners()

433

 

  {

434

 

    std::list<Entity*> *spawners = GetAllTag("spawner");

435

 

    if (spawners == NULL) {printf("NO SPAWNERS!!!\n");}

436

 

    for (std::list<Entity*>::iterator i = spawners->begin(); i != spawners->end(); ++i)

437

 

      (*i)->isVisible = false;

438

 

  }

439

 

 

440

 

  void DarkScene::ShowSpawners()

441

 

  {

442

 

    std::list<Entity*> *spawners = GetAllTag("spawner");

443

 

    for (std::list<Entity*>::iterator i = spawners->begin(); i != spawners->end(); ++i)

444

 

      (*i)->isVisible = true;

445

 

  }

446

 

  

447

 

  void DarkScene::Spawn()

448

 

  {

449

 

    Entity* playersp = GetFirstEntityWithTag("playerspawner");

450

256

    player = new Player();

451

 

    player->position = playersp->position;;

 

257

    player->position = Graphics::GetScreenCenter();

452

258

    Add(player);

453

259

    Add(player->dark);

454

260

 

455

 

    std::list<Entity*> *spawners = GetAllTag("creaturespawner");

456

 

    // Ugh, monocle is double-entering all the tags...

457

 

    spawners->sort();

458

 

    spawners->unique();

459

 

    for (std::list<Entity*>::iterator i = spawners->begin(); i != spawners->end(); ++i)

460

 

      {

461

 

        Creature *creature = new Creature();

462

 

        creature->position = (*i)->position;

463

 

        Add(creature);

464

 

      }

 

261

    Creature *creature = new Creature;

 

262

    creature->position = Graphics::GetScreenCenter();

 

263

    Add(creature);

 

264

 

 

265

    Creature *creature2 = new Creature;

 

266

    creature2->position = Graphics::GetScreenCenter();

 

267

    Add(creature2);

 

268

 

 

269

    Graphics::SetBackgroundColor(Color::green * 0.2f);

 

270

 

465

271

  }

466

272

 

467

273

  void DarkScene::Update()

492

298

            

493

299

            if (isPaused) {

494

300

              player->dark->isVisible = false;

495

 

              ShowSpawners();

496

301

              levelEditor->Enable();

497

302

            } else {

498

 

              HideSpawners();

499

303

              levelEditor->Disable();

500

304

              player->dark->isVisible = true;

501

305

            }

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1