Merge pull request #155 from markus-wa/issue/132-player-additional-status-info

add Player.IsPlanting, Player.IsReloading and Player.IsAirborne()

Author: markus-wa

common/player.go

@@ -8,6 +8,13 @@ import (
 	st "github.com/markus-wa/demoinfocs-golang/sendtables"
 )
 
+const (
+	maxEdictBits                 = 11
+	entityHandleSerialNumberBits = 10
+	entityHandleBits             = maxEdictBits + entityHandleSerialNumberBits
+	invalidEntityHandle          = (1 << entityHandleBits) - 1
+)
+
 // Player contains mostly game-relevant player information.
 type Player struct {
 	demoInfoProvider demoInfoProvider // provider for demo info such as tick-rate or current tick
@@ -40,6 +47,8 @@ type Player struct {
 	IsConnected                 bool
 	IsDucking                   bool
 	IsDefusing                  bool
+	IsPlanting                  bool
+	IsReloading                 bool
 	HasDefuseKit                bool
 	HasHelmet                   bool
 }
@@ -65,6 +74,17 @@ func (p *Player) IsBlinded() bool {
 	return p.FlashDurationTimeRemaining() > 0
 }
 
+// IsAirborne returns true if the player is jumping or falling.
+func (p *Player) IsAirborne() bool {
+	if p.Entity == nil {
+		return false
+	}
+
+	groundEntityHandle := p.Entity.FindPropertyI("m_hGroundEntity").Value().IntVal
+
+	return groundEntityHandle == invalidEntityHandle
+}
+
 // FlashDurationTime returns the duration of the blinding effect as time.Duration instead of float32 in seconds.
 // Will return 0 if IsBlinded() returns false.
 func (p *Player) FlashDurationTime() time.Duration {

common/player_test.go

@@ -190,6 +190,22 @@ func TestPlayer_IsScoped(t *testing.T) {
 	assert.True(t, pl.IsScoped())
 }
 
+func TestPlayer_IsAirborne_NilEntity(t *testing.T) {
+	pl := new(Player)
+
+	assert.False(t, pl.IsAirborne())
+}
+
+func TestPlayer_IsAirborne(t *testing.T) {
+	pl := playerWithProperty("m_hGroundEntity", st.PropertyValue{IntVal: 0})
+
+	assert.False(t, pl.IsAirborne())
+
+	pl = playerWithProperty("m_hGroundEntity", st.PropertyValue{IntVal: 2097151})
+
+	assert.True(t, pl.IsAirborne())
+}
+
 func newPlayer(tick int) *Player {
 	return NewPlayer(mockDemoInfoProvider(128, tick))
 }

datatables.go

@@ -72,14 +72,27 @@ func (p *Parser) bindEntities() {
 func (p *Parser) bindBomb() {
 	bomb := &p.gameState.bomb
 
-	// Track bomb when it is not held by a player
-	scDroppedC4 := p.stParser.ServerClasses().FindByName("CC4")
-	scDroppedC4.OnEntityCreated(func(bomb *st.Entity) {
-		bomb.OnPositionUpdate(func(pos r3.Vector) {
+	// Track bomb when it is dropped on the ground or being held by a player
+	scC4 := p.stParser.ServerClasses().FindByName("CC4")
+	scC4.OnEntityCreated(func(bombEntity *st.Entity) {
+		bombEntity.OnPositionUpdate(func(pos r3.Vector) {
 			// Bomb only has a position when not held by a player
-			p.gameState.bomb.Carrier = nil
+			bomb.Carrier = nil
 
-			p.gameState.bomb.LastOnGroundPosition = pos
+			bomb.LastOnGroundPosition = pos
+		})
+
+		bombEntity.FindPropertyI("m_hOwner").OnUpdate(func(val st.PropertyValue) {
+			bomb.Carrier = p.gameState.Participants().FindByHandle(val.IntVal)
+		})
+
+		bombEntity.FindPropertyI("m_bStartedArming").OnUpdate(func(val st.PropertyValue) {
+			if val.IntVal != 0 {
+				p.gameState.currentPlanter = bomb.Carrier
+			} else if p.gameState.currentPlanter != nil {
+				p.gameState.currentPlanter.IsPlanting = false
+				p.eventDispatcher.Dispatch(events.BombPlantAborted{Player: p.gameState.currentPlanter})
+			}
 		})
 	})
 
@@ -91,14 +104,6 @@ func (p *Parser) bindBomb() {
 
 		bomb.LastOnGroundPosition = bombEntity.Position()
 	})
-
-	// Track bomb when it is being held by a player
-	scPlayerC4 := p.stParser.ServerClasses().FindByName("CC4")
-	scPlayerC4.OnEntityCreated(func(bombEntity *st.Entity) {
-		bombEntity.FindPropertyI("m_hOwner").OnUpdate(func(val st.PropertyValue) {
-			bomb.Carrier = p.gameState.Participants().FindByHandle(val.IntVal)
-		})
-	})
 }
 
 func (p *Parser) bindTeamStates() {
@@ -299,6 +304,7 @@ func (p *Parser) bindNewPlayer(playerEntity st.IEntity) {
 
 	// Active weapon
 	playerEntity.FindPropertyI("m_hActiveWeapon").OnUpdate(func(val st.PropertyValue) {
+		pl.IsReloading = false
 		pl.ActiveWeaponID = val.IntVal & entityHandleIndexMask
 	})
 
@@ -426,6 +432,10 @@ func (p *Parser) bindWeapon(entity *st.Entity, wepType common.EquipmentElement)
 
 	entity.FindPropertyI("m_iClip1").OnUpdate(func(val st.PropertyValue) {
 		eq.AmmoInMagazine = val.IntVal - 1
+
+		if eq.Owner != nil {
+			eq.Owner.IsReloading = false
+		}
 	})
 	// Some weapons in some demos might be missing this property
 	if reserveAmmoProp := entity.FindPropertyI("m_iPrimaryReserveAmmoCount"); reserveAmmoProp != nil {

demoinfocs_test.go

@@ -98,6 +98,46 @@ func TestDemoInfoCs(t *testing.T) {
 		}
 	})
 
+	// bomb planting checks
+	p.RegisterEventHandler(func(begin events.BombPlantBegin) {
+		if !begin.Player.IsPlanting {
+			t.Error("Player started planting but IsPlanting is false")
+		}
+	})
+	p.RegisterEventHandler(func(abort events.BombPlantAborted) {
+		if abort.Player.IsPlanting {
+			t.Error("Player aborted planting but IsPlanting is true")
+		}
+	})
+	p.RegisterEventHandler(func(planted events.BombPlanted) {
+		if planted.Player.IsPlanting {
+			t.Error("Player finished planting but IsPlanting is true")
+		}
+	})
+
+	// airborne checks
+	// we don't check RoundStart or RoundFreezetimeEnd since players may spawn airborne
+	p.RegisterEventHandler(func(plantBegin events.BombPlantBegin) {
+		if plantBegin.Player.IsAirborne() {
+			t.Error("Player is airborne during plant")
+		}
+	})
+
+	// reload checks
+	p.RegisterEventHandler(func(reload events.WeaponReload) {
+		if !reload.Player.IsReloading {
+			t.Error("Player started reloading but IsReloading is false")
+		}
+	})
+
+	p.RegisterEventHandler(func(start events.RoundFreezetimeEnd) {
+		for _, pl := range p.GameState().Participants().All() {
+			if pl.IsReloading {
+				t.Error("Player is reloading at the start of the round")
+			}
+		}
+	})
+
 	// Check some things at match start
 	p.RegisterEventHandler(func(events.MatchStart) {
 		participants := gs.Participants()

events/events.go

@@ -286,6 +286,13 @@ type BombPlantBegin struct {
 	BombEvent
 }
 
+// BombPlantAbort signals the abortion of a plant.
+type BombPlantAborted struct {
+	Player *common.Player
+}
+
+func (BombPlantAborted) implementsBombEventIf() {}
+
 // BombPlanted signals that the bomb has been planted.
 type BombPlanted struct {
 	BombEvent

game_events.go

@@ -281,8 +281,10 @@ func (geh gameEventHandler) weaponFire(data map[string]*msg.CSVCMsg_GameEventKey
 }
 
 func (geh gameEventHandler) weaponReload(data map[string]*msg.CSVCMsg_GameEventKeyT) {
+	pl := geh.playerByUserID32(data["userid"].GetValShort())
+	pl.IsReloading = true
 	geh.dispatch(events.WeaponReload{
-		Player: geh.playerByUserID32(data["userid"].GetValShort()),
+		Player: pl,
 	})
 }
 
@@ -433,11 +435,17 @@ func (geh gameEventHandler) playerTeam(data map[string]*msg.CSVCMsg_GameEventKey
 }
 
 func (geh gameEventHandler) bombBeginPlant(data map[string]*msg.CSVCMsg_GameEventKeyT) {
-	geh.dispatch(events.BombPlantBegin{BombEvent: geh.bombEvent(data)})
+	event := events.BombPlantBegin{BombEvent: geh.bombEvent(data)}
+	event.Player.IsPlanting = true
+	geh.parser.gameState.currentPlanter = event.Player
+	geh.dispatch(event)
 }
 
 func (geh gameEventHandler) bombPlanted(data map[string]*msg.CSVCMsg_GameEventKeyT) {
-	geh.dispatch(events.BombPlanted{BombEvent: geh.bombEvent(data)})
+	event := events.BombPlanted{BombEvent: geh.bombEvent(data)}
+	event.Player.IsPlanting = false
+	geh.parser.gameState.currentPlanter = nil
+	geh.dispatch(event)
 }
 
 func (geh gameEventHandler) bombDefused(data map[string]*msg.CSVCMsg_GameEventKeyT) {

game_state.go

@@ -26,6 +26,7 @@ type GameState struct {
 	isMatchStarted     bool
 	lastFlasher        *common.Player // Last player whose flash exploded, used to find the attacker for player_blind events
 	currentDefuser     *common.Player // Player currently defusing the bomb, if any
+	currentPlanter     *common.Player // Player currently planting the bomb, if any
 }
 
 type ingameTickNumber int